blob: 2481fa278a980788f30b2e16a6eb87d29de1e575 [file] [log] [blame]
Patrick Ventureef3aead2018-09-12 08:53:29 -07001/*
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
17#include "process.hpp"
18
19#include "ipmi.hpp"
20
21#include <cstring>
Patrick Venturede8a16e2019-03-07 12:48:32 -080022#include <ipmiblob/crc.hpp>
Patrick Ventureb15b3052018-10-04 10:31:53 -070023#include <unordered_map>
Patrick Ventureef3aead2018-09-12 08:53:29 -070024#include <vector>
25
26namespace blobs
27{
28
29/* Used by all commands with data. */
30struct BmcRx
31{
32 uint8_t cmd;
33 uint16_t crc;
34 uint8_t data; /* one byte minimum of data. */
35} __attribute__((packed));
36
Patrick Ventureb15b3052018-10-04 10:31:53 -070037static const std::unordered_map<BlobOEMCommands, IpmiBlobHandler> handlers = {
38 {BlobOEMCommands::bmcBlobGetCount, getBlobCount},
39 {BlobOEMCommands::bmcBlobEnumerate, enumerateBlob},
40 {BlobOEMCommands::bmcBlobOpen, openBlob},
41 {BlobOEMCommands::bmcBlobRead, readBlob},
42 {BlobOEMCommands::bmcBlobWrite, writeBlob},
43 {BlobOEMCommands::bmcBlobCommit, commitBlob},
44 {BlobOEMCommands::bmcBlobClose, closeBlob},
45 {BlobOEMCommands::bmcBlobDelete, deleteBlob},
46 {BlobOEMCommands::bmcBlobStat, statBlob},
47 {BlobOEMCommands::bmcBlobSessionStat, sessionStatBlob},
Patrick Venture5c4b17b2018-10-04 10:32:22 -070048 {BlobOEMCommands::bmcBlobWriteMeta, writeMeta},
Patrick Ventureb15b3052018-10-04 10:31:53 -070049};
50
William A. Kennington III993f5412021-06-15 18:19:18 -070051IpmiBlobHandler validateBlobCommand(const uint8_t* reqBuf,
52 uint8_t* /*replyCmdBuf*/, size_t* dataLen,
53 ipmi_ret_t* code)
Patrick Ventureef3aead2018-09-12 08:53:29 -070054{
Patrick Ventureef3aead2018-09-12 08:53:29 -070055 size_t requestLength = (*dataLen);
56 /* We know dataLen is at least 1 already */
57 auto command = static_cast<BlobOEMCommands>(reqBuf[0]);
58
59 /* Validate it's at least well-formed. */
60 if (!validateRequestLength(command, requestLength))
61 {
Patrick Venture41258802018-11-12 10:46:30 -080062 *code = IPMI_CC_REQ_DATA_LEN_INVALID;
Patrick Ventureef3aead2018-09-12 08:53:29 -070063 return nullptr;
64 }
65
66 /* If there is a payload. */
67 if (requestLength > sizeof(uint8_t))
68 {
69 /* Verify the request includes: command, crc16, data */
70 if (requestLength < sizeof(struct BmcRx))
71 {
Patrick Venture41258802018-11-12 10:46:30 -080072 *code = IPMI_CC_REQ_DATA_LEN_INVALID;
Patrick Ventureef3aead2018-09-12 08:53:29 -070073 return nullptr;
74 }
75
76 /* We don't include the command byte at offset 0 as part of the crc
77 * payload area or the crc bytes at the beginning.
78 */
79 size_t requestBodyLen = requestLength - 3;
80
81 /* We start after the command byte. */
82 std::vector<uint8_t> bytes(requestBodyLen);
83
84 /* It likely has a well-formed payload. */
85 struct BmcRx request;
86 std::memcpy(&request, reqBuf, sizeof(request));
87 uint16_t crcValue = request.crc;
88
89 /* Set the in-place CRC to zero. */
90 std::memcpy(bytes.data(), &reqBuf[3], requestBodyLen);
91
Patrick Ventureef3aead2018-09-12 08:53:29 -070092 /* Crc expected but didn't match. */
Patrick Venturede8a16e2019-03-07 12:48:32 -080093 if (crcValue != ipmiblob::generateCrc(bytes))
Patrick Ventureef3aead2018-09-12 08:53:29 -070094 {
Patrick Venture41258802018-11-12 10:46:30 -080095 *code = IPMI_CC_UNSPECIFIED_ERROR;
Patrick Ventureef3aead2018-09-12 08:53:29 -070096 return nullptr;
97 }
98 }
99
Patrick Ventureb15b3052018-10-04 10:31:53 -0700100 /* Grab the corresponding handler for the command. */
101 auto found = handlers.find(command);
102 if (found == handlers.end())
Patrick Ventureef3aead2018-09-12 08:53:29 -0700103 {
Patrick Venture41258802018-11-12 10:46:30 -0800104 *code = IPMI_CC_INVALID_FIELD_REQUEST;
Patrick Ventureb15b3052018-10-04 10:31:53 -0700105 return nullptr;
Patrick Ventureef3aead2018-09-12 08:53:29 -0700106 }
107
Patrick Ventureb15b3052018-10-04 10:31:53 -0700108 return found->second;
Patrick Ventureef3aead2018-09-12 08:53:29 -0700109}
110
111ipmi_ret_t processBlobCommand(IpmiBlobHandler cmd, ManagerInterface* mgr,
Patrick Venturede8a16e2019-03-07 12:48:32 -0800112 const uint8_t* reqBuf, uint8_t* replyCmdBuf,
Willy Tud92aee42022-06-28 04:18:59 +0000113 size_t* dataLen)
Patrick Ventureef3aead2018-09-12 08:53:29 -0700114{
115 ipmi_ret_t result = cmd(mgr, reqBuf, replyCmdBuf, dataLen);
116 if (result != IPMI_CC_OK)
117 {
118 return result;
119 }
120
121 size_t replyLength = (*dataLen);
122
123 /* The command, whatever it was, returned success. */
124 if (replyLength == 0)
125 {
126 return result;
127 }
128
Patrick Ventured1c3e862019-01-10 13:12:20 -0800129 /* Read can return 0 bytes, and just a CRC, otherwise you need a CRC and 1
130 * byte, therefore the limit is 2 bytes.
131 */
132 if (replyLength < (sizeof(uint16_t)))
Patrick Ventureef3aead2018-09-12 08:53:29 -0700133 {
Patrick Venture41258802018-11-12 10:46:30 -0800134 return IPMI_CC_UNSPECIFIED_ERROR;
Patrick Ventureef3aead2018-09-12 08:53:29 -0700135 }
136
137 /* The command, whatever it was, replied, so let's set the CRC. */
Patrick Venturede8a16e2019-03-07 12:48:32 -0800138 std::vector<std::uint8_t> crcBuffer(replyCmdBuf + sizeof(uint16_t),
139 replyCmdBuf + replyLength);
Patrick Ventureef3aead2018-09-12 08:53:29 -0700140 /* Copy the CRC into place. */
Patrick Venturede8a16e2019-03-07 12:48:32 -0800141 uint16_t crcValue = ipmiblob::generateCrc(crcBuffer);
Patrick Ventureef3aead2018-09-12 08:53:29 -0700142 std::memcpy(replyCmdBuf, &crcValue, sizeof(crcValue));
143
144 return result;
145}
Patrick Venture03fd5b82020-05-07 14:51:42 -0700146
Willy Tud92aee42022-06-28 04:18:59 +0000147ipmi_ret_t handleBlobCommand(ipmi_cmd_t, const uint8_t* reqBuf,
Patrick Venture03fd5b82020-05-07 14:51:42 -0700148 uint8_t* replyCmdBuf, size_t* dataLen)
149{
150 /* It's holding at least a sub-command. The OEN is trimmed from the bytes
151 * before this is called.
152 */
153 if ((*dataLen) < 1)
154 {
155 return IPMI_CC_REQ_DATA_LEN_INVALID;
156 }
157
158 /* on failure rc is set to the corresponding IPMI error. */
159 ipmi_ret_t rc = IPMI_CC_OK;
160 IpmiBlobHandler command =
161 validateBlobCommand(reqBuf, replyCmdBuf, dataLen, &rc);
162 if (command == nullptr)
163 {
164 (*dataLen) = 0;
165 return rc;
166 }
167
168 return processBlobCommand(command, getBlobManager(), reqBuf, replyCmdBuf,
Willy Tud92aee42022-06-28 04:18:59 +0000169 dataLen);
Patrick Venture03fd5b82020-05-07 14:51:42 -0700170}
171
Patrick Ventureef3aead2018-09-12 08:53:29 -0700172} // namespace blobs