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 uint64_t size = 0; // size of the payload 62 uint64_t metadata_size = 0; // size of the metadata 63 std::string metadata_signature; // signature of the metadata in base64 64 brillo::Blob hash; // SHA256 hash of the payload 65 InstallPayloadType type{InstallPayloadType::kUnknown}; 66 // Only download manifest and fill in partitions in install plan without 67 // apply the payload if true. Will be set by DownloadAction when resuming 68 // multi-payload. 69 bool already_applied = false; 70 71 bool operator==(const Payload& that) const { 72 return size == that.size && metadata_size == that.metadata_size && 73 metadata_signature == that.metadata_signature && 74 hash == that.hash && type == that.type && 75 already_applied == that.already_applied; 76 } 77 }; 78 std::vector<Payload> payloads; 79 80 // The partition slots used for the update. 81 BootControlInterface::Slot source_slot{BootControlInterface::kInvalidSlot}; 82 BootControlInterface::Slot target_slot{BootControlInterface::kInvalidSlot}; 83 84 // The vector below is used for partition verification. The flow is: 85 // 86 // 1. DownloadAction fills in the expected source and target partition sizes 87 // and hashes based on the manifest. 88 // 89 // 2. FilesystemVerifierAction computes and verifies the partition sizes and 90 // hashes against the expected values. 91 struct Partition { 92 bool operator==(const Partition& that) const; 93 94 // The name of the partition. 95 std::string name; 96 97 std::string source_path; 98 uint64_t source_size{0}; 99 brillo::Blob source_hash; 100 101 std::string target_path; 102 uint64_t target_size{0}; 103 brillo::Blob target_hash; 104 uint32_t block_size{0}; 105 106 // Whether we should run the postinstall script from this partition and the 107 // postinstall parameters. 108 bool run_postinstall{false}; 109 std::string postinstall_path; 110 std::string filesystem_type; 111 bool postinstall_optional{false}; 112 113 // Verity hash tree and FEC config. See update_metadata.proto for details. 114 // All offsets and sizes are in bytes. 115 uint64_t hash_tree_data_offset{0}; 116 uint64_t hash_tree_data_size{0}; 117 uint64_t hash_tree_offset{0}; 118 uint64_t hash_tree_size{0}; 119 std::string hash_tree_algorithm; 120 brillo::Blob hash_tree_salt; 121 122 uint64_t fec_data_offset{0}; 123 uint64_t fec_data_size{0}; 124 uint64_t fec_offset{0}; 125 uint64_t fec_size{0}; 126 uint32_t fec_roots{0}; 127 }; 128 std::vector<Partition> partitions; 129 130 // True if payload hash checks are mandatory based on the system state and 131 // the Omaha response. 132 bool hash_checks_mandatory{false}; 133 134 // True if Powerwash is required on reboot after applying the payload. 135 // False otherwise. 136 bool powerwash_required{false}; 137 138 // True if the updated slot should be marked active on success. 139 // False otherwise. 140 bool switch_slot_on_reboot{true}; 141 142 // True if the update should run its post-install step. 143 // False otherwise. 144 bool run_post_install{true}; 145 146 // True if this update is a rollback. 147 bool is_rollback{false}; 148 149 // True if the update should write verity. 150 // False otherwise. 151 bool write_verity{true}; 152 153 // If not blank, a base-64 encoded representation of the PEM-encoded 154 // public key in the response. 155 std::string public_key_rsa; 156 }; 157 158 class InstallPlanAction; 159 160 template <> 161 class ActionTraits<InstallPlanAction> { 162 public: 163 // Takes the install plan as input 164 typedef InstallPlan InputObjectType; 165 // Passes the install plan as output 166 typedef InstallPlan OutputObjectType; 167 }; 168 169 // Basic action that only receives and sends Install Plans. 170 // Can be used to construct an Install Plan to send to any other Action that 171 // accept an InstallPlan. 172 class InstallPlanAction : public Action<InstallPlanAction> { 173 public: InstallPlanAction()174 InstallPlanAction() {} InstallPlanAction(const InstallPlan & install_plan)175 explicit InstallPlanAction(const InstallPlan& install_plan) 176 : install_plan_(install_plan) {} 177 PerformAction()178 void PerformAction() override { 179 if (HasOutputPipe()) { 180 SetOutputObject(install_plan_); 181 } 182 processor_->ActionComplete(this, ErrorCode::kSuccess); 183 } 184 install_plan()185 InstallPlan* install_plan() { return &install_plan_; } 186 StaticType()187 static std::string StaticType() { return "InstallPlanAction"; } Type()188 std::string Type() const override { return StaticType(); } 189 190 typedef ActionTraits<InstallPlanAction>::InputObjectType InputObjectType; 191 typedef ActionTraits<InstallPlanAction>::OutputObjectType OutputObjectType; 192 193 private: 194 InstallPlan install_plan_; 195 196 DISALLOW_COPY_AND_ASSIGN(InstallPlanAction); 197 }; 198 199 } // namespace chromeos_update_engine 200 201 #endif // UPDATE_ENGINE_PAYLOAD_CONSUMER_INSTALL_PLAN_H_ 202