1 //
2 // Copyright (C) 2016 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 <xz.h>
18
19 #include <string>
20 #include <vector>
21
22 #include <base/command_line.h>
23 #include <base/logging.h>
24 #include <base/strings/string_split.h>
25 #include <base/strings/stringprintf.h>
26 #include <brillo/asynchronous_signal_handler.h>
27 #include <brillo/flag_helper.h>
28 #include <brillo/make_unique_ptr.h>
29 #include <brillo/message_loops/base_message_loop.h>
30 #include <brillo/streams/file_stream.h>
31 #include <brillo/streams/stream.h>
32
33 #include "update_engine/common/boot_control.h"
34 #include "update_engine/common/error_code_utils.h"
35 #include "update_engine/common/hardware.h"
36 #include "update_engine/common/prefs.h"
37 #include "update_engine/common/subprocess.h"
38 #include "update_engine/common/terminator.h"
39 #include "update_engine/common/utils.h"
40 #include "update_engine/update_attempter_android.h"
41
42 using std::string;
43 using std::vector;
44 using update_engine::UpdateStatus;
45
46 namespace {
47 // The root directory used for temporary files in update_engine_sideload.
48 const char kSideloadRootTempDir[] = "/tmp/update_engine_sideload";
49 } // namespace
50
51 namespace chromeos_update_engine {
52 namespace {
53
SetupLogging()54 void SetupLogging() {
55 string log_file;
56 logging::LoggingSettings log_settings;
57 log_settings.lock_log = logging::DONT_LOCK_LOG_FILE;
58 log_settings.delete_old = logging::APPEND_TO_OLD_LOG_FILE;
59 log_settings.log_file = nullptr;
60 log_settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
61
62 logging::InitLogging(log_settings);
63 }
64
65 class SideloadDaemonState : public DaemonStateInterface,
66 public ServiceObserverInterface {
67 public:
SideloadDaemonState(brillo::StreamPtr status_stream)68 explicit SideloadDaemonState(brillo::StreamPtr status_stream)
69 : status_stream_(std::move(status_stream)) {
70 // Add this class as the only observer.
71 observers_.insert(this);
72 }
73 ~SideloadDaemonState() override = default;
74
75 // DaemonStateInterface overrides.
StartUpdater()76 bool StartUpdater() override { return true; }
AddObserver(ServiceObserverInterface * observer)77 void AddObserver(ServiceObserverInterface* observer) override {}
RemoveObserver(ServiceObserverInterface * observer)78 void RemoveObserver(ServiceObserverInterface* observer) override {}
service_observers()79 const std::set<ServiceObserverInterface*>& service_observers() override {
80 return observers_;
81 }
82
83 // ServiceObserverInterface overrides.
SendStatusUpdate(int64_t last_checked_time,double progress,UpdateStatus status,const string & new_version,int64_t new_size)84 void SendStatusUpdate(int64_t last_checked_time,
85 double progress,
86 UpdateStatus status,
87 const string& new_version,
88 int64_t new_size) override {
89 if (status_ != status && (status == UpdateStatus::DOWNLOADING ||
90 status == UpdateStatus::FINALIZING)) {
91 // Split the progress bar in two parts for the two stages DOWNLOADING and
92 // FINALIZING.
93 ReportStatus(base::StringPrintf(
94 "ui_print Step %d/2", status == UpdateStatus::DOWNLOADING ? 1 : 2));
95 ReportStatus(base::StringPrintf("progress 0.5 0"));
96 }
97 if (status_ != status || fabs(progress - progress_) > 0.005) {
98 ReportStatus(base::StringPrintf("set_progress %.lf", progress));
99 }
100 progress_ = progress;
101 status_ = status;
102 }
103
SendPayloadApplicationComplete(ErrorCode error_code)104 void SendPayloadApplicationComplete(ErrorCode error_code) override {
105 if (error_code != ErrorCode::kSuccess) {
106 ReportStatus(
107 base::StringPrintf("ui_print Error applying update: %d (%s)",
108 error_code,
109 utils::ErrorCodeToString(error_code).c_str()));
110 }
111 error_code_ = error_code;
112 brillo::MessageLoop::current()->BreakLoop();
113 }
114
SendChannelChangeUpdate(const string & tracking_channel)115 void SendChannelChangeUpdate(const string& tracking_channel) override {}
116
117 // Getters.
status()118 UpdateStatus status() { return status_; }
error_code()119 ErrorCode error_code() { return error_code_; }
120
121 private:
122 // Report a status message in the status_stream_, if any. These messages
123 // should conform to the specification defined in the Android recovery.
ReportStatus(const string & message)124 void ReportStatus(const string& message) {
125 if (!status_stream_)
126 return;
127 string status_line = message + "\n";
128 status_stream_->WriteAllBlocking(
129 status_line.data(), status_line.size(), nullptr);
130 }
131
132 std::set<ServiceObserverInterface*> observers_;
133 brillo::StreamPtr status_stream_;
134
135 // The last status and error code reported.
136 UpdateStatus status_{UpdateStatus::IDLE};
137 ErrorCode error_code_{ErrorCode::kSuccess};
138 double progress_{-1.};
139 };
140
141 // Apply an update payload directly from the given payload URI.
ApplyUpdatePayload(const string & payload,int64_t payload_offset,int64_t payload_size,const vector<string> & headers,int64_t status_fd)142 bool ApplyUpdatePayload(const string& payload,
143 int64_t payload_offset,
144 int64_t payload_size,
145 const vector<string>& headers,
146 int64_t status_fd) {
147 brillo::BaseMessageLoop loop;
148 loop.SetAsCurrent();
149
150 // Setup the subprocess handler.
151 brillo::AsynchronousSignalHandler handler;
152 handler.Init();
153 Subprocess subprocess;
154 subprocess.Init(&handler);
155
156 SideloadDaemonState sideload_daemon_state(
157 brillo::FileStream::FromFileDescriptor(status_fd, true, nullptr));
158
159 // During the sideload we don't access the prefs persisted on disk but instead
160 // use a temporary memory storage.
161 MemoryPrefs prefs;
162
163 std::unique_ptr<BootControlInterface> boot_control =
164 boot_control::CreateBootControl();
165 if (!boot_control) {
166 LOG(ERROR) << "Error initializing the BootControlInterface.";
167 return false;
168 }
169
170 std::unique_ptr<HardwareInterface> hardware = hardware::CreateHardware();
171 if (!hardware) {
172 LOG(ERROR) << "Error initializing the HardwareInterface.";
173 return false;
174 }
175
176 UpdateAttempterAndroid update_attempter(
177 &sideload_daemon_state, &prefs, boot_control.get(), hardware.get());
178 update_attempter.Init();
179
180 TEST_AND_RETURN_FALSE(update_attempter.ApplyPayload(
181 payload, payload_offset, payload_size, headers, nullptr));
182
183 loop.Run();
184 return sideload_daemon_state.status() == UpdateStatus::UPDATED_NEED_REBOOT;
185 }
186
187 } // namespace
188 } // namespace chromeos_update_engine
189
main(int argc,char ** argv)190 int main(int argc, char** argv) {
191 DEFINE_string(payload,
192 "file:///data/payload.bin",
193 "The URI to the update payload to use.");
194 DEFINE_int64(
195 offset, 0, "The offset in the payload where the CrAU update starts. ");
196 DEFINE_int64(size,
197 0,
198 "The size of the CrAU part of the payload. If 0 is passed, it "
199 "will be autodetected.");
200 DEFINE_string(headers,
201 "",
202 "A list of key-value pairs, one element of the list per line.");
203 DEFINE_int64(status_fd, -1, "A file descriptor to notify the update status.");
204
205 chromeos_update_engine::Terminator::Init();
206 chromeos_update_engine::SetupLogging();
207 brillo::FlagHelper::Init(argc, argv, "Update Engine Sideload");
208
209 LOG(INFO) << "Update Engine Sideloading starting";
210
211 // xz-embedded requires to initialize its CRC-32 table once on startup.
212 xz_crc32_init();
213
214 // When called from recovery, /data is not accessible, so we need to use
215 // /tmp for temporary files.
216 chromeos_update_engine::utils::SetRootTempDir(kSideloadRootTempDir);
217
218 vector<string> headers = base::SplitString(
219 FLAGS_headers, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
220
221 if (!chromeos_update_engine::ApplyUpdatePayload(
222 FLAGS_payload, FLAGS_offset, FLAGS_size, headers, FLAGS_status_fd))
223 return 1;
224
225 return 0;
226 }
227