blob: fc6f01a7f171c5d113eb4ffc7c91011720f1e618 [file] [log] [blame]
Patrick Venture22e38752018-11-21 08:52:49 -08001/*
2 * Copyright 2018 Google Inc.
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
Patrick Venturec7ca2912018-11-02 11:38:33 -070017#include "firmware_handler.hpp"
18
Patrick Venturea78e39f2018-11-06 18:37:06 -080019#include "image_handler.hpp"
Patrick Venture7dad86f2019-05-17 08:52:20 -070020#include "util.hpp"
Patrick Venture26a17262019-05-20 11:03:35 -070021#include "verify.hpp"
Patrick Venturea78e39f2018-11-06 18:37:06 -080022
Patrick Venture137ad2c2018-11-06 11:30:43 -080023#include <algorithm>
Patrick Venture192d60f2018-11-06 11:11:59 -080024#include <cstdint>
Patrick Venture18235e62018-11-08 10:21:09 -080025#include <cstring>
Patrick Ventureb3b4db72019-05-15 11:30:24 -070026#include <fstream>
Patrick Venture68cf64f2018-11-06 10:46:51 -080027#include <memory>
Patrick Ventured333a872018-12-03 16:24:26 -080028#include <phosphor-logging/log.hpp>
Patrick Venturefa6c4d92018-11-02 18:34:53 -070029#include <string>
30#include <vector>
31
Patrick Ventured333a872018-12-03 16:24:26 -080032using namespace phosphor::logging;
33
Patrick Venture1d5a31c2019-05-20 11:38:22 -070034namespace ipmi_flash
Patrick Venturec7ca2912018-11-02 11:38:33 -070035{
Patrick Ventureb3b4db72019-05-15 11:30:24 -070036
Patrick Venture1d5a31c2019-05-20 11:38:22 -070037std::unique_ptr<blobs::GenericBlobInterface>
Patrick Venture148cd652018-11-06 10:59:47 -080038 FirmwareBlobHandler::CreateFirmwareBlobHandler(
Patrick Venture3ecb3502019-05-17 11:03:51 -070039 const std::vector<HandlerPack>& firmwares,
Patrick Venture74059d62019-05-17 10:40:26 -070040 const std::vector<DataHandlerPack>& transports,
Patrick Venture3ecb3502019-05-17 11:03:51 -070041 std::unique_ptr<VerificationInterface> verification)
Patrick Venture68cf64f2018-11-06 10:46:51 -080042{
Patrick Venture52854622018-11-06 12:30:00 -080043 /* There must be at least one. */
44 if (!firmwares.size())
45 {
Patrick Ventured333a872018-12-03 16:24:26 -080046 log<level::ERR>("Must provide at least one firmware handler.");
Patrick Venture52854622018-11-06 12:30:00 -080047 return nullptr;
48 }
Patrick Venture1cde5f92018-11-07 08:26:47 -080049 if (!transports.size())
50 {
51 return nullptr;
52 }
Patrick Venture52854622018-11-06 12:30:00 -080053
Patrick Venturea78e39f2018-11-06 18:37:06 -080054 std::vector<std::string> blobs;
55 for (const auto& item : firmwares)
56 {
57 blobs.push_back(item.blobName);
58 }
Patrick Venture7dad86f2019-05-17 08:52:20 -070059 blobs.push_back(verifyBlobId); /* Add blob_id to always exist. */
Patrick Venture18235e62018-11-08 10:21:09 -080060
Patrick Venture7dad86f2019-05-17 08:52:20 -070061 if (0 == std::count(blobs.begin(), blobs.end(), hashBlobId))
Patrick Venture18235e62018-11-08 10:21:09 -080062 {
63 return nullptr;
64 }
Patrick Venture4cceb8e2018-11-06 11:56:48 -080065
Patrick Venture1cde5f92018-11-07 08:26:47 -080066 std::uint16_t bitmask = 0;
67 for (const auto& item : transports)
68 {
69 /* TODO: can use std::accumulate() unless I'm mistaken. :D */
70 bitmask |= item.bitmask;
71 }
72
Patrick Venture3ecb3502019-05-17 11:03:51 -070073 return std::make_unique<FirmwareBlobHandler>(
74 firmwares, blobs, transports, bitmask, std::move(verification));
Patrick Venture68cf64f2018-11-06 10:46:51 -080075}
76
Patrick Ventured6461d62018-11-09 17:30:25 -080077/* Check if the path is in our supported list (or active list). */
Patrick Venturec7ca2912018-11-02 11:38:33 -070078bool FirmwareBlobHandler::canHandleBlob(const std::string& path)
79{
Patrick Venture6032dc02019-05-17 11:01:44 -070080 return (std::count(blobIDs.begin(), blobIDs.end(), path) > 0);
Patrick Venturec7ca2912018-11-02 11:38:33 -070081}
Patrick Venture53977962018-11-02 18:59:35 -070082
Patrick Ventured6461d62018-11-09 17:30:25 -080083/*
84 * Grab the list of supported firmware.
85 *
86 * If there's an open firmware session, it'll already be present in the
87 * list as "/flash/active/image", and if the hash has started,
88 * "/flash/active/hash" regardless of mechanism. This is done in the open
89 * comamnd, no extra work is required here.
90 */
Patrick Venturec7ca2912018-11-02 11:38:33 -070091std::vector<std::string> FirmwareBlobHandler::getBlobIds()
92{
Patrick Venture4cceb8e2018-11-06 11:56:48 -080093 return blobIDs;
Patrick Venturec7ca2912018-11-02 11:38:33 -070094}
Patrick Venture53977962018-11-02 18:59:35 -070095
Patrick Ventured6461d62018-11-09 17:30:25 -080096/*
97 * Per the design, this mean abort, and this will trigger whatever
98 * appropriate actions are required to abort the process.
Patrick Venture9e5aab22018-11-09 20:49:28 -080099 *
100 * You cannot delete a blob that has an open handle in the system, therefore
101 * this is never called if there's an open session. Guaranteed by the blob
102 * manager.
Patrick Ventured6461d62018-11-09 17:30:25 -0800103 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700104bool FirmwareBlobHandler::deleteBlob(const std::string& path)
105{
Patrick Venture9e5aab22018-11-09 20:49:28 -0800106 const std::string* toDelete;
107
Patrick Ventureffcc5502018-11-16 12:32:38 -0800108 /* You cannot delete the verify blob -- trying to delete it, currently has
109 * no impact.
110 * TODO: Should trying to delete this cause an abort?
111 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700112 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800113 {
114 return false;
115 }
116
Patrick Venture7dad86f2019-05-17 08:52:20 -0700117 if (path == hashBlobId || path == activeHashBlobId)
Patrick Venture9e5aab22018-11-09 20:49:28 -0800118 {
119 /* They're deleting the hash. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700120 toDelete = &activeHashBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800121 }
122 else
123 {
124 /* They're deleting the image. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700125 toDelete = &activeImageBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800126 }
127
128 auto it = std::find_if(
129 blobIDs.begin(), blobIDs.end(),
130 [toDelete](const auto& iter) { return (iter == *toDelete); });
131 if (it == blobIDs.end())
132 {
133 /* Somehow they've asked to delete something we didn't say we could
134 * handle.
135 */
136 return false;
137 }
138
139 blobIDs.erase(it);
140
141 /* TODO: Handle aborting the process and fixing up the state. */
142
143 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700144}
Patrick Venture53977962018-11-02 18:59:35 -0700145
Patrick Ventured6461d62018-11-09 17:30:25 -0800146/*
147 * Stat on the files will return information such as what supported
148 * transport mechanisms are available.
149 *
150 * Stat on an active file or hash will return information such as the size
151 * of the data cached, and any additional pertinent information. The
152 * blob_state on the active files will return the state of the update.
153 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700154bool FirmwareBlobHandler::stat(const std::string& path,
155 struct blobs::BlobMeta* meta)
Patrick Venturec7ca2912018-11-02 11:38:33 -0700156{
Patrick Venture46637c82018-11-06 15:20:24 -0800157 /* We know we support this path because canHandle is called ahead */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700158 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800159 {
Patrick Venture699750d2019-05-15 09:24:09 -0700160 /* TODO: We need to return information for the verify state -- did they
161 * call commit() did things start?
Patrick Ventureffcc5502018-11-16 12:32:38 -0800162 */
163 }
Patrick Venture7dad86f2019-05-17 08:52:20 -0700164 else if (path == activeImageBlobId)
Patrick Venture46637c82018-11-06 15:20:24 -0800165 {
Patrick Venture699750d2019-05-15 09:24:09 -0700166 /* TODO: We need to return information for the image that's staged. */
Patrick Venture46637c82018-11-06 15:20:24 -0800167 }
Patrick Venture7dad86f2019-05-17 08:52:20 -0700168 else if (path == activeHashBlobId)
Patrick Venture46637c82018-11-06 15:20:24 -0800169 {
Patrick Venture699750d2019-05-15 09:24:09 -0700170 /* TODO: We need to return information for the hash that's staged. */
Patrick Venture46637c82018-11-06 15:20:24 -0800171 }
172 else
173 {
174 /* They are requesting information about the generic blob_id. */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800175 meta->blobState = bitmask;
Patrick Venture46637c82018-11-06 15:20:24 -0800176 meta->size = 0;
177
178 /* The generic blob_ids state is only the bits related to the transport
Patrick Ventured6461d62018-11-09 17:30:25 -0800179 * mechanisms.
180 */
Patrick Venture46637c82018-11-06 15:20:24 -0800181 return true;
182 }
183
Patrick Venturec7ca2912018-11-02 11:38:33 -0700184 return false;
185}
Patrick Venture53977962018-11-02 18:59:35 -0700186
Patrick Venturec02849b2018-11-06 17:31:15 -0800187/*
Patrick Ventured6461d62018-11-09 17:30:25 -0800188 * Return stat information on an open session. It therefore must be an active
189 * handle to either the active image or active hash.
190 *
191 * The stat() and sessionstat() commands will return the same information in
192 * many cases, therefore the logic will be combined.
193 *
194 * TODO: combine the logic for stat and sessionstat().
195 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700196bool FirmwareBlobHandler::stat(uint16_t session, struct blobs::BlobMeta* meta)
Patrick Ventured6461d62018-11-09 17:30:25 -0800197{
Patrick Venturecc7d1602018-11-15 13:58:33 -0800198 auto item = lookup.find(session);
199 if (item == lookup.end())
200 {
201 return false;
202 }
203
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700204 /* The size here refers to the size of the file -- of something analagous.
205 */
206 meta->size = (item->second->imageHandler)
207 ? item->second->imageHandler->getSize()
208 : 0;
209
210 meta->metadata.clear();
211
Patrick Venture699750d2019-05-15 09:24:09 -0700212 /* TODO: Implement this for the verification blob, which is what we expect.
213 * Calling stat() on the verify blob without an active session should not
214 * provide insight.
215 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700216 if (item->second->activePath == verifyBlobId)
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700217 {
Patrick Venture3ecb3502019-05-17 11:03:51 -0700218 auto value = verification->checkVerificationState();
Patrick Venture699750d2019-05-15 09:24:09 -0700219
Patrick Venturee955e072019-05-15 16:16:46 -0700220 meta->metadata.push_back(static_cast<std::uint8_t>(value));
221
222 /* Change the firmware handler's state and the blob's stat value
223 * depending.
224 */
225 if (value == VerifyCheckResponses::success ||
226 value == VerifyCheckResponses::failed)
227 {
228 state = UpdateState::verificationCompleted;
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700229 item->second->flags &= ~blobs::StateFlags::committing;
Patrick Venturee955e072019-05-15 16:16:46 -0700230
231 if (value == VerifyCheckResponses::success)
232 {
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700233 item->second->flags |= blobs::StateFlags::committed;
Patrick Venturee955e072019-05-15 16:16:46 -0700234 }
235 else
236 {
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700237 item->second->flags |= blobs::StateFlags::commit_error;
Patrick Venturee955e072019-05-15 16:16:46 -0700238 }
239 }
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700240 }
Patrick Venturecc7d1602018-11-15 13:58:33 -0800241
Patrick Venturee955e072019-05-15 16:16:46 -0700242 /* The blobState here relates to an active sesion, so we should return the
243 * flags used to open this session.
244 */
245 meta->blobState = item->second->flags;
246
Patrick Venturecc7d1602018-11-15 13:58:33 -0800247 /* The metadata blob returned comes from the data handler... it's used for
248 * instance, in P2A bridging to get required information about the mapping,
249 * and is the "opposite" of the lpc writemeta requirement.
250 */
Patrick Venturecc7d1602018-11-15 13:58:33 -0800251 if (item->second->dataHandler)
252 {
Patrick Venture74304642019-01-17 09:31:04 -0800253 auto bytes = item->second->dataHandler->readMeta();
Patrick Venturecc7d1602018-11-15 13:58:33 -0800254 meta->metadata.insert(meta->metadata.begin(), bytes.begin(),
255 bytes.end());
256 }
257
Patrick Venturecc7d1602018-11-15 13:58:33 -0800258 return true;
Patrick Ventured6461d62018-11-09 17:30:25 -0800259}
260
261/*
Patrick Venturec02849b2018-11-06 17:31:15 -0800262 * If you open /flash/image or /flash/tarball, or /flash/hash it will
263 * interpret the open flags and perform whatever actions are required for
264 * that update process. The session returned can be used immediately for
265 * sending data down, without requiring one to open the new active file.
266 *
267 * If you open the active flash image or active hash it will let you
268 * overwrite pieces, depending on the state.
269 *
270 * Once the verification process has started the active files cannot be
271 * opened.
272 *
273 * You can only have one open session at a time. Which means, you can only
274 * have one file open at a time. Trying to open the hash blob_id while you
275 * still have the flash image blob_id open will fail. Opening the flash
276 * blob_id when it is already open will fail.
277 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700278bool FirmwareBlobHandler::open(uint16_t session, uint16_t flags,
279 const std::string& path)
280{
Patrick Venture6e307a72018-11-09 18:21:17 -0800281 /* Check that they've opened for writing - read back not currently
282 * supported.
283 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700284 if ((flags & blobs::OpenFlags::write) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800285 {
286 return false;
287 }
288
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800289 /* Is the verification process underway? */
290 if (state == UpdateState::verificationStarted)
291 {
292 return false;
293 }
Patrick Venturec02849b2018-11-06 17:31:15 -0800294
295 /* Is there an open session already? We only allow one at a time.
Patrick Venture6e307a72018-11-09 18:21:17 -0800296 *
Patrick Venturec02849b2018-11-06 17:31:15 -0800297 * TODO: Temporarily using a simple boolean flag until there's a full
298 * session object to check.
Patrick Venture7c8b97e2018-11-08 09:14:30 -0800299 *
300 * Further on this, if there's an active session to the hash we don't allow
301 * re-opening the image, and if we have the image open, we don't allow
302 * opening the hash. This design decision may be re-evaluated, and changed
303 * to only allow one session per object type (of the two types). But,
304 * consider if the hash is open, do we want to allow writing to the image?
305 * And why would we? But, really, the point of no-return is once the
306 * verification process has begun -- which is done via commit() on the hash
307 * blob_id, we no longer want to allow updating the contents.
Patrick Venture53977962018-11-02 18:59:35 -0700308 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800309 if (fileOpen)
310 {
311 return false;
312 }
313
Patrick Ventureffcc5502018-11-16 12:32:38 -0800314 /* Handle opening the verifyBlobId --> we know the image and hash aren't
315 * open because of the fileOpen check.
316 *
317 * The file must be opened for writing, but no transport mechanism specified
318 * since it's irrelevant.
319 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700320 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800321 {
322 /* In this case, there's no image handler to use, or data handler,
323 * simply set up a session.
324 */
325 verifyImage.flags = flags;
326 verifyImage.state = Session::State::open;
327
328 lookup[session] = &verifyImage;
329
330 fileOpen = true;
331
332 return true;
333 }
334
Patrick Venturec02849b2018-11-06 17:31:15 -0800335 /* There are two abstractions at play, how you get the data and how you
336 * handle that data. such that, whether the data comes from the PCI bridge
337 * or LPC bridge is not connected to whether the data goes into a static
338 * layout flash update or a UBI tarball.
339 */
340
341 /* Check the flags for the transport mechanism: if none match we don't
Patrick Venture18235e62018-11-08 10:21:09 -0800342 * support what they request.
343 */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800344 if ((flags & bitmask) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800345 {
346 return false;
347 }
348
349 /* 2) there isn't, so what are they opening? */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700350 if (path == activeImageBlobId)
Patrick Venturec02849b2018-11-06 17:31:15 -0800351 {
352 /* 2a) are they opening the active image? this can only happen if they
Patrick Venture18235e62018-11-08 10:21:09 -0800353 * already started one (due to canHandleBlob's behavior).
354 */
Patrick Venture21c62c12018-11-09 17:46:58 -0800355 return false;
Patrick Venturec02849b2018-11-06 17:31:15 -0800356 }
Patrick Venture7dad86f2019-05-17 08:52:20 -0700357 else if (path == activeHashBlobId)
Patrick Venturec02849b2018-11-06 17:31:15 -0800358 {
359 /* 2b) are they opening the active hash? this can only happen if they
Patrick Venture18235e62018-11-08 10:21:09 -0800360 * already started one (due to canHandleBlob's behavior).
361 */
Patrick Venture21c62c12018-11-09 17:46:58 -0800362 return false;
Patrick Venturec02849b2018-11-06 17:31:15 -0800363 }
Patrick Venture18235e62018-11-08 10:21:09 -0800364
365 /* How are they expecting to copy this data? */
366 auto d = std::find_if(
367 transports.begin(), transports.end(),
368 [&flags](const auto& iter) { return (iter.bitmask & flags); });
369 if (d == transports.end())
Patrick Venturec02849b2018-11-06 17:31:15 -0800370 {
Patrick Venture18235e62018-11-08 10:21:09 -0800371 return false;
372 }
373
374 /* We found the transport handler they requested, no surprise since
375 * above we verify they selected at least one we wanted.
376 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800377
Patrick Venture6e307a72018-11-09 18:21:17 -0800378 /* Elsewhere I do this check by checking "if ::ipmi" because that's the
379 * only non-external data pathway -- but this is just a more generic
380 * approach to that.
381 */
382 if (d->handler)
383 {
384 /* If the data handler open call fails, open fails. */
385 if (!d->handler->open())
386 {
387 return false;
388 }
389 }
390
Patrick Venture70e30bf2019-01-17 10:29:28 -0800391 /* Do we have a file handler for the type of file they're opening.
392 * Note: This should only fail if something is somehow crazy wrong.
393 * Since the canHandle() said yes, and that's tied into the list of explicit
394 * firmware handers (and file handlers, like this'll know where to write the
395 * tarball, etc).
Patrick Venture18235e62018-11-08 10:21:09 -0800396 */
Patrick Venture18235e62018-11-08 10:21:09 -0800397 auto h = std::find_if(
398 handlers.begin(), handlers.end(),
399 [&path](const auto& iter) { return (iter.blobName == path); });
400 if (h == handlers.end())
401 {
402 return false;
403 }
404
405 /* Ok, so we found a handler that matched, so call open() */
406 if (!h->handler->open(path))
407 {
408 return false;
409 }
410
Patrick Venture70e30bf2019-01-17 10:29:28 -0800411 Session* curr;
412 const std::string* active;
413
Patrick Venture7dad86f2019-05-17 08:52:20 -0700414 if (path == hashBlobId)
Patrick Venture70e30bf2019-01-17 10:29:28 -0800415 {
416 /* 2c) are they opening the /flash/hash ? (to start the process) */
417 curr = &activeHash;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700418 active = &activeHashBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800419 }
420 else
421 {
422 curr = &activeImage;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700423 active = &activeImageBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800424 }
425
Patrick Venture18235e62018-11-08 10:21:09 -0800426 curr->flags = flags;
427 curr->dataHandler = d->handler;
428 curr->imageHandler = h->handler;
Patrick Venturecd310222018-11-09 18:47:13 -0800429 curr->state = Session::State::open;
Patrick Venture18235e62018-11-08 10:21:09 -0800430
431 lookup[session] = curr;
432
Patrick Venturedaf47072019-05-10 15:21:55 -0700433 /* This may be them re-opening a blob, so let's only push it onto the list
434 * when appropriate.
435 */
436 auto blobIdMatch =
437 std::find_if(blobIDs.begin(), blobIDs.end(),
438 [active](const auto& iter) { return (iter == *active); });
439 if (blobIdMatch == blobIDs.end())
440 {
441 blobIDs.push_back(*active);
442 }
Patrick Venturedb253bf2018-11-09 19:36:03 -0800443
Patrick Venture12233c52019-05-16 09:26:59 -0700444 state = UpdateState::uploadInProgress;
Patrick Venture991910a2018-11-09 19:43:48 -0800445 fileOpen = true;
446
Patrick Venture18235e62018-11-08 10:21:09 -0800447 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700448}
Patrick Venture53977962018-11-02 18:59:35 -0700449
Patrick Venture18235e62018-11-08 10:21:09 -0800450/**
451 * The write command really just grabs the data from wherever it is and sends it
452 * to the image handler. It's the image handler's responsibility to deal with
453 * the data provided.
Patrick Ventured6461d62018-11-09 17:30:25 -0800454 *
455 * This receives a session from the blob manager, therefore it is always called
456 * between open() and close().
Patrick Venture18235e62018-11-08 10:21:09 -0800457 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700458bool FirmwareBlobHandler::write(uint16_t session, uint32_t offset,
459 const std::vector<uint8_t>& data)
460{
Patrick Venture18235e62018-11-08 10:21:09 -0800461 auto item = lookup.find(session);
462 if (item == lookup.end())
463 {
464 return false;
465 }
466
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800467 /* Prevent writing during verification. */
468 if (state == UpdateState::verificationStarted)
469 {
470 return false;
471 }
472
Patrick Venture8af15eb2019-05-15 09:39:22 -0700473 /* Prevent writing to the verification blob before they trigger
Patrick Venture699750d2019-05-15 09:24:09 -0700474 * verification.
475 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700476 if (item->second->activePath == verifyBlobId)
Patrick Venture8af15eb2019-05-15 09:39:22 -0700477 {
478 return false;
479 }
Patrick Venture699750d2019-05-15 09:24:09 -0700480
Patrick Venture18235e62018-11-08 10:21:09 -0800481 std::vector<std::uint8_t> bytes;
482
Patrick Venture05abf7e2018-11-09 11:02:56 -0800483 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture18235e62018-11-08 10:21:09 -0800484 {
485 bytes = data;
486 }
487 else
488 {
489 /* little endian required per design, and so on, but TODO: do endianness
490 * with boost.
491 */
492 struct ExtChunkHdr header;
493
494 if (data.size() != sizeof(header))
495 {
496 return false;
497 }
498
499 std::memcpy(&header, data.data(), data.size());
500 bytes = item->second->dataHandler->copyFrom(header.length);
501 }
502
503 return item->second->imageHandler->write(offset, bytes);
Patrick Venturec7ca2912018-11-02 11:38:33 -0700504}
Patrick Venture18235e62018-11-08 10:21:09 -0800505
Patrick Venture8c535332018-11-08 15:58:00 -0800506/*
507 * If the active session (image or hash) is over LPC, this allows
508 * configuring it. This option is only available before you start
509 * writing data for the given item (image or hash). This will return
510 * false at any other part. -- the lpc handler portion will know to return
511 * false.
512 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700513bool FirmwareBlobHandler::writeMeta(uint16_t session, uint32_t offset,
514 const std::vector<uint8_t>& data)
515{
Patrick Venture8c535332018-11-08 15:58:00 -0800516 auto item = lookup.find(session);
517 if (item == lookup.end())
518 {
519 return false;
520 }
521
Patrick Venture05abf7e2018-11-09 11:02:56 -0800522 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture8c535332018-11-08 15:58:00 -0800523 {
524 return false;
525 }
526
Patrick Ventured56097a2019-05-15 09:47:55 -0700527 /* Prevent writing meta to the verification blob (it has no data handler).
528 */
529 if (item->second->dataHandler)
530 {
531 return item->second->dataHandler->writeMeta(data);
532 }
Patrick Venture699750d2019-05-15 09:24:09 -0700533
Patrick Ventured56097a2019-05-15 09:47:55 -0700534 return false;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700535}
Patrick Venture8c535332018-11-08 15:58:00 -0800536
Patrick Ventured6461d62018-11-09 17:30:25 -0800537/*
Patrick Venture7dad86f2019-05-17 08:52:20 -0700538 * If this command is called on the session for the verifyBlobId, it'll
Patrick Ventured6461d62018-11-09 17:30:25 -0800539 * trigger a systemd service `verify_image.service` to attempt to verify
Patrick Ventureffcc5502018-11-16 12:32:38 -0800540 * the image.
541 *
542 * For this file to have opened, the other two must be closed, which means any
543 * out-of-band transport mechanism involved is closed.
Patrick Ventured6461d62018-11-09 17:30:25 -0800544 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700545bool FirmwareBlobHandler::commit(uint16_t session,
546 const std::vector<uint8_t>& data)
547{
Patrick Ventureffcc5502018-11-16 12:32:38 -0800548 auto item = lookup.find(session);
549 if (item == lookup.end())
550 {
551 return false;
552 }
553
554 /* You can only commit on the verifyBlodId */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700555 if (item->second->activePath != verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800556 {
557 return false;
558 }
559
Patrick Venturebe198702019-05-15 09:46:02 -0700560 /* Calling repeatedly has no effect within an update process. */
Patrick Ventureffcc5502018-11-16 12:32:38 -0800561 if (state == UpdateState::verificationStarted)
562 {
Patrick Venturebe198702019-05-15 09:46:02 -0700563 return true;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800564 }
565
566 /* Set state to committing. */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700567 item->second->flags |= blobs::StateFlags::committing;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800568
569 return triggerVerification();
Patrick Venturec7ca2912018-11-02 11:38:33 -0700570}
Patrick Ventured6461d62018-11-09 17:30:25 -0800571
572/*
573 * Close must be called on the firmware image before triggering
574 * verification via commit. Once the verification is complete, you can
575 * then close the hash file.
576 *
577 * If the `verify_image.service` returned success, closing the hash file
578 * will have a specific behavior depending on the update. If it's UBI,
579 * it'll perform the install. If it's static layout, it'll do nothing. The
580 * verify_image service in the static layout case is responsible for placing
581 * the file in the correct staging position.
582 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700583bool FirmwareBlobHandler::close(uint16_t session)
584{
Patrick Venture68bb1432018-11-09 20:08:48 -0800585 auto item = lookup.find(session);
586 if (item == lookup.end())
587 {
588 return false;
589 }
590
Patrick Ventureffcc5502018-11-16 12:32:38 -0800591 /* Are you closing the verify blob? */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700592 if (item->second->activePath == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800593 {
Patrick Ventureffcc5502018-11-16 12:32:38 -0800594 if (state == UpdateState::verificationStarted)
595 {
Patrick Venture12233c52019-05-16 09:26:59 -0700596 /* TODO: If they close this blob before verification finishes,
597 * that's an abort.
598 */
Patrick Ventureffcc5502018-11-16 12:32:38 -0800599 return false;
600 }
Patrick Venture12233c52019-05-16 09:26:59 -0700601 else if (state == UpdateState::verificationCompleted)
602 {
603 /* TODO: Should this delete the verification artifact? */
604 state = UpdateState::notYetStarted;
605
606 /* A this point, delete the active blob IDs from the blob_list. */
607 blobIDs.erase(
Patrick Venture7dad86f2019-05-17 08:52:20 -0700608 std::remove(blobIDs.begin(), blobIDs.end(), activeImageBlobId));
Patrick Venture12233c52019-05-16 09:26:59 -0700609 blobIDs.erase(
Patrick Venture7dad86f2019-05-17 08:52:20 -0700610 std::remove(blobIDs.begin(), blobIDs.end(), activeHashBlobId));
Patrick Venture12233c52019-05-16 09:26:59 -0700611 }
612 /* Must be verificationPending... not yet started, they may re-open and
613 * trigger verification.
614 */
615 }
616 else
617 {
618 /* They are closing a data pathway (image, tarball, hash). */
619 state = UpdateState::verificationPending;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800620 }
621
Patrick Venture68bb1432018-11-09 20:08:48 -0800622 if (item->second->dataHandler)
623 {
624 item->second->dataHandler->close();
625 }
Patrick Ventureffcc5502018-11-16 12:32:38 -0800626 if (item->second->imageHandler)
627 {
628 item->second->imageHandler->close();
629 }
630
Patrick Venture68bb1432018-11-09 20:08:48 -0800631 item->second->state = Session::State::closed;
632 /* Do not delete the active blob_id from the list of blob_ids, because that
633 * blob_id indicates there is data stored. Delete will destroy it.
634 */
635
636 lookup.erase(item);
637
Patrick Venture991910a2018-11-09 19:43:48 -0800638 fileOpen = false;
639
Patrick Venture68bb1432018-11-09 20:08:48 -0800640 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700641}
Patrick Ventured6461d62018-11-09 17:30:25 -0800642
Patrick Venturec7ca2912018-11-02 11:38:33 -0700643bool FirmwareBlobHandler::expire(uint16_t session)
644{
645 return false;
646}
Patrick Ventured6461d62018-11-09 17:30:25 -0800647
648/*
649 * Currently, the design does not provide this with a function, however,
650 * it will likely change to support reading data back.
651 */
652std::vector<uint8_t> FirmwareBlobHandler::read(uint16_t session,
653 uint32_t offset,
654 uint32_t requestedSize)
655{
656 return {};
657}
658
Patrick Ventureffcc5502018-11-16 12:32:38 -0800659bool FirmwareBlobHandler::triggerVerification()
660{
Patrick Venture3ecb3502019-05-17 11:03:51 -0700661 bool result = verification->triggerVerification();
662 if (result)
Patrick Venturecabc1172018-11-16 16:14:26 -0800663 {
Patrick Venture453f06a2019-01-17 10:02:12 -0800664 state = UpdateState::verificationStarted;
Patrick Venturecabc1172018-11-16 16:14:26 -0800665 }
Patrick Venturecabc1172018-11-16 16:14:26 -0800666
Patrick Venture3ecb3502019-05-17 11:03:51 -0700667 return result;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800668}
669
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700670} // namespace ipmi_flash