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 #ifndef UPDATE_ENGINE_PAYLOAD_CONSUMER_INSTALL_PLAN_H_
18 #define UPDATE_ENGINE_PAYLOAD_CONSUMER_INSTALL_PLAN_H_
19 
20 #include <string>
21 #include <vector>
22 
23 #include <base/macros.h>
24 #include <brillo/secure_blob.h>
25 
26 #include "update_engine/common/action.h"
27 #include "update_engine/common/boot_control_interface.h"
28 
29 // InstallPlan is a simple struct that contains relevant info for many
30 // parts of the update system about the install that should happen.
31 namespace chromeos_update_engine {
32 
33 enum class InstallPayloadType {
34   kUnknown,
35   kFull,
36   kDelta,
37 };
38 
39 std::string InstallPayloadTypeToString(InstallPayloadType type);
40 
41 struct InstallPlan {
42   InstallPlan() = default;
43 
44   bool operator==(const InstallPlan& that) const;
45   bool operator!=(const InstallPlan& that) const;
46 
47   void Dump() const;
48 
49   // Loads the |source_path| and |target_path| of all |partitions| based on the
50   // |source_slot| and |target_slot| if available. Returns whether it succeeded
51   // to load all the partitions for the valid slots.
52   bool LoadPartitionsFromSlots(BootControlInterface* boot_control);
53 
54   bool is_resume{false};
55   std::string download_url;  // url to download from
56   std::string version;       // version we are installing.
57   // system version, if present and separate from version
58   std::string system_version;
59 
60   struct Payload {
61     std::vector<std::string> payload_urls;  // URLs to download the payload
62     uint64_t size = 0;               // size of the payload
63     uint64_t metadata_size = 0;      // size of the metadata
64     std::string metadata_signature;  // signature of the metadata in base64
65     brillo::Blob hash;               // SHA256 hash of the payload
66     InstallPayloadType type{InstallPayloadType::kUnknown};
67     // Only download manifest and fill in partitions in install plan without
68     // apply the payload if true. Will be set by DownloadAction when resuming
69     // multi-payload.
70     bool already_applied = false;
71 
72     bool operator==(const Payload& that) const {
73       return payload_urls == that.payload_urls && size == that.size &&
74              metadata_size == that.metadata_size &&
75              metadata_signature == that.metadata_signature &&
76              hash == that.hash && type == that.type &&
77              already_applied == that.already_applied;
78     }
79   };
80   std::vector<Payload> payloads;
81 
82   // The partition slots used for the update.
83   BootControlInterface::Slot source_slot{BootControlInterface::kInvalidSlot};
84   BootControlInterface::Slot target_slot{BootControlInterface::kInvalidSlot};
85 
86   // The vector below is used for partition verification. The flow is:
87   //
88   // 1. DownloadAction fills in the expected source and target partition sizes
89   // and hashes based on the manifest.
90   //
91   // 2. FilesystemVerifierAction computes and verifies the partition sizes and
92   // hashes against the expected values.
93   struct Partition {
94     bool operator==(const Partition& that) const;
95 
96     // The name of the partition.
97     std::string name;
98 
99     std::string source_path;
100     uint64_t source_size{0};
101     brillo::Blob source_hash;
102 
103     std::string target_path;
104     uint64_t target_size{0};
105     brillo::Blob target_hash;
106     uint32_t block_size{0};
107 
108     // Whether we should run the postinstall script from this partition and the
109     // postinstall parameters.
110     bool run_postinstall{false};
111     std::string postinstall_path;
112     std::string filesystem_type;
113     bool postinstall_optional{false};
114 
115     // Verity hash tree and FEC config. See update_metadata.proto for details.
116     // All offsets and sizes are in bytes.
117     uint64_t hash_tree_data_offset{0};
118     uint64_t hash_tree_data_size{0};
119     uint64_t hash_tree_offset{0};
120     uint64_t hash_tree_size{0};
121     std::string hash_tree_algorithm;
122     brillo::Blob hash_tree_salt;
123 
124     uint64_t fec_data_offset{0};
125     uint64_t fec_data_size{0};
126     uint64_t fec_offset{0};
127     uint64_t fec_size{0};
128     uint32_t fec_roots{0};
129   };
130   std::vector<Partition> partitions;
131 
132   // True if payload hash checks are mandatory based on the system state and
133   // the Omaha response.
134   bool hash_checks_mandatory{false};
135 
136   // True if Powerwash is required on reboot after applying the payload.
137   // False otherwise.
138   bool powerwash_required{false};
139 
140   // True if the updated slot should be marked active on success.
141   // False otherwise.
142   bool switch_slot_on_reboot{true};
143 
144   // True if the update should run its post-install step.
145   // False otherwise.
146   bool run_post_install{true};
147 
148   // True if this update is a rollback.
149   bool is_rollback{false};
150 
151   // True if this rollback should preserve some system data.
152   bool rollback_data_save_requested{false};
153 
154   // True if the update should write verity.
155   // False otherwise.
156   bool write_verity{true};
157 
158   // If not blank, a base-64 encoded representation of the PEM-encoded
159   // public key in the response.
160   std::string public_key_rsa;
161 
162   // The name of dynamic partitions not included in the payload. Only used
163   // for partial updates.
164   std::vector<std::string> untouched_dynamic_partitions;
165 };
166 
167 class InstallPlanAction;
168 
169 template <>
170 class ActionTraits<InstallPlanAction> {
171  public:
172   // Takes the install plan as input
173   typedef InstallPlan InputObjectType;
174   // Passes the install plan as output
175   typedef InstallPlan OutputObjectType;
176 };
177 
178 // Basic action that only receives and sends Install Plans.
179 // Can be used to construct an Install Plan to send to any other Action that
180 // accept an InstallPlan.
181 class InstallPlanAction : public Action<InstallPlanAction> {
182  public:
InstallPlanAction()183   InstallPlanAction() {}
InstallPlanAction(const InstallPlan & install_plan)184   explicit InstallPlanAction(const InstallPlan& install_plan)
185       : install_plan_(install_plan) {}
186 
PerformAction()187   void PerformAction() override {
188     if (HasOutputPipe()) {
189       SetOutputObject(install_plan_);
190     }
191     processor_->ActionComplete(this, ErrorCode::kSuccess);
192   }
193 
install_plan()194   InstallPlan* install_plan() { return &install_plan_; }
195 
StaticType()196   static std::string StaticType() { return "InstallPlanAction"; }
Type()197   std::string Type() const override { return StaticType(); }
198 
199   typedef ActionTraits<InstallPlanAction>::InputObjectType InputObjectType;
200   typedef ActionTraits<InstallPlanAction>::OutputObjectType OutputObjectType;
201 
202  protected:
203   InstallPlan install_plan_;
204 
205  private:
206   DISALLOW_COPY_AND_ASSIGN(InstallPlanAction);
207 };
208 
209 }  // namespace chromeos_update_engine
210 
211 #endif  // UPDATE_ENGINE_PAYLOAD_CONSUMER_INSTALL_PLAN_H_
212