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 
58 OmahaRequestParams::~OmahaRequestParams() {
59   if (!root_.empty())
60     test::SetImagePropertiesRootPrefix(nullptr);
61 }
62 
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   if (!image_props_.system_version.empty()) {
81     if (in_app_version == "ForcedUpdate") {
82       image_props_.system_version = in_app_version;
83     }
84     os_version_ = image_props_.system_version;
85   } else {
86     os_version_ = OmahaRequestParams::kOsVersion;
87   }
88   if (!in_app_version.empty())
89     image_props_.version = in_app_version;
90 
91   os_sp_ = image_props_.version + "_" + GetMachineType();
92   app_lang_ = "en-US";
93   hwid_ = system_state_->hardware()->GetHardwareClass();
94   if (CollectECFWVersions()) {
95     fw_version_ = system_state_->hardware()->GetFirmwareVersion();
96     ec_version_ = system_state_->hardware()->GetECVersion();
97   }
98 
99   if (image_props_.current_channel == mutable_image_props_.target_channel) {
100     // deltas are only okay if the /.nodelta file does not exist.  if we don't
101     // know (i.e. stat() returns some unexpected error), then err on the side of
102     // caution and say deltas are not okay.
103     struct stat stbuf;
104     delta_okay_ =
105         (stat((root_ + "/.nodelta").c_str(), &stbuf) < 0) && (errno == ENOENT);
106   } else {
107     LOG(INFO) << "Disabling deltas as a channel change to "
108               << mutable_image_props_.target_channel
109               << " is pending, with is_powerwash_allowed="
110               << utils::ToString(mutable_image_props_.is_powerwash_allowed);
111     // For now, disable delta updates if the current channel is different from
112     // the channel that we're sending to the update server because such updates
113     // are destined to fail -- the current rootfs hash will be different than
114     // the expected hash due to the different channel in /etc/lsb-release.
115     delta_okay_ = false;
116   }
117 
118   if (in_update_url.empty())
119     update_url_ = image_props_.omaha_url;
120   else
121     update_url_ = in_update_url;
122 
123   // Set the interactive flag accordingly.
124   interactive_ = in_interactive;
125 
126   dlc_module_ids_.clear();
127   // Set false so it will do update by default.
128   is_install_ = false;
129   return true;
130 }
131 
132 bool OmahaRequestParams::IsUpdateUrlOfficial() const {
133   return (update_url_ == constants::kOmahaDefaultAUTestURL ||
134           update_url_ == image_props_.omaha_url);
135 }
136 
137 bool OmahaRequestParams::CollectECFWVersions() const {
138   return base::StartsWith(
139              hwid_, string("PARROT"), base::CompareCase::SENSITIVE) ||
140          base::StartsWith(
141              hwid_, string("SPRING"), base::CompareCase::SENSITIVE) ||
142          base::StartsWith(hwid_, string("SNOW"), base::CompareCase::SENSITIVE);
143 }
144 
145 bool OmahaRequestParams::SetTargetChannel(const string& new_target_channel,
146                                           bool is_powerwash_allowed,
147                                           string* error_message) {
148   LOG(INFO) << "SetTargetChannel called with " << new_target_channel
149             << ", Is Powerwash Allowed = "
150             << utils::ToString(is_powerwash_allowed)
151             << ". Current channel = " << image_props_.current_channel
152             << ", existing target channel = "
153             << mutable_image_props_.target_channel
154             << ", download channel = " << download_channel_;
155   if (!IsValidChannel(new_target_channel, error_message)) {
156     return false;
157   }
158 
159   MutableImageProperties new_props;
160   new_props.target_channel = new_target_channel;
161   new_props.is_powerwash_allowed = is_powerwash_allowed;
162 
163   if (!StoreMutableImageProperties(system_state_, new_props)) {
164     if (error_message)
165       *error_message = "Error storing the new channel value.";
166     return false;
167   }
168   mutable_image_props_ = new_props;
169   return true;
170 }
171 
172 void OmahaRequestParams::UpdateDownloadChannel() {
173   if (download_channel_ != mutable_image_props_.target_channel) {
174     download_channel_ = mutable_image_props_.target_channel;
175     LOG(INFO) << "Download channel for this attempt = " << download_channel_;
176   }
177 }
178 
179 string OmahaRequestParams::GetMachineType() const {
180   struct utsname buf;
181   string ret;
182   if (uname(&buf) == 0)
183     ret = buf.machine;
184   return ret;
185 }
186 
187 bool OmahaRequestParams::IsValidChannel(const string& channel,
188                                         string* error_message) const {
189   if (image_props_.allow_arbitrary_channels) {
190     if (!base::EndsWith(channel, "-channel", base::CompareCase::SENSITIVE)) {
191       if (error_message) {
192         *error_message = base::StringPrintf(
193             "Invalid channel name \"%s\", must ends with -channel.",
194             channel.c_str());
195       }
196       return false;
197     }
198     return true;
199   }
200   if (GetChannelIndex(channel) < 0) {
201     string valid_channels = brillo::string_utils::JoinRange(
202         ", ", std::begin(kChannelsByStability), std::end(kChannelsByStability));
203     if (error_message) {
204       *error_message =
205           base::StringPrintf("Invalid channel name \"%s\", valid names are: %s",
206                              channel.c_str(),
207                              valid_channels.c_str());
208     }
209     return false;
210   }
211   return true;
212 }
213 
214 void OmahaRequestParams::set_root(const string& root) {
215   root_ = root;
216   test::SetImagePropertiesRootPrefix(root_.c_str());
217 }
218 
219 int OmahaRequestParams::GetChannelIndex(const string& channel) const {
220   for (size_t t = 0; t < arraysize(kChannelsByStability); ++t)
221     if (channel == kChannelsByStability[t])
222       return t;
223 
224   return -1;
225 }
226 
227 bool OmahaRequestParams::ToMoreStableChannel() const {
228   int current_channel_index = GetChannelIndex(image_props_.current_channel);
229   int download_channel_index = GetChannelIndex(download_channel_);
230 
231   return download_channel_index > current_channel_index;
232 }
233 
234 bool OmahaRequestParams::ShouldPowerwash() const {
235   if (!mutable_image_props_.is_powerwash_allowed)
236     return false;
237   // If arbitrary channels are allowed, always powerwash on channel change.
238   if (image_props_.allow_arbitrary_channels)
239     return image_props_.current_channel != download_channel_;
240   // Otherwise only powerwash if we are moving from less stable (higher version)
241   // to more stable channel (lower version).
242   return ToMoreStableChannel();
243 }
244 
245 string OmahaRequestParams::GetAppId() const {
246   return download_channel_ == "canary-channel" ? image_props_.canary_product_id
247                                                : image_props_.product_id;
248 }
249 
250 }  // namespace chromeos_update_engine
251