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   // Load 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   InstallPayloadType payload_type{InstallPayloadType::kUnknown};
56   std::string download_url;  // url to download from
57   std::string version;       // version we are installing.
58 
59   uint64_t payload_size{0};              // size of the payload
60   std::string payload_hash;              // SHA256 hash of the payload
61   uint64_t metadata_size{0};             // size of the metadata
62   std::string metadata_signature;        // signature of the  metadata
63 
64   // The partition slots used for the update.
65   BootControlInterface::Slot source_slot{BootControlInterface::kInvalidSlot};
66   BootControlInterface::Slot target_slot{BootControlInterface::kInvalidSlot};
67 
68   // The vector below is used for partition verification. The flow is:
69   //
70   // 1. FilesystemVerifierAction computes and fills in the source partition
71   // hash based on the guessed source size for delta major version 1 updates.
72   //
73   // 2. DownloadAction verifies the source partition sizes and hashes against
74   // the expected values transmitted in the update manifest. It fills in the
75   // expected target partition sizes and hashes based on the manifest.
76   //
77   // 3. FilesystemVerifierAction computes and verifies the applied partition
78   // sizes and hashes against the expected values in target_partition_hashes.
79   struct Partition {
80     bool operator==(const Partition& that) const;
81 
82     // The name of the partition.
83     std::string name;
84 
85     std::string source_path;
86     uint64_t source_size{0};
87     brillo::Blob source_hash;
88 
89     std::string target_path;
90     uint64_t target_size{0};
91     brillo::Blob target_hash;
92 
93     // Whether we should run the postinstall script from this partition and the
94     // postinstall parameters.
95     bool run_postinstall{false};
96     std::string postinstall_path;
97     std::string filesystem_type;
98   };
99   std::vector<Partition> partitions;
100 
101   // True if payload hash checks are mandatory based on the system state and
102   // the Omaha response.
103   bool hash_checks_mandatory{false};
104 
105   // True if Powerwash is required on reboot after applying the payload.
106   // False otherwise.
107   bool powerwash_required{false};
108 
109   // If not blank, a base-64 encoded representation of the PEM-encoded
110   // public key in the response.
111   std::string public_key_rsa;
112 };
113 
114 class InstallPlanAction;
115 
116 template<>
117 class ActionTraits<InstallPlanAction> {
118  public:
119   // Takes the install plan as input
120   typedef InstallPlan InputObjectType;
121   // Passes the install plan as output
122   typedef InstallPlan OutputObjectType;
123 };
124 
125 // Basic action that only receives and sends Install Plans.
126 // Can be used to construct an Install Plan to send to any other Action that
127 // accept an InstallPlan.
128 class InstallPlanAction : public Action<InstallPlanAction> {
129  public:
InstallPlanAction()130   InstallPlanAction() {}
InstallPlanAction(const InstallPlan & install_plan)131   explicit InstallPlanAction(const InstallPlan& install_plan):
132     install_plan_(install_plan) {}
133 
PerformAction()134   void PerformAction() override {
135     if (HasOutputPipe()) {
136       SetOutputObject(install_plan_);
137     }
138     processor_->ActionComplete(this, ErrorCode::kSuccess);
139   }
140 
install_plan()141   InstallPlan* install_plan() { return &install_plan_; }
142 
StaticType()143   static std::string StaticType() { return "InstallPlanAction"; }
Type()144   std::string Type() const override { return StaticType(); }
145 
146   typedef ActionTraits<InstallPlanAction>::InputObjectType InputObjectType;
147   typedef ActionTraits<InstallPlanAction>::OutputObjectType OutputObjectType;
148 
149  private:
150   InstallPlan install_plan_;
151 
152   DISALLOW_COPY_AND_ASSIGN(InstallPlanAction);
153 };
154 
155 }  // namespace chromeos_update_engine
156 
157 #endif  // UPDATE_ENGINE_PAYLOAD_CONSUMER_INSTALL_PLAN_H_
158