blob: 958633d8357d0152335733bedf2844b7a8a5e483 [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
2// Copyright (C) 2012 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//
rspangler@google.com49fdf182009-10-10 00:57:34 +000016
Amin Hassaniec7bc112020-10-29 16:47:58 -070017#ifndef UPDATE_ENGINE_CROS_OMAHA_REQUEST_ACTION_H_
18#define UPDATE_ENGINE_CROS_OMAHA_REQUEST_ACTION_H_
rspangler@google.com49fdf182009-10-10 00:57:34 +000019
Alex Vakulenko44cab302014-07-23 13:12:15 -070020#include <fcntl.h>
rspangler@google.com49fdf182009-10-10 00:57:34 +000021#include <sys/stat.h>
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070022#include <sys/types.h>
rspangler@google.com49fdf182009-10-10 00:57:34 +000023
Alex Deymob3fa53b2016-04-18 19:57:58 -070024#include <map>
Ben Chan02f7c1d2014-10-18 15:18:02 -070025#include <memory>
rspangler@google.com49fdf182009-10-10 00:57:34 +000026#include <string>
Jay Srinivasan6f6ea002012-12-14 11:26:28 -080027#include <vector>
rspangler@google.com49fdf182009-10-10 00:57:34 +000028
Alex Deymoc1c17b42015-11-23 03:53:15 -030029#include <gtest/gtest_prod.h> // for FRIEND_TEST
30
Jae Hoon Kime2cac612020-11-02 18:30:29 -080031#include <base/optional.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070032#include <brillo/secure_blob.h>
rspangler@google.com49fdf182009-10-10 00:57:34 +000033#include <curl/curl.h>
34
Alex Deymo39910dc2015-11-09 17:04:30 -080035#include "update_engine/common/action.h"
36#include "update_engine/common/http_fetcher.h"
Amin Hassaniec7bc112020-10-29 16:47:58 -070037#include "update_engine/cros/omaha_request_builder_xml.h"
38#include "update_engine/cros/omaha_response.h"
rspangler@google.com49fdf182009-10-10 00:57:34 +000039
Darin Petkov6a5b3222010-07-13 14:55:28 -070040// The Omaha Request action makes a request to Omaha and can output
41// the response on the output ActionPipe.
rspangler@google.com49fdf182009-10-10 00:57:34 +000042
Zentaro Kavanagh1f899d52018-02-27 15:02:47 -080043namespace policy {
44class PolicyProvider;
45}
46
rspangler@google.com49fdf182009-10-10 00:57:34 +000047namespace chromeos_update_engine {
48
rspangler@google.com49fdf182009-10-10 00:57:34 +000049class NoneType;
Darin Petkova4a8a8c2010-07-15 22:21:12 -070050class OmahaRequestAction;
Yunlian Jianga178e5e2013-04-05 14:41:56 -070051class OmahaRequestParams;
rspangler@google.com49fdf182009-10-10 00:57:34 +000052
David Zeuthene8ed8632014-07-24 13:38:10 -040053// This struct is declared in the .cc file.
54struct OmahaParserData;
55
Amin Hassani7cc8bb02019-01-14 16:29:47 -080056template <>
Darin Petkov6a5b3222010-07-13 14:55:28 -070057class ActionTraits<OmahaRequestAction> {
rspangler@google.com49fdf182009-10-10 00:57:34 +000058 public:
Darin Petkov0dc8e9a2010-07-14 14:51:57 -070059 // Takes parameters on the input pipe.
Darin Petkova4a8a8c2010-07-15 22:21:12 -070060 typedef NoneType InputObjectType;
Darin Petkov0dc8e9a2010-07-14 14:51:57 -070061 // On UpdateCheck success, puts the Omaha response on output. Event
62 // requests do not have an output pipe.
Darin Petkov6a5b3222010-07-13 14:55:28 -070063 typedef OmahaResponse OutputObjectType;
rspangler@google.com49fdf182009-10-10 00:57:34 +000064};
65
Darin Petkov6a5b3222010-07-13 14:55:28 -070066class OmahaRequestAction : public Action<OmahaRequestAction>,
67 public HttpFetcherDelegate {
rspangler@google.com49fdf182009-10-10 00:57:34 +000068 public:
Darin Petkov1cbd78f2010-07-29 12:38:34 -070069 static const int kPingTimeJump = -2;
Jae Hoon Kima3210e62020-05-07 11:32:44 -070070 // We choose this value of 3 as a heuristic for a work day in trying
Jay Srinivasan2b5a0f02012-12-19 17:25:56 -080071 // each URL, assuming we check roughly every 45 mins. This is a good time to
Jae Hoon Kima3210e62020-05-07 11:32:44 -070072 // wait so we don't give up the preferred URLs, but allow using the URL that
73 // appears earlier in list for every payload before resorting to the fallback
74 // URLs in the candiate URL list.
75 static const int kDefaultMaxFailureCountPerUrl = 3;
Darin Petkov1cbd78f2010-07-29 12:38:34 -070076
Adolfo Victoria497044c2018-07-18 07:51:42 -070077 // If staging is enabled, set the maximum wait time to 28 days, since that is
78 // the predetermined wait time for staging.
79 static const int kMaxWaitTimeStagingInDays = 28;
80
Jay Srinivasan480ddfa2012-06-01 19:15:26 -070081 // These are the possible outcome upon checking whether we satisfied
82 // the wall-clock-based-wait.
83 enum WallClockWaitResult {
84 kWallClockWaitNotSatisfied,
85 kWallClockWaitDoneButUpdateCheckWaitRequired,
86 kWallClockWaitDoneAndUpdateCheckWaitNotRequired,
87 };
88
Darin Petkov0dc8e9a2010-07-14 14:51:57 -070089 // The ctor takes in all the parameters that will be used for making
90 // the request to Omaha. For some of them we have constants that
91 // should be used.
92 //
rspangler@google.com49fdf182009-10-10 00:57:34 +000093 // Takes ownership of the passed in HttpFetcher. Useful for testing.
Darin Petkov0dc8e9a2010-07-14 14:51:57 -070094 //
Alex Vakulenko88b591f2014-08-28 16:48:57 -070095 // Takes ownership of the passed in OmahaEvent. If |event| is null,
Darin Petkov0dc8e9a2010-07-14 14:51:57 -070096 // this is an UpdateCheck request, otherwise it's an Event request.
97 // Event requests always succeed.
98 //
rspangler@google.com49fdf182009-10-10 00:57:34 +000099 // A good calling pattern is:
Darin Petkova4a8a8c2010-07-15 22:21:12 -0700100 // OmahaRequestAction(..., new OmahaEvent(...), new WhateverHttpFetcher);
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700101 // or
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700102 // OmahaRequestAction(..., nullptr, new WhateverHttpFetcher);
Amin Hassani538bd592020-11-04 20:46:08 -0800103 OmahaRequestAction(OmahaEvent* event,
Alex Deymoc1c17b42015-11-23 03:53:15 -0300104 std::unique_ptr<HttpFetcher> http_fetcher,
Jae Hoon Kimedb65502019-06-14 11:52:17 -0700105 bool ping_only,
106 const std::string& session_id);
Alex Deymo610277e2014-11-11 21:18:11 -0800107 ~OmahaRequestAction() override;
Darin Petkov6a5b3222010-07-13 14:55:28 -0700108 typedef ActionTraits<OmahaRequestAction>::InputObjectType InputObjectType;
109 typedef ActionTraits<OmahaRequestAction>::OutputObjectType OutputObjectType;
Alex Deymo610277e2014-11-11 21:18:11 -0800110 void PerformAction() override;
111 void TerminateProcessing() override;
112 void ActionCompleted(ErrorCode code) override;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000113
Darin Petkov1023a602010-08-30 13:47:51 -0700114 int GetHTTPResponseCode() { return http_fetcher_->http_response_code(); }
115
rspangler@google.com49fdf182009-10-10 00:57:34 +0000116 // Debugging/logging
Darin Petkov6a5b3222010-07-13 14:55:28 -0700117 static std::string StaticType() { return "OmahaRequestAction"; }
Alex Deymo610277e2014-11-11 21:18:11 -0800118 std::string Type() const override { return StaticType(); }
rspangler@google.com49fdf182009-10-10 00:57:34 +0000119
120 // Delegate methods (see http_fetcher.h)
Amin Hassani0cd9d772018-07-31 23:55:43 -0700121 bool ReceivedBytes(HttpFetcher* fetcher,
122 const void* bytes,
123 size_t length) override;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000124
Amin Hassani7cc8bb02019-01-14 16:29:47 -0800125 void TransferComplete(HttpFetcher* fetcher, bool successful) override;
Alex Deymo610277e2014-11-11 21:18:11 -0800126
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700127 // Returns true if this is an Event request, false if it's an UpdateCheck.
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700128 bool IsEvent() const { return event_.get() != nullptr; }
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700129
rspangler@google.com49fdf182009-10-10 00:57:34 +0000130 private:
Zentaro Kavanagh1f899d52018-02-27 15:02:47 -0800131 friend class OmahaRequestActionTest;
Amin Hassanid3f4bea2018-04-30 14:52:40 -0700132 friend class OmahaRequestActionTestProcessorDelegate;
Alex Deymoe1e3afe2014-10-30 13:02:49 -0700133 FRIEND_TEST(OmahaRequestActionTest, GetInstallDateWhenNoPrefsNorOOBE);
134 FRIEND_TEST(OmahaRequestActionTest,
135 GetInstallDateWhenOOBECompletedWithInvalidDate);
136 FRIEND_TEST(OmahaRequestActionTest,
137 GetInstallDateWhenOOBECompletedWithValidDate);
138 FRIEND_TEST(OmahaRequestActionTest,
139 GetInstallDateWhenOOBECompletedDateChanges);
Jae Hoon Kimedb65502019-06-14 11:52:17 -0700140 friend class UpdateAttempterTest;
141 FRIEND_TEST(UpdateAttempterTest, SessionIdTestEnforceEmptyStrPingOmaha);
142 FRIEND_TEST(UpdateAttempterTest, SessionIdTestConsistencyInUpdateFlow);
David Zeuthen639aa362014-02-03 16:23:44 -0800143
144 // Enumeration used in PersistInstallDate().
145 enum InstallDateProvisioningSource {
146 kProvisionedFromOmahaResponse,
147 kProvisionedFromOOBEMarker,
148
149 // kProvisionedMax is the count of the number of enums above. Add
150 // any new enums above this line only.
151 kProvisionedMax
152 };
153
154 // Gets the install date, expressed as the number of PST8PDT
155 // calendar weeks since January 1st 2007, times seven. Returns -1 if
156 // unknown. See http://crbug.com/336838 for details about this value.
Amin Hassani538bd592020-11-04 20:46:08 -0800157 static int GetInstallDate();
David Zeuthen639aa362014-02-03 16:23:44 -0800158
159 // Parses the Omaha Response in |doc| and sets the
160 // |install_date_days| field of |output_object| to the value of the
161 // elapsed_days attribute of the daystart element. Returns True if
162 // the value was set, False if it wasn't found.
David Zeuthene8ed8632014-07-24 13:38:10 -0400163 static bool ParseInstallDate(OmahaParserData* parser_data,
David Zeuthen639aa362014-02-03 16:23:44 -0800164 OmahaResponse* output_object);
165
166 // Returns True if the kPrefsInstallDateDays state variable is set,
167 // False otherwise.
Amin Hassani538bd592020-11-04 20:46:08 -0800168 static bool HasInstallDate();
David Zeuthen639aa362014-02-03 16:23:44 -0800169
170 // Writes |install_date_days| into the kPrefsInstallDateDays state
171 // variable and emits an UMA stat for the |source| used. Returns
172 // True if the value was written, False if an error occurred.
Amin Hassani538bd592020-11-04 20:46:08 -0800173 static bool PersistInstallDate(int install_date_days,
David Zeuthen639aa362014-02-03 16:23:44 -0800174 InstallDateProvisioningSource source);
175
Jae Hoon Kime2cac612020-11-02 18:30:29 -0800176 // Persist the new cohort value received in the XML file in the |prefs_key|
177 // preference file. If the |new_value| is empty, do nothing. If the
178 // |new_value| stores and empty value, the currently stored value will be
179 // deleted. Don't call this function with an empty |new_value| if the value
180 // was not set in the XML, since that would delete the stored value.
181 void PersistCohortData(const std::string& prefs_key,
182 const base::Optional<std::string>& new_value);
183
184 // Parses and persists the cohorts sent back in the updatecheck tag
185 // attributes.
186 void PersistCohorts(const OmahaParserData& parser_data);
Alex Deymo8e18f932015-03-27 16:16:59 -0700187
Amin Hassani2cbb0692019-10-30 13:36:17 -0700188 // Parses and persists the end-of-life date flag sent back in the updatecheck
189 // tag attributes. The flags will be validated and stored in the Prefs.
190 bool PersistEolInfo(const std::map<std::string, std::string>& attrs);
Alex Deymob3fa53b2016-04-18 19:57:58 -0700191
Darin Petkov1cbd78f2010-07-29 12:38:34 -0700192 // If this is an update check request, initializes
193 // |ping_active_days_| and |ping_roll_call_days_| to values that may
194 // be sent as pings to Omaha.
195 void InitPingDays();
196
Darin Petkov84c763c2010-07-29 16:27:58 -0700197 // Based on the persistent preference store values, calculates the
Darin Petkov1cbd78f2010-07-29 12:38:34 -0700198 // number of days since the last ping sent for |key|.
199 int CalculatePingDays(const std::string& key);
200
Alex Deymoebbe7ef2014-10-30 13:02:49 -0700201 // Returns whether we have "active_days" or "roll_call_days" ping values to
202 // send to Omaha and thus we should include them in the response.
203 bool ShouldPing() const;
204
Andrewe045aef2020-01-08 16:29:22 -0800205 // Process Omaha's response to a ping request and store the results in the DLC
206 // metadata directory.
207 void StorePingReply(const OmahaParserData& parser_data) const;
208
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700209 // Returns true if the download of a new update should be deferred.
210 // False if the update can be downloaded.
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700211 bool ShouldDeferDownload(OmahaResponse* output_object);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700212
213 // Returns true if the basic wall-clock-based waiting period has been
214 // satisfied based on the scattering policy setting. False otherwise.
215 // If true, it also indicates whether the additional update-check-count-based
216 // waiting period also needs to be satisfied before the download can begin.
217 WallClockWaitResult IsWallClockBasedWaitingSatisfied(
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700218 OmahaResponse* output_object);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700219
220 // Returns true if the update-check-count-based waiting period has been
221 // satisfied. False otherwise.
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700222 bool IsUpdateCheckCountBasedWaitingSatisfied();
223
224 // Parses the response from Omaha that's available in |doc| using the other
225 // helper methods below and populates the |output_object| with the relevant
226 // values. Returns true if we should continue the parsing. False otherwise,
227 // in which case it sets any error code using |completer|.
David Zeuthene8ed8632014-07-24 13:38:10 -0400228 bool ParseResponse(OmahaParserData* parser_data,
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700229 OmahaResponse* output_object,
230 ScopedActionCompleter* completer);
231
232 // Parses the status property in the given update_check_node and populates
233 // |output_object| if valid. Returns true if we should continue the parsing.
234 // False otherwise, in which case it sets any error code using |completer|.
David Zeuthene8ed8632014-07-24 13:38:10 -0400235 bool ParseStatus(OmahaParserData* parser_data,
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700236 OmahaResponse* output_object,
237 ScopedActionCompleter* completer);
238
239 // Parses the URL nodes in the given XML document and populates
240 // |output_object| if valid. Returns true if we should continue the parsing.
241 // False otherwise, in which case it sets any error code using |completer|.
David Zeuthene8ed8632014-07-24 13:38:10 -0400242 bool ParseUrls(OmahaParserData* parser_data,
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700243 OmahaResponse* output_object,
244 ScopedActionCompleter* completer);
245
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700246 // Parses the other parameters in the given XML document and populates
247 // |output_object| if valid. Returns true if we should continue the parsing.
248 // False otherwise, in which case it sets any error code using |completer|.
David Zeuthene8ed8632014-07-24 13:38:10 -0400249 bool ParseParams(OmahaParserData* parser_data,
Jay Srinivasan23b92a52012-10-27 02:00:21 -0700250 OmahaResponse* output_object,
251 ScopedActionCompleter* completer);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700252
David Zeuthen8f191b22013-08-06 12:27:50 -0700253 // Called by TransferComplete() to complete processing, either
254 // asynchronously after looking up resources via p2p or directly.
255 void CompleteProcessing();
256
257 // Helper to asynchronously look up payload on the LAN.
258 void LookupPayloadViaP2P(const OmahaResponse& response);
259
260 // Callback used by LookupPayloadViaP2P().
261 void OnLookupPayloadViaP2PCompleted(const std::string& url);
262
Chris Sosa77f79e82014-06-02 18:16:24 -0700263 // Returns true if the current update should be ignored.
Toni Barzic61544e62018-10-11 14:37:30 -0700264 bool ShouldIgnoreUpdate(const OmahaResponse& response,
265 ErrorCode* error) const;
Weidong Guo421ff332017-04-17 10:08:38 -0700266
267 // Return true if updates are allowed by user preferences.
268 bool IsUpdateAllowedOverCellularByPrefs(const OmahaResponse& response) const;
Chris Sosa77f79e82014-06-02 18:16:24 -0700269
270 // Returns true if updates are allowed over the current type of connection.
271 // False otherwise.
Weidong Guo421ff332017-04-17 10:08:38 -0700272 bool IsUpdateAllowedOverCurrentConnection(
273 ErrorCode* error, const OmahaResponse& response) const;
Chris Sosa77f79e82014-06-02 18:16:24 -0700274
Zentaro Kavanagh1f899d52018-02-27 15:02:47 -0800275 // Returns true if rollback is enabled. Always returns false for consumer
276 // devices.
277 bool IsRollbackEnabled() const;
278
279 // Sets the appropriate max kernel key version based on whether rollback is
280 // enabled.
281 void SetMaxKernelKeyVersionForRollback() const;
282
May Lippert60aa3ca2018-08-15 16:55:29 -0700283 // Reads and returns the kPrefsUpdateFirstSeenAt pref if the pref currently
284 // exists. Otherwise saves the current wallclock time to the
285 // kPrefsUpdateFirstSeenAt pref and returns it as a base::Time object.
286 base::Time LoadOrPersistUpdateFirstSeenAtPref() const;
287
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700288 // Pointer to the OmahaEvent info. This is an UpdateCheck request if null.
Ben Chan02f7c1d2014-10-18 15:18:02 -0700289 std::unique_ptr<OmahaEvent> event_;
Darin Petkov0dc8e9a2010-07-14 14:51:57 -0700290
rspangler@google.com49fdf182009-10-10 00:57:34 +0000291 // pointer to the HttpFetcher that does the http work
Ben Chan02f7c1d2014-10-18 15:18:02 -0700292 std::unique_ptr<HttpFetcher> http_fetcher_;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000293
Zentaro Kavanagh1f899d52018-02-27 15:02:47 -0800294 // Used for fetching information about the device policy.
295 std::unique_ptr<policy::PolicyProvider> policy_provider_;
296
Thieu Le116fda32011-04-19 11:01:54 -0700297 // If true, only include the <ping> element in the request.
298 bool ping_only_;
299
rspangler@google.com49fdf182009-10-10 00:57:34 +0000300 // Stores the response from the omaha server
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700301 brillo::Blob response_buffer_;
rspangler@google.com49fdf182009-10-10 00:57:34 +0000302
Darin Petkov1cbd78f2010-07-29 12:38:34 -0700303 // Initialized by InitPingDays to values that may be sent to Omaha
304 // as part of a ping message. Note that only positive values and -1
305 // are sent to Omaha.
306 int ping_active_days_;
307 int ping_roll_call_days_;
308
Jae Hoon Kimedb65502019-06-14 11:52:17 -0700309 std::string session_id_;
310
Darin Petkov6a5b3222010-07-13 14:55:28 -0700311 DISALLOW_COPY_AND_ASSIGN(OmahaRequestAction);
rspangler@google.com49fdf182009-10-10 00:57:34 +0000312};
313
314} // namespace chromeos_update_engine
315
Amin Hassaniec7bc112020-10-29 16:47:58 -0700316#endif // UPDATE_ENGINE_CROS_OMAHA_REQUEST_ACTION_H_