blob: 39086bedb500bb5ecc56efdbb57b06c0ea8bc4c3 [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 Venture7dad86f2019-05-17 08:52:20 -070060 blobs.push_back(verifyBlobId); /* Add blob_id to always exist. */
Patrick Venture18235e62018-11-08 10:21:09 -080061
Patrick Venture7dad86f2019-05-17 08:52:20 -070062 if (0 == std::count(blobs.begin(), blobs.end(), hashBlobId))
Patrick Venture18235e62018-11-08 10:21:09 -080063 {
64 return nullptr;
65 }
Patrick Venture4cceb8e2018-11-06 11:56:48 -080066
Patrick Venture1cde5f92018-11-07 08:26:47 -080067 std::uint16_t bitmask = 0;
68 for (const auto& item : transports)
69 {
70 /* TODO: can use std::accumulate() unless I'm mistaken. :D */
71 bitmask |= item.bitmask;
72 }
73
Patrick Venture3ecb3502019-05-17 11:03:51 -070074 return std::make_unique<FirmwareBlobHandler>(
Patrick Venture27ac5822019-05-20 17:39:31 -070075 firmwares, blobs, transports, bitmask, std::move(verification),
76 std::move(update));
Patrick Venture68cf64f2018-11-06 10:46:51 -080077}
78
Patrick Ventured6461d62018-11-09 17:30:25 -080079/* Check if the path is in our supported list (or active list). */
Patrick Venturec7ca2912018-11-02 11:38:33 -070080bool FirmwareBlobHandler::canHandleBlob(const std::string& path)
81{
Patrick Venture6032dc02019-05-17 11:01:44 -070082 return (std::count(blobIDs.begin(), blobIDs.end(), path) > 0);
Patrick Venturec7ca2912018-11-02 11:38:33 -070083}
Patrick Venture53977962018-11-02 18:59:35 -070084
Patrick Ventured6461d62018-11-09 17:30:25 -080085/*
86 * Grab the list of supported firmware.
87 *
88 * If there's an open firmware session, it'll already be present in the
89 * list as "/flash/active/image", and if the hash has started,
90 * "/flash/active/hash" regardless of mechanism. This is done in the open
91 * comamnd, no extra work is required here.
92 */
Patrick Venturec7ca2912018-11-02 11:38:33 -070093std::vector<std::string> FirmwareBlobHandler::getBlobIds()
94{
Patrick Venture4cceb8e2018-11-06 11:56:48 -080095 return blobIDs;
Patrick Venturec7ca2912018-11-02 11:38:33 -070096}
Patrick Venture53977962018-11-02 18:59:35 -070097
Patrick Ventured6461d62018-11-09 17:30:25 -080098/*
99 * Per the design, this mean abort, and this will trigger whatever
100 * appropriate actions are required to abort the process.
Patrick Venture9e5aab22018-11-09 20:49:28 -0800101 *
102 * You cannot delete a blob that has an open handle in the system, therefore
103 * this is never called if there's an open session. Guaranteed by the blob
104 * manager.
Patrick Ventured6461d62018-11-09 17:30:25 -0800105 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700106bool FirmwareBlobHandler::deleteBlob(const std::string& path)
107{
Patrick Venture9e5aab22018-11-09 20:49:28 -0800108 const std::string* toDelete;
109
Patrick Ventureffcc5502018-11-16 12:32:38 -0800110 /* You cannot delete the verify blob -- trying to delete it, currently has
111 * no impact.
112 * TODO: Should trying to delete this cause an abort?
113 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700114 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800115 {
116 return false;
117 }
118
Patrick Venture7dad86f2019-05-17 08:52:20 -0700119 if (path == hashBlobId || path == activeHashBlobId)
Patrick Venture9e5aab22018-11-09 20:49:28 -0800120 {
121 /* They're deleting the hash. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700122 toDelete = &activeHashBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800123 }
124 else
125 {
126 /* They're deleting the image. */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700127 toDelete = &activeImageBlobId;
Patrick Venture9e5aab22018-11-09 20:49:28 -0800128 }
129
130 auto it = std::find_if(
131 blobIDs.begin(), blobIDs.end(),
132 [toDelete](const auto& iter) { return (iter == *toDelete); });
133 if (it == blobIDs.end())
134 {
135 /* Somehow they've asked to delete something we didn't say we could
136 * handle.
137 */
138 return false;
139 }
140
141 blobIDs.erase(it);
142
143 /* TODO: Handle aborting the process and fixing up the state. */
144
145 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700146}
Patrick Venture53977962018-11-02 18:59:35 -0700147
Patrick Ventured6461d62018-11-09 17:30:25 -0800148/*
149 * Stat on the files will return information such as what supported
150 * transport mechanisms are available.
151 *
152 * Stat on an active file or hash will return information such as the size
153 * of the data cached, and any additional pertinent information. The
154 * blob_state on the active files will return the state of the update.
155 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700156bool FirmwareBlobHandler::stat(const std::string& path,
157 struct blobs::BlobMeta* meta)
Patrick Venturec7ca2912018-11-02 11:38:33 -0700158{
Patrick Venture46637c82018-11-06 15:20:24 -0800159 /* We know we support this path because canHandle is called ahead */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700160 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800161 {
Patrick Venture699750d2019-05-15 09:24:09 -0700162 /* TODO: We need to return information for the verify state -- did they
163 * call commit() did things start?
Patrick Ventureffcc5502018-11-16 12:32:38 -0800164 */
165 }
Patrick Venture7dad86f2019-05-17 08:52:20 -0700166 else if (path == activeImageBlobId)
Patrick Venture46637c82018-11-06 15:20:24 -0800167 {
Patrick Venture699750d2019-05-15 09:24:09 -0700168 /* TODO: We need to return information for the image that's staged. */
Patrick Venture46637c82018-11-06 15:20:24 -0800169 }
Patrick Venture7dad86f2019-05-17 08:52:20 -0700170 else if (path == activeHashBlobId)
Patrick Venture46637c82018-11-06 15:20:24 -0800171 {
Patrick Venture699750d2019-05-15 09:24:09 -0700172 /* TODO: We need to return information for the hash that's staged. */
Patrick Venture46637c82018-11-06 15:20:24 -0800173 }
174 else
175 {
176 /* They are requesting information about the generic blob_id. */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800177 meta->blobState = bitmask;
Patrick Venture46637c82018-11-06 15:20:24 -0800178 meta->size = 0;
179
180 /* The generic blob_ids state is only the bits related to the transport
Patrick Ventured6461d62018-11-09 17:30:25 -0800181 * mechanisms.
182 */
Patrick Venture46637c82018-11-06 15:20:24 -0800183 return true;
184 }
185
Patrick Venturec7ca2912018-11-02 11:38:33 -0700186 return false;
187}
Patrick Venture53977962018-11-02 18:59:35 -0700188
Patrick Venturec02849b2018-11-06 17:31:15 -0800189/*
Patrick Ventured6461d62018-11-09 17:30:25 -0800190 * Return stat information on an open session. It therefore must be an active
191 * handle to either the active image or active hash.
192 *
193 * The stat() and sessionstat() commands will return the same information in
194 * many cases, therefore the logic will be combined.
195 *
196 * TODO: combine the logic for stat and sessionstat().
197 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700198bool FirmwareBlobHandler::stat(uint16_t session, struct blobs::BlobMeta* meta)
Patrick Ventured6461d62018-11-09 17:30:25 -0800199{
Patrick Venturecc7d1602018-11-15 13:58:33 -0800200 auto item = lookup.find(session);
201 if (item == lookup.end())
202 {
203 return false;
204 }
205
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700206 /* The size here refers to the size of the file -- of something analagous.
207 */
208 meta->size = (item->second->imageHandler)
209 ? item->second->imageHandler->getSize()
210 : 0;
211
212 meta->metadata.clear();
213
Patrick Venture699750d2019-05-15 09:24:09 -0700214 /* TODO: Implement this for the verification blob, which is what we expect.
215 * Calling stat() on the verify blob without an active session should not
216 * provide insight.
217 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700218 if (item->second->activePath == verifyBlobId)
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700219 {
Patrick Venture3ecb3502019-05-17 11:03:51 -0700220 auto value = verification->checkVerificationState();
Patrick Venture699750d2019-05-15 09:24:09 -0700221
Patrick Venturee955e072019-05-15 16:16:46 -0700222 meta->metadata.push_back(static_cast<std::uint8_t>(value));
223
224 /* Change the firmware handler's state and the blob's stat value
225 * depending.
226 */
227 if (value == VerifyCheckResponses::success ||
228 value == VerifyCheckResponses::failed)
229 {
230 state = UpdateState::verificationCompleted;
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700231 item->second->flags &= ~blobs::StateFlags::committing;
Patrick Venturee955e072019-05-15 16:16:46 -0700232
233 if (value == VerifyCheckResponses::success)
234 {
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700235 item->second->flags |= blobs::StateFlags::committed;
Patrick Venturee955e072019-05-15 16:16:46 -0700236 }
237 else
238 {
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700239 item->second->flags |= blobs::StateFlags::commit_error;
Patrick Venturee955e072019-05-15 16:16:46 -0700240 }
241 }
Patrick Ventureb3b4db72019-05-15 11:30:24 -0700242 }
Patrick Venturecc7d1602018-11-15 13:58:33 -0800243
Patrick Venturee955e072019-05-15 16:16:46 -0700244 /* The blobState here relates to an active sesion, so we should return the
245 * flags used to open this session.
246 */
247 meta->blobState = item->second->flags;
248
Patrick Venturecc7d1602018-11-15 13:58:33 -0800249 /* The metadata blob returned comes from the data handler... it's used for
250 * instance, in P2A bridging to get required information about the mapping,
251 * and is the "opposite" of the lpc writemeta requirement.
252 */
Patrick Venturecc7d1602018-11-15 13:58:33 -0800253 if (item->second->dataHandler)
254 {
Patrick Venture74304642019-01-17 09:31:04 -0800255 auto bytes = item->second->dataHandler->readMeta();
Patrick Venturecc7d1602018-11-15 13:58:33 -0800256 meta->metadata.insert(meta->metadata.begin(), bytes.begin(),
257 bytes.end());
258 }
259
Patrick Venturecc7d1602018-11-15 13:58:33 -0800260 return true;
Patrick Ventured6461d62018-11-09 17:30:25 -0800261}
262
263/*
Patrick Venturec02849b2018-11-06 17:31:15 -0800264 * If you open /flash/image or /flash/tarball, or /flash/hash it will
265 * interpret the open flags and perform whatever actions are required for
266 * that update process. The session returned can be used immediately for
267 * sending data down, without requiring one to open the new active file.
268 *
269 * If you open the active flash image or active hash it will let you
270 * overwrite pieces, depending on the state.
271 *
272 * Once the verification process has started the active files cannot be
273 * opened.
274 *
275 * You can only have one open session at a time. Which means, you can only
276 * have one file open at a time. Trying to open the hash blob_id while you
277 * still have the flash image blob_id open will fail. Opening the flash
278 * blob_id when it is already open will fail.
279 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700280bool FirmwareBlobHandler::open(uint16_t session, uint16_t flags,
281 const std::string& path)
282{
Patrick Venture6e307a72018-11-09 18:21:17 -0800283 /* Check that they've opened for writing - read back not currently
284 * supported.
285 */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700286 if ((flags & blobs::OpenFlags::write) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800287 {
288 return false;
289 }
290
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800291 /* Is the verification process underway? */
292 if (state == UpdateState::verificationStarted)
293 {
294 return false;
295 }
Patrick Venturec02849b2018-11-06 17:31:15 -0800296
297 /* Is there an open session already? We only allow one at a time.
Patrick Venture6e307a72018-11-09 18:21:17 -0800298 *
Patrick Venturec02849b2018-11-06 17:31:15 -0800299 * TODO: Temporarily using a simple boolean flag until there's a full
300 * session object to check.
Patrick Venture7c8b97e2018-11-08 09:14:30 -0800301 *
302 * Further on this, if there's an active session to the hash we don't allow
303 * re-opening the image, and if we have the image open, we don't allow
304 * opening the hash. This design decision may be re-evaluated, and changed
305 * to only allow one session per object type (of the two types). But,
306 * consider if the hash is open, do we want to allow writing to the image?
307 * And why would we? But, really, the point of no-return is once the
308 * verification process has begun -- which is done via commit() on the hash
309 * blob_id, we no longer want to allow updating the contents.
Patrick Venture53977962018-11-02 18:59:35 -0700310 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800311 if (fileOpen)
312 {
313 return false;
314 }
315
Patrick Ventureffcc5502018-11-16 12:32:38 -0800316 /* Handle opening the verifyBlobId --> we know the image and hash aren't
317 * open because of the fileOpen check.
318 *
319 * The file must be opened for writing, but no transport mechanism specified
320 * since it's irrelevant.
321 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700322 if (path == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800323 {
324 /* In this case, there's no image handler to use, or data handler,
325 * simply set up a session.
326 */
327 verifyImage.flags = flags;
328 verifyImage.state = Session::State::open;
329
330 lookup[session] = &verifyImage;
331
332 fileOpen = true;
333
334 return true;
335 }
336
Patrick Venturec02849b2018-11-06 17:31:15 -0800337 /* There are two abstractions at play, how you get the data and how you
338 * handle that data. such that, whether the data comes from the PCI bridge
339 * or LPC bridge is not connected to whether the data goes into a static
340 * layout flash update or a UBI tarball.
341 */
342
343 /* Check the flags for the transport mechanism: if none match we don't
Patrick Venture18235e62018-11-08 10:21:09 -0800344 * support what they request.
345 */
Patrick Venture1cde5f92018-11-07 08:26:47 -0800346 if ((flags & bitmask) == 0)
Patrick Venturec02849b2018-11-06 17:31:15 -0800347 {
348 return false;
349 }
350
351 /* 2) there isn't, so what are they opening? */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700352 if (path == activeImageBlobId)
Patrick Venturec02849b2018-11-06 17:31:15 -0800353 {
354 /* 2a) are they opening the active image? this can only happen if they
Patrick Venture18235e62018-11-08 10:21:09 -0800355 * already started one (due to canHandleBlob's behavior).
356 */
Patrick Venture21c62c12018-11-09 17:46:58 -0800357 return false;
Patrick Venturec02849b2018-11-06 17:31:15 -0800358 }
Patrick Venture7dad86f2019-05-17 08:52:20 -0700359 else if (path == activeHashBlobId)
Patrick Venturec02849b2018-11-06 17:31:15 -0800360 {
361 /* 2b) are they opening the active hash? this can only happen if they
Patrick Venture18235e62018-11-08 10:21:09 -0800362 * already started one (due to canHandleBlob's behavior).
363 */
Patrick Venture21c62c12018-11-09 17:46:58 -0800364 return false;
Patrick Venturec02849b2018-11-06 17:31:15 -0800365 }
Patrick Venture18235e62018-11-08 10:21:09 -0800366
367 /* How are they expecting to copy this data? */
368 auto d = std::find_if(
369 transports.begin(), transports.end(),
370 [&flags](const auto& iter) { return (iter.bitmask & flags); });
371 if (d == transports.end())
Patrick Venturec02849b2018-11-06 17:31:15 -0800372 {
Patrick Venture18235e62018-11-08 10:21:09 -0800373 return false;
374 }
375
376 /* We found the transport handler they requested, no surprise since
377 * above we verify they selected at least one we wanted.
378 */
Patrick Venturec02849b2018-11-06 17:31:15 -0800379
Patrick Venture6e307a72018-11-09 18:21:17 -0800380 /* Elsewhere I do this check by checking "if ::ipmi" because that's the
381 * only non-external data pathway -- but this is just a more generic
382 * approach to that.
383 */
384 if (d->handler)
385 {
386 /* If the data handler open call fails, open fails. */
387 if (!d->handler->open())
388 {
389 return false;
390 }
391 }
392
Patrick Venture70e30bf2019-01-17 10:29:28 -0800393 /* Do we have a file handler for the type of file they're opening.
394 * Note: This should only fail if something is somehow crazy wrong.
395 * Since the canHandle() said yes, and that's tied into the list of explicit
396 * firmware handers (and file handlers, like this'll know where to write the
397 * tarball, etc).
Patrick Venture18235e62018-11-08 10:21:09 -0800398 */
Patrick Venture18235e62018-11-08 10:21:09 -0800399 auto h = std::find_if(
400 handlers.begin(), handlers.end(),
401 [&path](const auto& iter) { return (iter.blobName == path); });
402 if (h == handlers.end())
403 {
404 return false;
405 }
406
407 /* Ok, so we found a handler that matched, so call open() */
408 if (!h->handler->open(path))
409 {
410 return false;
411 }
412
Patrick Venture70e30bf2019-01-17 10:29:28 -0800413 Session* curr;
414 const std::string* active;
415
Patrick Venture7dad86f2019-05-17 08:52:20 -0700416 if (path == hashBlobId)
Patrick Venture70e30bf2019-01-17 10:29:28 -0800417 {
418 /* 2c) are they opening the /flash/hash ? (to start the process) */
419 curr = &activeHash;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700420 active = &activeHashBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800421 }
422 else
423 {
424 curr = &activeImage;
Patrick Venture7dad86f2019-05-17 08:52:20 -0700425 active = &activeImageBlobId;
Patrick Venture70e30bf2019-01-17 10:29:28 -0800426 }
427
Patrick Venture18235e62018-11-08 10:21:09 -0800428 curr->flags = flags;
429 curr->dataHandler = d->handler;
430 curr->imageHandler = h->handler;
Patrick Venturecd310222018-11-09 18:47:13 -0800431 curr->state = Session::State::open;
Patrick Venture18235e62018-11-08 10:21:09 -0800432
433 lookup[session] = curr;
434
Patrick Venturedaf47072019-05-10 15:21:55 -0700435 /* This may be them re-opening a blob, so let's only push it onto the list
436 * when appropriate.
437 */
438 auto blobIdMatch =
439 std::find_if(blobIDs.begin(), blobIDs.end(),
440 [active](const auto& iter) { return (iter == *active); });
441 if (blobIdMatch == blobIDs.end())
442 {
443 blobIDs.push_back(*active);
444 }
Patrick Venturedb253bf2018-11-09 19:36:03 -0800445
Patrick Venture12233c52019-05-16 09:26:59 -0700446 state = UpdateState::uploadInProgress;
Patrick Venture991910a2018-11-09 19:43:48 -0800447 fileOpen = true;
448
Patrick Venture18235e62018-11-08 10:21:09 -0800449 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700450}
Patrick Venture53977962018-11-02 18:59:35 -0700451
Patrick Venture18235e62018-11-08 10:21:09 -0800452/**
453 * The write command really just grabs the data from wherever it is and sends it
454 * to the image handler. It's the image handler's responsibility to deal with
455 * the data provided.
Patrick Ventured6461d62018-11-09 17:30:25 -0800456 *
457 * This receives a session from the blob manager, therefore it is always called
458 * between open() and close().
Patrick Venture18235e62018-11-08 10:21:09 -0800459 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700460bool FirmwareBlobHandler::write(uint16_t session, uint32_t offset,
461 const std::vector<uint8_t>& data)
462{
Patrick Venture18235e62018-11-08 10:21:09 -0800463 auto item = lookup.find(session);
464 if (item == lookup.end())
465 {
466 return false;
467 }
468
Patrick Ventureb1b68fc2018-11-09 09:37:04 -0800469 /* Prevent writing during verification. */
470 if (state == UpdateState::verificationStarted)
471 {
472 return false;
473 }
474
Patrick Venture8af15eb2019-05-15 09:39:22 -0700475 /* Prevent writing to the verification blob before they trigger
Patrick Venture699750d2019-05-15 09:24:09 -0700476 * verification.
477 */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700478 if (item->second->activePath == verifyBlobId)
Patrick Venture8af15eb2019-05-15 09:39:22 -0700479 {
480 return false;
481 }
Patrick Venture699750d2019-05-15 09:24:09 -0700482
Patrick Venture18235e62018-11-08 10:21:09 -0800483 std::vector<std::uint8_t> bytes;
484
Patrick Venture05abf7e2018-11-09 11:02:56 -0800485 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture18235e62018-11-08 10:21:09 -0800486 {
487 bytes = data;
488 }
489 else
490 {
491 /* little endian required per design, and so on, but TODO: do endianness
492 * with boost.
493 */
494 struct ExtChunkHdr header;
495
496 if (data.size() != sizeof(header))
497 {
498 return false;
499 }
500
501 std::memcpy(&header, data.data(), data.size());
502 bytes = item->second->dataHandler->copyFrom(header.length);
503 }
504
505 return item->second->imageHandler->write(offset, bytes);
Patrick Venturec7ca2912018-11-02 11:38:33 -0700506}
Patrick Venture18235e62018-11-08 10:21:09 -0800507
Patrick Venture8c535332018-11-08 15:58:00 -0800508/*
509 * If the active session (image or hash) is over LPC, this allows
510 * configuring it. This option is only available before you start
511 * writing data for the given item (image or hash). This will return
512 * false at any other part. -- the lpc handler portion will know to return
513 * false.
514 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700515bool FirmwareBlobHandler::writeMeta(uint16_t session, uint32_t offset,
516 const std::vector<uint8_t>& data)
517{
Patrick Venture8c535332018-11-08 15:58:00 -0800518 auto item = lookup.find(session);
519 if (item == lookup.end())
520 {
521 return false;
522 }
523
Patrick Venture05abf7e2018-11-09 11:02:56 -0800524 if (item->second->flags & UpdateFlags::ipmi)
Patrick Venture8c535332018-11-08 15:58:00 -0800525 {
526 return false;
527 }
528
Patrick Ventured56097a2019-05-15 09:47:55 -0700529 /* Prevent writing meta to the verification blob (it has no data handler).
530 */
531 if (item->second->dataHandler)
532 {
533 return item->second->dataHandler->writeMeta(data);
534 }
Patrick Venture699750d2019-05-15 09:24:09 -0700535
Patrick Ventured56097a2019-05-15 09:47:55 -0700536 return false;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700537}
Patrick Venture8c535332018-11-08 15:58:00 -0800538
Patrick Ventured6461d62018-11-09 17:30:25 -0800539/*
Patrick Venture7dad86f2019-05-17 08:52:20 -0700540 * If this command is called on the session for the verifyBlobId, it'll
Patrick Ventured6461d62018-11-09 17:30:25 -0800541 * trigger a systemd service `verify_image.service` to attempt to verify
Patrick Ventureffcc5502018-11-16 12:32:38 -0800542 * the image.
543 *
544 * For this file to have opened, the other two must be closed, which means any
545 * out-of-band transport mechanism involved is closed.
Patrick Ventured6461d62018-11-09 17:30:25 -0800546 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700547bool FirmwareBlobHandler::commit(uint16_t session,
548 const std::vector<uint8_t>& data)
549{
Patrick Ventureffcc5502018-11-16 12:32:38 -0800550 auto item = lookup.find(session);
551 if (item == lookup.end())
552 {
553 return false;
554 }
555
556 /* You can only commit on the verifyBlodId */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700557 if (item->second->activePath != verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800558 {
559 return false;
560 }
561
Patrick Venturebe198702019-05-15 09:46:02 -0700562 /* Calling repeatedly has no effect within an update process. */
Patrick Ventureffcc5502018-11-16 12:32:38 -0800563 if (state == UpdateState::verificationStarted)
564 {
Patrick Venturebe198702019-05-15 09:46:02 -0700565 return true;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800566 }
567
568 /* Set state to committing. */
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700569 item->second->flags |= blobs::StateFlags::committing;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800570
571 return triggerVerification();
Patrick Venturec7ca2912018-11-02 11:38:33 -0700572}
Patrick Ventured6461d62018-11-09 17:30:25 -0800573
574/*
575 * Close must be called on the firmware image before triggering
576 * verification via commit. Once the verification is complete, you can
577 * then close the hash file.
578 *
579 * If the `verify_image.service` returned success, closing the hash file
580 * will have a specific behavior depending on the update. If it's UBI,
581 * it'll perform the install. If it's static layout, it'll do nothing. The
582 * verify_image service in the static layout case is responsible for placing
583 * the file in the correct staging position.
584 */
Patrick Venturec7ca2912018-11-02 11:38:33 -0700585bool FirmwareBlobHandler::close(uint16_t session)
586{
Patrick Venture68bb1432018-11-09 20:08:48 -0800587 auto item = lookup.find(session);
588 if (item == lookup.end())
589 {
590 return false;
591 }
592
Patrick Ventureffcc5502018-11-16 12:32:38 -0800593 /* Are you closing the verify blob? */
Patrick Venture7dad86f2019-05-17 08:52:20 -0700594 if (item->second->activePath == verifyBlobId)
Patrick Ventureffcc5502018-11-16 12:32:38 -0800595 {
Patrick Ventureffcc5502018-11-16 12:32:38 -0800596 if (state == UpdateState::verificationStarted)
597 {
Patrick Venture12233c52019-05-16 09:26:59 -0700598 /* TODO: If they close this blob before verification finishes,
599 * that's an abort.
600 */
Patrick Ventureffcc5502018-11-16 12:32:38 -0800601 return false;
602 }
Patrick Venture12233c52019-05-16 09:26:59 -0700603 else if (state == UpdateState::verificationCompleted)
604 {
605 /* TODO: Should this delete the verification artifact? */
606 state = UpdateState::notYetStarted;
607
608 /* A this point, delete the active blob IDs from the blob_list. */
609 blobIDs.erase(
Patrick Venture7dad86f2019-05-17 08:52:20 -0700610 std::remove(blobIDs.begin(), blobIDs.end(), activeImageBlobId));
Patrick Venture12233c52019-05-16 09:26:59 -0700611 blobIDs.erase(
Patrick Venture7dad86f2019-05-17 08:52:20 -0700612 std::remove(blobIDs.begin(), blobIDs.end(), activeHashBlobId));
Patrick Venture12233c52019-05-16 09:26:59 -0700613 }
614 /* Must be verificationPending... not yet started, they may re-open and
615 * trigger verification.
616 */
617 }
618 else
619 {
620 /* They are closing a data pathway (image, tarball, hash). */
621 state = UpdateState::verificationPending;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800622 }
623
Patrick Venture68bb1432018-11-09 20:08:48 -0800624 if (item->second->dataHandler)
625 {
626 item->second->dataHandler->close();
627 }
Patrick Ventureffcc5502018-11-16 12:32:38 -0800628 if (item->second->imageHandler)
629 {
630 item->second->imageHandler->close();
631 }
632
Patrick Venture68bb1432018-11-09 20:08:48 -0800633 item->second->state = Session::State::closed;
634 /* Do not delete the active blob_id from the list of blob_ids, because that
635 * blob_id indicates there is data stored. Delete will destroy it.
636 */
637
638 lookup.erase(item);
639
Patrick Venture991910a2018-11-09 19:43:48 -0800640 fileOpen = false;
641
Patrick Venture68bb1432018-11-09 20:08:48 -0800642 return true;
Patrick Venturec7ca2912018-11-02 11:38:33 -0700643}
Patrick Ventured6461d62018-11-09 17:30:25 -0800644
Patrick Venturec7ca2912018-11-02 11:38:33 -0700645bool FirmwareBlobHandler::expire(uint16_t session)
646{
647 return false;
648}
Patrick Ventured6461d62018-11-09 17:30:25 -0800649
650/*
651 * Currently, the design does not provide this with a function, however,
652 * it will likely change to support reading data back.
653 */
654std::vector<uint8_t> FirmwareBlobHandler::read(uint16_t session,
655 uint32_t offset,
656 uint32_t requestedSize)
657{
658 return {};
659}
660
Patrick Ventureffcc5502018-11-16 12:32:38 -0800661bool FirmwareBlobHandler::triggerVerification()
662{
Patrick Venture3ecb3502019-05-17 11:03:51 -0700663 bool result = verification->triggerVerification();
664 if (result)
Patrick Venturecabc1172018-11-16 16:14:26 -0800665 {
Patrick Venture453f06a2019-01-17 10:02:12 -0800666 state = UpdateState::verificationStarted;
Patrick Venturecabc1172018-11-16 16:14:26 -0800667 }
Patrick Venturecabc1172018-11-16 16:14:26 -0800668
Patrick Venture3ecb3502019-05-17 11:03:51 -0700669 return result;
Patrick Ventureffcc5502018-11-16 12:32:38 -0800670}
671
Patrick Venture1d5a31c2019-05-20 11:38:22 -0700672} // namespace ipmi_flash