blob: 15dbee883ec6870b6b4818d16e853bc6c8ddfd53 [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 Venture27ac5822019-05-20 17:39:31 -070041 std::unique_ptr<VerificationInterface> verification,
42 std::unique_ptr<UpdateInterface> update)
Patrick Venture68cf64f2018-11-06 10:46:51 -080043{
Patrick Venture52854622018-11-06 12:30:00 -080044 /* There must be at least one. */
45 if (!firmwares.size())
46 {
Patrick Ventured333a872018-12-03 16:24:26 -080047 log<level::ERR>("Must provide at least one firmware handler.");
Patrick Venture52854622018-11-06 12:30:00 -080048 return nullptr;
49 }
Patrick Venture1cde5f92018-11-07 08:26:47 -080050 if (!transports.size())
51 {
52 return nullptr;
53 }
Patrick Venture52854622018-11-06 12:30:00 -080054
Patrick Venturea78e39f2018-11-06 18:37:06 -080055 std::vector<std::string> blobs;
56 for (const auto& item : firmwares)
57 {
58 blobs.push_back(item.blobName);
59 }
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>(
Patrick Venture27ac5822019-05-20 17:39:31 -070074 firmwares, blobs, transports, bitmask, std::move(verification),
75 std::move(update));
Patrick Venture68cf64f2018-11-06 10:46:51 -080076}
77
Patrick Ventured6461d62018-11-09 17:30:25 -080078/* Check if the path is in our supported list (or active list). */
Patrick Venturec7ca2912018-11-02 11:38:33 -070079bool FirmwareBlobHandler::canHandleBlob(const std::string& path)
80{
Patrick Venture6032dc02019-05-17 11:01:44 -070081 return (std::count(blobIDs.begin(), blobIDs.end(), path) > 0);
Patrick Venturec7ca2912018-11-02 11:38:33 -070082}
Patrick Venture53977962018-11-02 18:59:35 -070083
Patrick Ventured6461d62018-11-09 17:30:25 -080084/*
85 * Grab the list of supported firmware.
86 *
87 * If there's an open firmware session, it'll already be present in the
88 * list as "/flash/active/image", and if the hash has started,
89 * "/flash/active/hash" regardless of mechanism. This is done in the open
90 * comamnd, no extra work is required here.
91 */
Patrick Venturec7ca2912018-11-02 11:38:33 -070092std::vector<std::string> FirmwareBlobHandler::getBlobIds()
93{
Patrick Venture4cceb8e2018-11-06 11:56:48 -080094 return blobIDs;
Patrick Venturec7ca2912018-11-02 11:38:33 -070095}
Patrick Venture53977962018-11-02 18:59:35 -070096
Patrick Ventured6461d62018-11-09 17:30:25 -080097/*
98 * Per the design, this mean abort, and this will trigger whatever
99 * appropriate actions are required to abort the process.
Patrick Venture9e5aab22018-11-09 20:49:28 -0800100 *
101 * You cannot delete a blob that has an open handle in the system, therefore
102 * this is never called if there's an open session. Guaranteed by the blob
103 * manager.
Patrick Ventured6461d62018-11-09 17:30:25 -0800104 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700105bool FirmwareBlobHandler::deleteBlob(const std::string& path)
106{
Patrick Venture9e5aab22018-11-09 20:49:28 -0800107 const std::string* toDelete;
108
Patrick Ventureffcc5502018-11-16 12:32:38 -0800109 /* You cannot delete the verify blob -- trying to delete it, currently has
110 * no impact.
111 * TODO: Should trying to delete this cause an abort?
112 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700113 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800114 {
115 return false;
116 }
117
Patrick Venture7dad86f2019-05-17 08:52:20 -0700118 if (path == hashBlobId || path == activeHashBlobId)
Patrick Venture9e5aab22018-11-09 20:49:28 -0800119 {
120 /* They're deleting the hash. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700121 toDelete = &activeHashBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800122 }
123 else
124 {
125 /* They're deleting the image. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700126 toDelete = &activeImageBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800127 }
128
129 auto it = std::find_if(
130 blobIDs.begin(), blobIDs.end(),
131 [toDelete](const auto& iter) { return (iter == *toDelete); });
132 if (it == blobIDs.end())
133 {
134 /* Somehow they've asked to delete something we didn't say we could
135 * handle.
136 */
137 return false;
138 }
139
140 blobIDs.erase(it);
141
142 /* TODO: Handle aborting the process and fixing up the state. */
143
144 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700145}
Patrick Venture53977962018-11-02 18:59:35 -0700146
Patrick Ventured6461d62018-11-09 17:30:25 -0800147/*
148 * Stat on the files will return information such as what supported
149 * transport mechanisms are available.
150 *
151 * Stat on an active file or hash will return information such as the size
152 * of the data cached, and any additional pertinent information. The
153 * blob_state on the active files will return the state of the update.
154 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700155bool FirmwareBlobHandler::stat(const std::string& path,
156 struct blobs::BlobMeta* meta)
Patrick Venturec7ca2912018-11-02 11:38:33 -0700157{
Patrick Venture46637c82018-11-06 15:20:24 -0800158 /* We know we support this path because canHandle is called ahead */
Patrick Ventured342a952019-05-29 09:09:10 -0700159 if (path == verifyBlobId || path == activeImageBlobId ||
Patrick Venture5f562692019-05-30 16:49:46 -0700160 path == activeHashBlobId || path == updateBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800161 {
Patrick Ventured342a952019-05-29 09:09:10 -0700162 /* These blobs are placeholders that indicate things, or allow actions,
163 * but are not stat-able as-is.
Patrick Ventureffcc5502018-11-16 12:32:38 -0800164 */
Patrick Ventured342a952019-05-29 09:09:10 -0700165 return false;
Patrick Venture46637c82018-11-06 15:20:24 -0800166 }
167
Patrick Ventured342a952019-05-29 09:09:10 -0700168 /* They are requesting information about the generic blob_id. */
169 meta->blobState = bitmask;
170 meta->size = 0;
171
172 /* The generic blob_ids state is only the bits related to the transport
173 * mechanisms.
174 */
175 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700176}
Patrick Venture53977962018-11-02 18:59:35 -0700177
Patrick Venturec02849b2018-11-06 17:31:15 -0800178/*
Patrick Ventured6461d62018-11-09 17:30:25 -0800179 * Return stat information on an open session. It therefore must be an active
180 * handle to either the active image or active hash.
181 *
182 * The stat() and sessionstat() commands will return the same information in
183 * many cases, therefore the logic will be combined.
184 *
185 * TODO: combine the logic for stat and sessionstat().
186 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700187bool FirmwareBlobHandler::stat(uint16_t session, struct blobs::BlobMeta* meta)
Patrick Ventured6461d62018-11-09 17:30:25 -0800188{
Patrick Venturecc7d1602018-11-15 13:58:33 -0800189 auto item = lookup.find(session);
190 if (item == lookup.end())
191 {
192 return false;
193 }
194
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700195 /* The size here refers to the size of the file -- of something analagous.
196 */
197 meta->size = (item->second->imageHandler)
198 ? item->second->imageHandler->getSize()
199 : 0;
200
201 meta->metadata.clear();
202
Patrick Venture7dad86f2019-05-17 08:52:20 -0700203 if (item->second->activePath == verifyBlobId)
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700204 {
Patrick Venture01a33272019-05-23 19:48:22 -0700205 VerifyCheckResponses value;
206
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700207 switch (state)
Patrick Venture01a33272019-05-23 19:48:22 -0700208 {
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700209 case UpdateState::verificationPending:
210 value = VerifyCheckResponses::other;
211 break;
212 case UpdateState::verificationCompleted:
213 value = lastVerificationResponse;
214 break;
215 default:
216 value = verification->checkVerificationState();
217 lastVerificationResponse = value;
Patrick Venture01a33272019-05-23 19:48:22 -0700218 }
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 Venture40d7ffc2019-05-30 17:12:06 -0700241 else if (item->second->activePath == updateBlobId)
242 {
243 UpdateStatus value;
244
245 switch (state)
246 {
247 case UpdateState::updatePending:
248 value = UpdateStatus::unknown;
249 break;
250 default:
251 break;
252 }
253
254 meta->metadata.push_back(static_cast<std::uint8_t>(value));
255 }
Patrick Venturecc7d1602018-11-15 13:58:33 -0800256
Patrick Venturee955e072019-05-15 16:16:46 -0700257 /* The blobState here relates to an active sesion, so we should return the
258 * flags used to open this session.
259 */
260 meta->blobState = item->second->flags;
261
Patrick Venturecc7d1602018-11-15 13:58:33 -0800262 /* The metadata blob returned comes from the data handler... it's used for
263 * instance, in P2A bridging to get required information about the mapping,
264 * and is the "opposite" of the lpc writemeta requirement.
265 */
Patrick Venturecc7d1602018-11-15 13:58:33 -0800266 if (item->second->dataHandler)
267 {
Patrick Venture74304642019-01-17 09:31:04 -0800268 auto bytes = item->second->dataHandler->readMeta();
Patrick Venturecc7d1602018-11-15 13:58:33 -0800269 meta->metadata.insert(meta->metadata.begin(), bytes.begin(),
270 bytes.end());
271 }
272
Patrick Venturecc7d1602018-11-15 13:58:33 -0800273 return true;
Patrick Ventured6461d62018-11-09 17:30:25 -0800274}
275
276/*
Patrick Venturec02849b2018-11-06 17:31:15 -0800277 * If you open /flash/image or /flash/tarball, or /flash/hash it will
278 * interpret the open flags and perform whatever actions are required for
279 * that update process. The session returned can be used immediately for
280 * sending data down, without requiring one to open the new active file.
281 *
282 * If you open the active flash image or active hash it will let you
283 * overwrite pieces, depending on the state.
284 *
285 * Once the verification process has started the active files cannot be
286 * opened.
287 *
288 * You can only have one open session at a time. Which means, you can only
289 * have one file open at a time. Trying to open the hash blob_id while you
290 * still have the flash image blob_id open will fail. Opening the flash
291 * blob_id when it is already open will fail.
292 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700293bool FirmwareBlobHandler::open(uint16_t session, uint16_t flags,
294 const std::string& path)
295{
Patrick Venture6e307a72018-11-09 18:21:17 -0800296 /* Check that they've opened for writing - read back not currently
297 * supported.
298 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700299 if ((flags & blobs::OpenFlags::write) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800300 {
301 return false;
302 }
303
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800304 /* Is the verification process underway? */
305 if (state == UpdateState::verificationStarted)
306 {
307 return false;
308 }
Patrick Venturec02849b2018-11-06 17:31:15 -0800309
310 /* Is there an open session already? We only allow one at a time.
Patrick Venture6e307a72018-11-09 18:21:17 -0800311 *
Patrick Venturec02849b2018-11-06 17:31:15 -0800312 * TODO: Temporarily using a simple boolean flag until there's a full
313 * session object to check.
Patrick Venture7c8b97e2018-11-08 09:14:30 -0800314 *
315 * Further on this, if there's an active session to the hash we don't allow
316 * re-opening the image, and if we have the image open, we don't allow
317 * opening the hash. This design decision may be re-evaluated, and changed
318 * to only allow one session per object type (of the two types). But,
319 * consider if the hash is open, do we want to allow writing to the image?
320 * And why would we? But, really, the point of no-return is once the
321 * verification process has begun -- which is done via commit() on the hash
322 * blob_id, we no longer want to allow updating the contents.
Patrick Venture53977962018-11-02 18:59:35 -0700323 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800324 if (fileOpen)
325 {
326 return false;
327 }
328
Patrick Venture19f5d882019-05-30 14:34:55 -0700329 /* When in this state, they can only open the updateBlobId */
330 if (state == UpdateState::updatePending)
331 {
332 if (path != updateBlobId)
333 {
334 return false;
335 }
336 else
337 {
338 /* Similarly to verifyBlodId, this is special. */
339 updateImage.flags = flags;
340 updateImage.state = Session::State::open;
341
342 lookup[session] = &updateImage;
343
344 fileOpen = true;
345 return true;
346 }
347 }
348
Patrick Ventureffcc5502018-11-16 12:32:38 -0800349 /* Handle opening the verifyBlobId --> we know the image and hash aren't
350 * open because of the fileOpen check.
351 *
352 * The file must be opened for writing, but no transport mechanism specified
353 * since it's irrelevant.
354 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700355 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800356 {
357 /* In this case, there's no image handler to use, or data handler,
358 * simply set up a session.
359 */
360 verifyImage.flags = flags;
361 verifyImage.state = Session::State::open;
362
363 lookup[session] = &verifyImage;
364
365 fileOpen = true;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800366 return true;
367 }
368
Patrick Venturec02849b2018-11-06 17:31:15 -0800369 /* There are two abstractions at play, how you get the data and how you
370 * handle that data. such that, whether the data comes from the PCI bridge
371 * or LPC bridge is not connected to whether the data goes into a static
372 * layout flash update or a UBI tarball.
373 */
374
Patrick Venture19f5d882019-05-30 14:34:55 -0700375 /* 2) there isn't, so what are they opening? */
376 if (path == activeImageBlobId || path == activeHashBlobId)
377 {
378 /* 2a) are they opening the active image? this can only happen if they
379 * already started one (due to canHandleBlob's behavior).
380 */
381 /* 2b) are they opening the active hash? this can only happen if they
382 * already started one (due to canHandleBlob's behavior).
383 */
384 return false;
385 }
386
Patrick Venturec02849b2018-11-06 17:31:15 -0800387 /* Check the flags for the transport mechanism: if none match we don't
Patrick Venture18235e62018-11-08 10:21:09 -0800388 * support what they request.
389 */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800390 if ((flags & bitmask) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800391 {
392 return false;
393 }
394
Patrick Venture18235e62018-11-08 10:21:09 -0800395 /* How are they expecting to copy this data? */
396 auto d = std::find_if(
397 transports.begin(), transports.end(),
398 [&flags](const auto& iter) { return (iter.bitmask & flags); });
399 if (d == transports.end())
Patrick Venturec02849b2018-11-06 17:31:15 -0800400 {
Patrick Venture18235e62018-11-08 10:21:09 -0800401 return false;
402 }
403
404 /* We found the transport handler they requested, no surprise since
405 * above we verify they selected at least one we wanted.
406 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800407
Patrick Venture6e307a72018-11-09 18:21:17 -0800408 /* Elsewhere I do this check by checking "if ::ipmi" because that's the
409 * only non-external data pathway -- but this is just a more generic
410 * approach to that.
411 */
412 if (d->handler)
413 {
414 /* If the data handler open call fails, open fails. */
415 if (!d->handler->open())
416 {
417 return false;
418 }
419 }
420
Patrick Venture70e30bf2019-01-17 10:29:28 -0800421 /* Do we have a file handler for the type of file they're opening.
422 * Note: This should only fail if something is somehow crazy wrong.
423 * Since the canHandle() said yes, and that's tied into the list of explicit
424 * firmware handers (and file handlers, like this'll know where to write the
425 * tarball, etc).
Patrick Venture18235e62018-11-08 10:21:09 -0800426 */
Patrick Venture18235e62018-11-08 10:21:09 -0800427 auto h = std::find_if(
428 handlers.begin(), handlers.end(),
429 [&path](const auto& iter) { return (iter.blobName == path); });
430 if (h == handlers.end())
431 {
432 return false;
433 }
434
435 /* Ok, so we found a handler that matched, so call open() */
436 if (!h->handler->open(path))
437 {
438 return false;
439 }
440
Patrick Venture70e30bf2019-01-17 10:29:28 -0800441 Session* curr;
442 const std::string* active;
443
Patrick Venture7dad86f2019-05-17 08:52:20 -0700444 if (path == hashBlobId)
Patrick Venture70e30bf2019-01-17 10:29:28 -0800445 {
446 /* 2c) are they opening the /flash/hash ? (to start the process) */
447 curr = &activeHash;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700448 active = &activeHashBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800449 }
450 else
451 {
452 curr = &activeImage;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700453 active = &activeImageBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800454 }
455
Patrick Venture18235e62018-11-08 10:21:09 -0800456 curr->flags = flags;
457 curr->dataHandler = d->handler;
458 curr->imageHandler = h->handler;
Patrick Venturecd310222018-11-09 18:47:13 -0800459 curr->state = Session::State::open;
Patrick Venture18235e62018-11-08 10:21:09 -0800460
461 lookup[session] = curr;
462
Patrick Ventureefba42d2019-05-24 10:48:16 -0700463 addBlobId(*active);
Patrick Venture930c7b72019-05-24 11:11:08 -0700464 removeBlobId(verifyBlobId);
Patrick Venturedb253bf2018-11-09 19:36:03 -0800465
Patrick Venture12233c52019-05-16 09:26:59 -0700466 state = UpdateState::uploadInProgress;
Patrick Venture991910a2018-11-09 19:43:48 -0800467 fileOpen = true;
468
Patrick Venture18235e62018-11-08 10:21:09 -0800469 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700470}
Patrick Venture53977962018-11-02 18:59:35 -0700471
Patrick Venture18235e62018-11-08 10:21:09 -0800472/**
473 * The write command really just grabs the data from wherever it is and sends it
474 * to the image handler. It's the image handler's responsibility to deal with
475 * the data provided.
Patrick Ventured6461d62018-11-09 17:30:25 -0800476 *
477 * This receives a session from the blob manager, therefore it is always called
478 * between open() and close().
Patrick Venture18235e62018-11-08 10:21:09 -0800479 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700480bool FirmwareBlobHandler::write(uint16_t session, uint32_t offset,
481 const std::vector<uint8_t>& data)
482{
Patrick Venture18235e62018-11-08 10:21:09 -0800483 auto item = lookup.find(session);
484 if (item == lookup.end())
485 {
486 return false;
487 }
488
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800489 /* Prevent writing during verification. */
490 if (state == UpdateState::verificationStarted)
491 {
492 return false;
493 }
494
Patrick Venture4e2fdcd2019-05-30 14:58:57 -0700495 /* Prevent writing to the verification or update blobs. */
496 if (item->second->activePath == verifyBlobId ||
497 item->second->activePath == updateBlobId)
Patrick Venture8af15eb2019-05-15 09:39:22 -0700498 {
499 return false;
500 }
Patrick Venture699750d2019-05-15 09:24:09 -0700501
Patrick Venture18235e62018-11-08 10:21:09 -0800502 std::vector<std::uint8_t> bytes;
503
Patrick Venture05abf7e2018-11-09 11:02:56 -0800504 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture18235e62018-11-08 10:21:09 -0800505 {
506 bytes = data;
507 }
508 else
509 {
510 /* little endian required per design, and so on, but TODO: do endianness
511 * with boost.
512 */
513 struct ExtChunkHdr header;
514
515 if (data.size() != sizeof(header))
516 {
517 return false;
518 }
519
520 std::memcpy(&header, data.data(), data.size());
521 bytes = item->second->dataHandler->copyFrom(header.length);
522 }
523
524 return item->second->imageHandler->write(offset, bytes);
Patrick Venturec7ca2912018-11-02 11:38:33 -0700525}
Patrick Venture18235e62018-11-08 10:21:09 -0800526
Patrick Venture8c535332018-11-08 15:58:00 -0800527/*
528 * If the active session (image or hash) is over LPC, this allows
529 * configuring it. This option is only available before you start
530 * writing data for the given item (image or hash). This will return
531 * false at any other part. -- the lpc handler portion will know to return
532 * false.
533 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700534bool FirmwareBlobHandler::writeMeta(uint16_t session, uint32_t offset,
535 const std::vector<uint8_t>& data)
536{
Patrick Venture8c535332018-11-08 15:58:00 -0800537 auto item = lookup.find(session);
538 if (item == lookup.end())
539 {
540 return false;
541 }
542
Patrick Venture05abf7e2018-11-09 11:02:56 -0800543 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture8c535332018-11-08 15:58:00 -0800544 {
545 return false;
546 }
547
Patrick Ventured56097a2019-05-15 09:47:55 -0700548 /* Prevent writing meta to the verification blob (it has no data handler).
549 */
550 if (item->second->dataHandler)
551 {
552 return item->second->dataHandler->writeMeta(data);
553 }
Patrick Venture699750d2019-05-15 09:24:09 -0700554
Patrick Ventured56097a2019-05-15 09:47:55 -0700555 return false;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700556}
Patrick Venture8c535332018-11-08 15:58:00 -0800557
Patrick Ventured6461d62018-11-09 17:30:25 -0800558/*
Patrick Venture7dad86f2019-05-17 08:52:20 -0700559 * If this command is called on the session for the verifyBlobId, it'll
Patrick Ventured6461d62018-11-09 17:30:25 -0800560 * trigger a systemd service `verify_image.service` to attempt to verify
Patrick Ventureffcc5502018-11-16 12:32:38 -0800561 * the image.
562 *
563 * For this file to have opened, the other two must be closed, which means any
564 * out-of-band transport mechanism involved is closed.
Patrick Ventured6461d62018-11-09 17:30:25 -0800565 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700566bool FirmwareBlobHandler::commit(uint16_t session,
567 const std::vector<uint8_t>& data)
568{
Patrick Ventureffcc5502018-11-16 12:32:38 -0800569 auto item = lookup.find(session);
570 if (item == lookup.end())
571 {
572 return false;
573 }
574
575 /* You can only commit on the verifyBlodId */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700576 if (item->second->activePath != verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800577 {
578 return false;
579 }
580
Patrick Venture433cbc32019-05-30 09:53:10 -0700581 switch (state)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800582 {
Patrick Venture433cbc32019-05-30 09:53:10 -0700583 case UpdateState::verificationStarted:
584 /* Calling repeatedly has no effect within an update process. */
585 return true;
586 case UpdateState::verificationCompleted:
587 /* Calling after the verification process has completed returns
588 * failure. */
589 return false;
590 default:
591 /* Set state to committing. */
592 item->second->flags |= blobs::StateFlags::committing;
593 return triggerVerification();
Patrick Ventureffcc5502018-11-16 12:32:38 -0800594 }
Patrick Venturec7ca2912018-11-02 11:38:33 -0700595}
Patrick Ventured6461d62018-11-09 17:30:25 -0800596
597/*
598 * Close must be called on the firmware image before triggering
599 * verification via commit. Once the verification is complete, you can
600 * then close the hash file.
601 *
602 * If the `verify_image.service` returned success, closing the hash file
603 * will have a specific behavior depending on the update. If it's UBI,
604 * it'll perform the install. If it's static layout, it'll do nothing. The
605 * verify_image service in the static layout case is responsible for placing
606 * the file in the correct staging position.
607 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700608bool FirmwareBlobHandler::close(uint16_t session)
609{
Patrick Venture68bb1432018-11-09 20:08:48 -0800610 auto item = lookup.find(session);
611 if (item == lookup.end())
612 {
613 return false;
614 }
615
Patrick Ventureffcc5502018-11-16 12:32:38 -0800616 /* Are you closing the verify blob? */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700617 if (item->second->activePath == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800618 {
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700619 switch (state)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800620 {
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700621 case UpdateState::verificationStarted:
622 /* TODO: If they close this blob before verification finishes,
623 * that's an abort.
624 */
625 return false;
626 case UpdateState::verificationCompleted:
627 if (lastVerificationResponse == VerifyCheckResponses::success)
628 {
629 state = UpdateState::updatePending;
630 addBlobId(updateBlobId);
Patrick Venturead933832019-05-30 14:13:29 -0700631 removeBlobId(verifyBlobId);
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700632 }
633 else
634 {
635 /* TODO: Verification failed, what now? */
636 state = UpdateState::notYetStarted;
637 }
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700638 break;
Patrick Venture1c6d8f52019-05-30 10:53:49 -0700639 default:
Patrick Venture40d7ffc2019-05-30 17:12:06 -0700640 break;
Patrick Venture12233c52019-05-16 09:26:59 -0700641 }
642 /* Must be verificationPending... not yet started, they may re-open and
643 * trigger verification.
644 */
645 }
Patrick Venture6b0aa182019-05-30 14:47:32 -0700646 else if (item->second->activePath == updateBlobId)
647 {
648 /* nothing interesting. */
649 }
Patrick Venture12233c52019-05-16 09:26:59 -0700650 else
651 {
652 /* They are closing a data pathway (image, tarball, hash). */
653 state = UpdateState::verificationPending;
Patrick Venture930c7b72019-05-24 11:11:08 -0700654
655 /* Add verify blob ID now that we can expect it. */
656 addBlobId(verifyBlobId);
Patrick Ventureffcc5502018-11-16 12:32:38 -0800657 }
658
Patrick Venture68bb1432018-11-09 20:08:48 -0800659 if (item->second->dataHandler)
660 {
661 item->second->dataHandler->close();
662 }
Patrick Ventureffcc5502018-11-16 12:32:38 -0800663 if (item->second->imageHandler)
664 {
665 item->second->imageHandler->close();
666 }
667
Patrick Venture68bb1432018-11-09 20:08:48 -0800668 item->second->state = Session::State::closed;
Patrick Venture68bb1432018-11-09 20:08:48 -0800669 lookup.erase(item);
Patrick Venture991910a2018-11-09 19:43:48 -0800670 fileOpen = false;
Patrick Venture68bb1432018-11-09 20:08:48 -0800671 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700672}
Patrick Ventured6461d62018-11-09 17:30:25 -0800673
Patrick Venturec7ca2912018-11-02 11:38:33 -0700674bool FirmwareBlobHandler::expire(uint16_t session)
675{
676 return false;
677}
Patrick Ventured6461d62018-11-09 17:30:25 -0800678
679/*
680 * Currently, the design does not provide this with a function, however,
681 * it will likely change to support reading data back.
682 */
683std::vector<uint8_t> FirmwareBlobHandler::read(uint16_t session,
684 uint32_t offset,
685 uint32_t requestedSize)
686{
687 return {};
688}
689
Patrick Ventureffcc5502018-11-16 12:32:38 -0800690bool FirmwareBlobHandler::triggerVerification()
691{
Patrick Venture3ecb3502019-05-17 11:03:51 -0700692 bool result = verification->triggerVerification();
693 if (result)
Patrick Venturecabc1172018-11-16 16:14:26 -0800694 {
Patrick Venture453f06a2019-01-17 10:02:12 -0800695 state = UpdateState::verificationStarted;
Patrick Venturecabc1172018-11-16 16:14:26 -0800696 }
Patrick Venturecabc1172018-11-16 16:14:26 -0800697
Patrick Venture3ecb3502019-05-17 11:03:51 -0700698 return result;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800699}
700
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700701} // namespace ipmi_flash