1//
2// Copyright (C) 2020 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 <unistd.h>
18#include <cstdint>
19#include <memory>
20
21#include <gmock/gmock.h>
22#include <gmock/gmock-actions.h>
23#include <gmock/gmock-function-mocker.h>
24#include <gmock/gmock-spec-builders.h>
25#include <gtest/gtest.h>
26
27#include "update_engine/common/action_pipe.h"
28#include "update_engine/common/boot_control_stub.h"
29#include "update_engine/common/constants.h"
30#include "update_engine/common/download_action.h"
31#include "update_engine/common/fake_hardware.h"
32#include "update_engine/common/mock_action_processor.h"
33#include "update_engine/common/mock_http_fetcher.h"
34#include "update_engine/common/mock_prefs.h"
35#include "update_engine/common/test_utils.h"
36#include "update_engine/common/utils.h"
37#include "update_engine/payload_consumer/install_plan.h"
38#include "update_engine/payload_consumer/payload_constants.h"
39#include "update_engine/payload_generator/annotated_operation.h"
40#include "update_engine/payload_generator/payload_file.h"
41#include "update_engine/payload_generator/payload_signer.h"
42
43namespace chromeos_update_engine {
44using testing::_;
45using testing::DoAll;
46using testing::Return;
47using testing::SetArgPointee;
48
49extern const char* kUnittestPrivateKeyPath;
50extern const char* kUnittestPublicKeyPath;
51
52class DownloadActionTest : public ::testing::Test {
53 public:
54  static constexpr int64_t METADATA_SIZE = 1024;
55  static constexpr int64_t SIGNATURE_SIZE = 256;
56  std::shared_ptr<ActionPipe<InstallPlan>> action_pipe{
57      new ActionPipe<InstallPlan>()};
58};
59
60TEST_F(DownloadActionTest, CacheManifestInvalid) {
61  std::string data(METADATA_SIZE + SIGNATURE_SIZE, '-');
62  MockPrefs prefs;
63  EXPECT_CALL(prefs, GetInt64(kPrefsUpdateStatePayloadIndex, _))
64      .WillRepeatedly(DoAll(SetArgPointee<1>(0L), Return(true)));
65  EXPECT_CALL(prefs, GetInt64(kPrefsManifestMetadataSize, _))
66      .WillRepeatedly(DoAll(SetArgPointee<1>(METADATA_SIZE), Return(true)));
67  EXPECT_CALL(prefs, GetInt64(kPrefsManifestSignatureSize, _))
68      .WillRepeatedly(DoAll(SetArgPointee<1>(SIGNATURE_SIZE), Return(true)));
69  EXPECT_CALL(prefs, GetInt64(kPrefsUpdateStateNextDataOffset, _))
70      .WillRepeatedly(DoAll(SetArgPointee<1>(0L), Return(true)));
71  EXPECT_CALL(prefs, GetString(kPrefsManifestBytes, _))
72      .WillRepeatedly(DoAll(SetArgPointee<1>(data), Return(true)));
73
74  BootControlStub boot_control;
75  MockHttpFetcher* http_fetcher =
76      new MockHttpFetcher(data.data(), data.size(), nullptr);
77  http_fetcher->set_delay(false);
78  InstallPlan install_plan;
79  auto& payload = install_plan.payloads.emplace_back();
80  install_plan.download_url = "http://fake_url.invalid";
81  payload.size = data.size();
82  payload.payload_urls.emplace_back("http://fake_url.invalid");
83  install_plan.is_resume = true;
84  action_pipe->set_contents(install_plan);
85
86  // takes ownership of passed in HttpFetcher
87  auto download_action = std::make_unique<DownloadAction>(
88      &prefs, &boot_control, nullptr, http_fetcher, false /* interactive */);
89  download_action->set_in_pipe(action_pipe);
90  MockActionProcessor mock_processor;
91  download_action->SetProcessor(&mock_processor);
92  download_action->PerformAction();
93  ASSERT_EQ(download_action->http_fetcher()->GetBytesDownloaded(), data.size());
94}
95
96TEST_F(DownloadActionTest, CacheManifestValid) {
97  // Create a valid manifest
98  PayloadGenerationConfig config;
99  config.version.major = kMaxSupportedMajorPayloadVersion;
100  config.version.minor = kMaxSupportedMinorPayloadVersion;
101
102  PayloadFile payload_file;
103  ASSERT_TRUE(payload_file.Init(config));
104  PartitionConfig partition_config{"system"};
105  ScopedTempFile partition_file("part-system-XXXXXX", true);
106  ftruncate(partition_file.fd(), 4096);
107  partition_config.size = 4096;
108  partition_config.path = partition_file.path();
109  ASSERT_TRUE(
110      payload_file.AddPartition(partition_config, partition_config, {}, {}, 0));
111  ScopedTempFile blob_file("Blob-XXXXXX");
112  ScopedTempFile manifest_file("Manifest-XXXXXX");
113  uint64_t metadata_size;
114  std::string private_key =
115      test_utils::GetBuildArtifactsPath(kUnittestPrivateKeyPath);
116  payload_file.WritePayload(
117      manifest_file.path(), blob_file.path(), private_key, &metadata_size);
118  uint64_t signature_blob_length = 0;
119  ASSERT_TRUE(PayloadSigner::SignatureBlobLength({private_key},
120                                                 &signature_blob_length));
121  std::string data;
122  ASSERT_TRUE(utils::ReadFile(manifest_file.path(), &data));
123  data.resize(metadata_size + signature_blob_length);
124
125  // Setup the prefs so that manifest is cached
126  MockPrefs prefs;
127  EXPECT_CALL(prefs, GetInt64(kPrefsUpdateStatePayloadIndex, _))
128      .WillRepeatedly(DoAll(SetArgPointee<1>(0L), Return(true)));
129  EXPECT_CALL(prefs, GetInt64(kPrefsManifestMetadataSize, _))
130      .WillRepeatedly(DoAll(SetArgPointee<1>(metadata_size), Return(true)));
131  EXPECT_CALL(prefs, GetInt64(kPrefsManifestSignatureSize, _))
132      .WillRepeatedly(
133          DoAll(SetArgPointee<1>(signature_blob_length), Return(true)));
134  EXPECT_CALL(prefs, GetInt64(kPrefsUpdateStateNextDataOffset, _))
135      .WillRepeatedly(DoAll(SetArgPointee<1>(0L), Return(true)));
136  EXPECT_CALL(prefs, GetString(kPrefsManifestBytes, _))
137      .WillRepeatedly(DoAll(SetArgPointee<1>(data), Return(true)));
138  EXPECT_CALL(prefs, GetInt64(kPrefsUpdateStateNextOperation, _))
139      .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(true)));
140  EXPECT_CALL(prefs, GetInt64(kPrefsUpdateStatePayloadIndex, _))
141      .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(true)));
142
143  BootControlStub boot_control;
144  MockHttpFetcher* http_fetcher =
145      new MockHttpFetcher(data.data(), data.size(), nullptr);
146  http_fetcher->set_delay(false);
147  InstallPlan install_plan;
148  auto& payload = install_plan.payloads.emplace_back();
149  install_plan.download_url = "http://fake_url.invalid";
150  payload.size = data.size();
151  payload.payload_urls.emplace_back("http://fake_url.invalid");
152  install_plan.is_resume = true;
153  auto& install_part = install_plan.partitions.emplace_back();
154  install_part.source_path = partition_file.path();
155  install_part.target_path = partition_file.path();
156  action_pipe->set_contents(install_plan);
157
158  FakeHardware hardware;
159  // takes ownership of passed in HttpFetcher
160  auto download_action = std::make_unique<DownloadAction>(
161      &prefs, &boot_control, &hardware, http_fetcher, false /* interactive */);
162
163  auto delta_performer = std::make_unique<DeltaPerformer>(&prefs,
164                                                          &boot_control,
165                                                          &hardware,
166                                                          nullptr,
167                                                          &install_plan,
168                                                          &payload,
169                                                          false);
170  delta_performer->set_public_key_path(kUnittestPublicKeyPath);
171  download_action->SetTestFileWriter(std::move(delta_performer));
172  download_action->set_in_pipe(action_pipe);
173  MockActionProcessor mock_processor;
174  download_action->SetProcessor(&mock_processor);
175  download_action->PerformAction();
176
177  // Manifest is cached, so no data should be downloaded from http fetcher.
178  ASSERT_EQ(download_action->http_fetcher()->GetBytesDownloaded(), 0UL);
179}
180}  // namespace chromeos_update_engine
181