Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 1 | #include "message_handler.hpp" |
| 2 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 3 | #include "command_table.hpp" |
| 4 | #include "main.hpp" |
| 5 | #include "message.hpp" |
| 6 | #include "message_parsers.hpp" |
| 7 | #include "sessions_manager.hpp" |
| 8 | |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 9 | #include <sys/socket.h> |
| 10 | |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 11 | #include <memory> |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 12 | #include <phosphor-logging/log.hpp> |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 13 | #include <string> |
| 14 | #include <vector> |
| 15 | |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 16 | using namespace phosphor::logging; |
| 17 | |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 18 | namespace message |
| 19 | { |
| 20 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 21 | std::shared_ptr<Message> Handler::receive() |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 22 | { |
| 23 | std::vector<uint8_t> packet; |
| 24 | auto readStatus = 0; |
| 25 | |
| 26 | // Read the packet |
| 27 | std::tie(readStatus, packet) = channel->read(); |
| 28 | |
| 29 | // Read of the packet failed |
| 30 | if (readStatus < 0) |
| 31 | { |
Vernon Mauery | fc37e59 | 2018-12-19 14:55:15 -0800 | [diff] [blame] | 32 | log<level::ERR>("Error in Read", entry("STATUS=%x", readStatus)); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 33 | return nullptr; |
| 34 | } |
| 35 | |
| 36 | // Unflatten the packet |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 37 | std::shared_ptr<Message> message; |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 38 | std::tie(message, sessionHeader) = parser::unflatten(packet); |
| 39 | |
Vernon Mauery | ae1fda4 | 2018-10-15 12:55:34 -0700 | [diff] [blame] | 40 | auto session = std::get<session::Manager&>(singletonPool) |
| 41 | .getSession(message->bmcSessionID); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 42 | |
| 43 | sessionID = message->bmcSessionID; |
| 44 | message->rcSessionID = session->getRCSessionID(); |
| 45 | session->updateLastTransactionTime(); |
| 46 | |
| 47 | return message; |
| 48 | } |
| 49 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 50 | template <> |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 51 | std::shared_ptr<Message> Handler::createResponse<PayloadType::IPMI>( |
| 52 | std::vector<uint8_t>& output, std::shared_ptr<Message> inMessage) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 53 | { |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 54 | auto outMessage = std::make_shared<Message>(); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 55 | outMessage->payloadType = PayloadType::IPMI; |
| 56 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 57 | outMessage->payload.resize(sizeof(LAN::header::Response) + output.size() + |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 58 | sizeof(LAN::trailer::Response)); |
| 59 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 60 | auto reqHeader = |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 61 | reinterpret_cast<LAN::header::Request*>(inMessage->payload.data()); |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 62 | auto respHeader = |
| 63 | reinterpret_cast<LAN::header::Response*>(outMessage->payload.data()); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 64 | |
| 65 | // Add IPMI LAN Message Response Header |
| 66 | respHeader->rqaddr = reqHeader->rqaddr; |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 67 | respHeader->netfn = reqHeader->netfn | 0x04; |
| 68 | respHeader->cs = crc8bit(&(respHeader->rqaddr), 2); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 69 | respHeader->rsaddr = reqHeader->rsaddr; |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 70 | respHeader->rqseq = reqHeader->rqseq; |
| 71 | respHeader->cmd = reqHeader->cmd; |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 72 | |
| 73 | auto assembledSize = sizeof(LAN::header::Response); |
| 74 | |
| 75 | // Copy the output by the execution of the command |
| 76 | std::copy(output.begin(), output.end(), |
| 77 | outMessage->payload.begin() + assembledSize); |
| 78 | assembledSize += output.size(); |
| 79 | |
| 80 | // Add the IPMI LAN Message Trailer |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 81 | auto trailer = reinterpret_cast<LAN::trailer::Response*>( |
| 82 | outMessage->payload.data() + assembledSize); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 83 | trailer->checksum = crc8bit(&respHeader->rsaddr, assembledSize - 3); |
| 84 | |
| 85 | return outMessage; |
| 86 | } |
| 87 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 88 | std::shared_ptr<Message> |
| 89 | Handler::executeCommand(std::shared_ptr<Message> inMessage) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 90 | { |
| 91 | // Get the CommandID to map into the command table |
| 92 | auto command = getCommand(inMessage); |
| 93 | std::vector<uint8_t> output{}; |
| 94 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 95 | if (inMessage->payloadType == PayloadType::IPMI) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 96 | { |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 97 | if (inMessage->payload.size() < |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 98 | (sizeof(LAN::header::Request) + sizeof(LAN::trailer::Request))) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 99 | { |
| 100 | return nullptr; |
| 101 | } |
| 102 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 103 | auto start = inMessage->payload.begin() + sizeof(LAN::header::Request); |
| 104 | auto end = inMessage->payload.end() - sizeof(LAN::trailer::Request); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 105 | std::vector<uint8_t> inPayload(start, end); |
| 106 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 107 | output = std::get<command::Table&>(singletonPool) |
| 108 | .executeCommand(command, inPayload, *this); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 109 | } |
| 110 | else |
| 111 | { |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 112 | output = std::get<command::Table&>(singletonPool) |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 113 | .executeCommand(command, inMessage->payload, *this); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 114 | } |
| 115 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 116 | std::shared_ptr<Message> outMessage = nullptr; |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 117 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 118 | switch (inMessage->payloadType) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 119 | { |
| 120 | case PayloadType::IPMI: |
| 121 | outMessage = createResponse<PayloadType::IPMI>(output, inMessage); |
| 122 | break; |
| 123 | case PayloadType::OPEN_SESSION_REQUEST: |
| 124 | outMessage = createResponse<PayloadType::OPEN_SESSION_RESPONSE>( |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 125 | output, inMessage); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 126 | break; |
| 127 | case PayloadType::RAKP1: |
| 128 | outMessage = createResponse<PayloadType::RAKP2>(output, inMessage); |
| 129 | break; |
| 130 | case PayloadType::RAKP3: |
| 131 | outMessage = createResponse<PayloadType::RAKP4>(output, inMessage); |
| 132 | break; |
Tom Joseph | 703adbf | 2017-03-31 10:50:22 +0530 | [diff] [blame] | 133 | case PayloadType::SOL: |
| 134 | return outMessage; |
| 135 | break; |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 136 | default: |
| 137 | break; |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 138 | } |
| 139 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 140 | outMessage->isPacketEncrypted = inMessage->isPacketEncrypted; |
| 141 | outMessage->isPacketAuthenticated = inMessage->isPacketAuthenticated; |
| 142 | outMessage->rcSessionID = inMessage->rcSessionID; |
| 143 | outMessage->bmcSessionID = inMessage->bmcSessionID; |
Tom Joseph | 8dfa0f0 | 2017-01-10 15:38:20 +0530 | [diff] [blame] | 144 | |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 145 | return outMessage; |
| 146 | } |
| 147 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 148 | uint32_t Handler::getCommand(std::shared_ptr<Message> message) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 149 | { |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 150 | uint32_t command = 0; |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 151 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 152 | command |= (static_cast<uint8_t>(message->payloadType) << 16); |
| 153 | if (message->payloadType == PayloadType::IPMI) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 154 | { |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 155 | command |= |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 156 | ((reinterpret_cast<LAN::header::Request*>(message->payload.data())) |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 157 | ->netfn) |
| 158 | << 8; |
| 159 | command |= |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 160 | (reinterpret_cast<LAN::header::Request*>(message->payload.data())) |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 161 | ->cmd; |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | return command; |
| 165 | } |
| 166 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 167 | void Handler::send(std::shared_ptr<Message> outMessage) |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 168 | { |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 169 | auto session = |
Vernon Mauery | ae1fda4 | 2018-10-15 12:55:34 -0700 | [diff] [blame] | 170 | std::get<session::Manager&>(singletonPool).getSession(sessionID); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 171 | |
| 172 | // Flatten the packet |
Vernon Mauery | 224f36a | 2018-10-25 08:52:23 -0700 | [diff] [blame] | 173 | auto packet = parser::flatten(outMessage, sessionHeader, session); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 174 | |
Tom Joseph | 04b3038 | 2017-04-03 01:06:51 +0530 | [diff] [blame] | 175 | // Write the packet |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 176 | auto writeStatus = channel->write(packet); |
| 177 | if (writeStatus < 0) |
| 178 | { |
Tom Joseph | 04b3038 | 2017-04-03 01:06:51 +0530 | [diff] [blame] | 179 | throw std::runtime_error("Error in writing to socket"); |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 180 | } |
Tom Joseph | e6361a2 | 2016-08-10 06:56:25 -0500 | [diff] [blame] | 181 | } |
| 182 | |
Tom Joseph | ff84849 | 2017-03-31 10:43:48 +0530 | [diff] [blame] | 183 | void Handler::setChannelInSession() const |
| 184 | { |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 185 | auto session = |
Vernon Mauery | ae1fda4 | 2018-10-15 12:55:34 -0700 | [diff] [blame] | 186 | std::get<session::Manager&>(singletonPool).getSession(sessionID); |
Tom Joseph | ff84849 | 2017-03-31 10:43:48 +0530 | [diff] [blame] | 187 | |
| 188 | session->channelPtr = channel; |
| 189 | } |
| 190 | |
Vernon Mauery | 70fd29c | 2017-11-30 13:11:43 -0800 | [diff] [blame] | 191 | void Handler::sendSOLPayload(const std::vector<uint8_t>& input) |
Tom Joseph | 22596f2 | 2017-03-31 10:52:27 +0530 | [diff] [blame] | 192 | { |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 193 | auto session = |
Vernon Mauery | ae1fda4 | 2018-10-15 12:55:34 -0700 | [diff] [blame] | 194 | std::get<session::Manager&>(singletonPool).getSession(sessionID); |
Tom Joseph | 22596f2 | 2017-03-31 10:52:27 +0530 | [diff] [blame] | 195 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 196 | auto outMessage = std::make_shared<Message>(); |
| 197 | outMessage->payloadType = PayloadType::SOL; |
| 198 | outMessage->payload = input; |
| 199 | outMessage->isPacketEncrypted = session->isCryptAlgoEnabled(); |
| 200 | outMessage->isPacketAuthenticated = session->isIntegrityAlgoEnabled(); |
| 201 | outMessage->rcSessionID = session->getRCSessionID(); |
| 202 | outMessage->bmcSessionID = sessionID; |
Tom Joseph | 22596f2 | 2017-03-31 10:52:27 +0530 | [diff] [blame] | 203 | |
| 204 | send(outMessage); |
| 205 | } |
| 206 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 207 | void Handler::sendUnsolicitedIPMIPayload(uint8_t netfn, uint8_t cmd, |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 208 | const std::vector<uint8_t>& output) |
| 209 | { |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 210 | auto session = |
Vernon Mauery | ae1fda4 | 2018-10-15 12:55:34 -0700 | [diff] [blame] | 211 | std::get<session::Manager&>(singletonPool).getSession(sessionID); |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 212 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 213 | auto outMessage = std::make_shared<Message>(); |
| 214 | outMessage->payloadType = PayloadType::IPMI; |
| 215 | outMessage->isPacketEncrypted = session->isCryptAlgoEnabled(); |
| 216 | outMessage->isPacketAuthenticated = session->isIntegrityAlgoEnabled(); |
| 217 | outMessage->rcSessionID = session->getRCSessionID(); |
| 218 | outMessage->bmcSessionID = sessionID; |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 219 | |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 220 | outMessage->payload.resize(sizeof(LAN::header::Request) + output.size() + |
| 221 | sizeof(LAN::trailer::Request)); |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 222 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 223 | auto respHeader = |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 224 | reinterpret_cast<LAN::header::Request*>(outMessage->payload.data()); |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 225 | |
| 226 | // Add IPMI LAN Message Request Header |
| 227 | respHeader->rsaddr = LAN::requesterBMCAddress; |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 228 | respHeader->netfn = (netfn << 0x02); |
| 229 | respHeader->cs = crc8bit(&(respHeader->rsaddr), 2); |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 230 | respHeader->rqaddr = LAN::responderBMCAddress; |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 231 | respHeader->rqseq = 0; |
| 232 | respHeader->cmd = cmd; |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 233 | |
| 234 | auto assembledSize = sizeof(LAN::header::Request); |
| 235 | |
| 236 | // Copy the output by the execution of the command |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 237 | std::copy(output.begin(), output.end(), |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 238 | outMessage->payload.begin() + assembledSize); |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 239 | assembledSize += output.size(); |
| 240 | |
| 241 | // Add the IPMI LAN Message Trailer |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 242 | auto trailer = reinterpret_cast<LAN::trailer::Request*>( |
Vernon Mauery | d999ffc | 2018-10-25 09:16:05 -0700 | [diff] [blame] | 243 | outMessage->payload.data() + assembledSize); |
Tom Joseph | 63d3e49 | 2017-03-31 11:01:08 +0530 | [diff] [blame] | 244 | |
| 245 | // Calculate the checksum for the field rqaddr in the header to the |
| 246 | // command data, 3 corresponds to size of the fields before rqaddr( rsaddr, |
| 247 | // netfn, cs). |
| 248 | trailer->checksum = crc8bit(&respHeader->rqaddr, assembledSize - 3); |
| 249 | |
| 250 | send(outMessage); |
| 251 | } |
| 252 | |
Vernon Mauery | 9e801a2 | 2018-10-12 13:20:49 -0700 | [diff] [blame] | 253 | } // namespace message |