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
42 using std::map;
43 using std::string;
44 using std::vector;
45
46 namespace chromeos_update_engine {
47
48 const char OmahaRequestParams::kOsVersion[] = "Indy";
49
50 const 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
~OmahaRequestParams()58 OmahaRequestParams::~OmahaRequestParams() {
59 if (!root_.empty())
60 test::SetImagePropertiesRootPrefix(nullptr);
61 }
62
Init(const string & in_app_version,const string & in_update_url,bool in_interactive)63 bool 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 os_version_ = OmahaRequestParams::kOsVersion;
81 if (!in_app_version.empty())
82 image_props_.version = in_app_version;
83
84 os_sp_ = image_props_.version + "_" + GetMachineType();
85 app_lang_ = "en-US";
86 hwid_ = system_state_->hardware()->GetHardwareClass();
87 if (CollectECFWVersions()) {
88 fw_version_ = system_state_->hardware()->GetFirmwareVersion();
89 ec_version_ = system_state_->hardware()->GetECVersion();
90 }
91
92 if (image_props_.current_channel == mutable_image_props_.target_channel) {
93 // deltas are only okay if the /.nodelta file does not exist. if we don't
94 // know (i.e. stat() returns some unexpected error), then err on the side of
95 // caution and say deltas are not okay.
96 struct stat stbuf;
97 delta_okay_ = (stat((root_ + "/.nodelta").c_str(), &stbuf) < 0) &&
98 (errno == ENOENT);
99 } else {
100 LOG(INFO) << "Disabling deltas as a channel change to "
101 << mutable_image_props_.target_channel
102 << " is pending, with is_powerwash_allowed="
103 << utils::ToString(mutable_image_props_.is_powerwash_allowed);
104 // For now, disable delta updates if the current channel is different from
105 // the channel that we're sending to the update server because such updates
106 // are destined to fail -- the current rootfs hash will be different than
107 // the expected hash due to the different channel in /etc/lsb-release.
108 delta_okay_ = false;
109 }
110
111 if (in_update_url.empty())
112 update_url_ = image_props_.omaha_url;
113 else
114 update_url_ = in_update_url;
115
116 // Set the interactive flag accordingly.
117 interactive_ = in_interactive;
118 return true;
119 }
120
IsUpdateUrlOfficial() const121 bool OmahaRequestParams::IsUpdateUrlOfficial() const {
122 return (update_url_ == constants::kOmahaDefaultAUTestURL ||
123 update_url_ == image_props_.omaha_url);
124 }
125
CollectECFWVersions() const126 bool OmahaRequestParams::CollectECFWVersions() const {
127 return base::StartsWith(hwid_, string("SAMS ALEX"),
128 base::CompareCase::SENSITIVE) ||
129 base::StartsWith(hwid_, string("BUTTERFLY"),
130 base::CompareCase::SENSITIVE) ||
131 base::StartsWith(hwid_, string("LUMPY"),
132 base::CompareCase::SENSITIVE) ||
133 base::StartsWith(hwid_, string("PARROT"),
134 base::CompareCase::SENSITIVE) ||
135 base::StartsWith(hwid_, string("SPRING"),
136 base::CompareCase::SENSITIVE) ||
137 base::StartsWith(hwid_, string("SNOW"), base::CompareCase::SENSITIVE);
138 }
139
SetTargetChannel(const string & new_target_channel,bool is_powerwash_allowed,string * error_message)140 bool OmahaRequestParams::SetTargetChannel(const string& new_target_channel,
141 bool is_powerwash_allowed,
142 string* error_message) {
143 LOG(INFO) << "SetTargetChannel called with " << new_target_channel
144 << ", Is Powerwash Allowed = "
145 << utils::ToString(is_powerwash_allowed)
146 << ". Current channel = " << image_props_.current_channel
147 << ", existing target channel = "
148 << mutable_image_props_.target_channel
149 << ", download channel = " << download_channel_;
150 if (!IsValidChannel(new_target_channel)) {
151 string valid_channels = brillo::string_utils::JoinRange(
152 ", ",
153 std::begin(kChannelsByStability),
154 std::end(kChannelsByStability));
155 if (error_message) {
156 *error_message = base::StringPrintf(
157 "Invalid channel name \"%s\", valid names are: %s",
158 new_target_channel.c_str(), valid_channels.c_str());
159 }
160 return false;
161 }
162
163 MutableImageProperties new_props;
164 new_props.target_channel = new_target_channel;
165 new_props.is_powerwash_allowed = is_powerwash_allowed;
166
167 if (!StoreMutableImageProperties(system_state_, new_props)) {
168 if (error_message)
169 *error_message = "Error storing the new channel value.";
170 return false;
171 }
172 mutable_image_props_ = new_props;
173 return true;
174 }
175
UpdateDownloadChannel()176 void OmahaRequestParams::UpdateDownloadChannel() {
177 if (download_channel_ != mutable_image_props_.target_channel) {
178 download_channel_ = mutable_image_props_.target_channel;
179 LOG(INFO) << "Download channel for this attempt = " << download_channel_;
180 }
181 }
182
GetMachineType() const183 string OmahaRequestParams::GetMachineType() const {
184 struct utsname buf;
185 string ret;
186 if (uname(&buf) == 0)
187 ret = buf.machine;
188 return ret;
189 }
190
IsValidChannel(const string & channel) const191 bool OmahaRequestParams::IsValidChannel(const string& channel) const {
192 return GetChannelIndex(channel) >= 0;
193 }
194
set_root(const string & root)195 void OmahaRequestParams::set_root(const string& root) {
196 root_ = root;
197 test::SetImagePropertiesRootPrefix(root_.c_str());
198 }
199
GetChannelIndex(const string & channel) const200 int OmahaRequestParams::GetChannelIndex(const string& channel) const {
201 for (size_t t = 0; t < arraysize(kChannelsByStability); ++t)
202 if (channel == kChannelsByStability[t])
203 return t;
204
205 return -1;
206 }
207
to_more_stable_channel() const208 bool OmahaRequestParams::to_more_stable_channel() const {
209 int current_channel_index = GetChannelIndex(image_props_.current_channel);
210 int download_channel_index = GetChannelIndex(download_channel_);
211
212 return download_channel_index > current_channel_index;
213 }
214
GetAppId() const215 string OmahaRequestParams::GetAppId() const {
216 return download_channel_ == "canary-channel" ? image_props_.canary_product_id
217 : image_props_.product_id;
218 }
219
220 } // namespace chromeos_update_engine
221