1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
#pragma once
#include <memory>
#include <numeric>
#include <vector>
namespace message
{
enum class PayloadType : uint8_t
{
IPMI = 0x00,
SOL = 0x01,
OPEN_SESSION_REQUEST = 0x10,
OPEN_SESSION_RESPONSE = 0x11,
RAKP1 = 0x12,
RAKP2 = 0x13,
RAKP3 = 0x14,
RAKP4 = 0x15,
INVALID = 0xFF,
};
namespace LAN
{
constexpr uint8_t requesterBMCAddress = 0x20;
constexpr uint8_t responderBMCAddress = 0x81;
namespace header
{
/**
* @struct IPMI LAN Message Request Header
*/
struct Request
{
uint8_t rsaddr;
uint8_t netfn;
uint8_t cs;
uint8_t rqaddr;
uint8_t rqseq;
uint8_t cmd;
} __attribute__((packed));
/**
* @struct IPMI LAN Message Response Header
*/
struct Response
{
uint8_t rqaddr;
uint8_t netfn;
uint8_t cs;
uint8_t rsaddr;
uint8_t rqseq;
uint8_t cmd;
} __attribute__((packed));
} // namespace header
namespace trailer
{
/**
* @struct IPMI LAN Message Trailer
*/
struct Request
{
uint8_t checksum;
} __attribute__((packed));
using Response = Request;
} // namespace trailer
} // namespace LAN
/**
* @brief Calculate 8 bit 2's complement checksum
*
* Initialize checksum to 0. For each byte, checksum = (checksum + byte)
* modulo 256. Then checksum = - checksum. When the checksum and the
* bytes are added together, modulo 256, the result should be 0.
*/
static inline uint8_t crc8bit(const uint8_t* ptr, const size_t len)
{
return (0x100 - std::accumulate(ptr, ptr + len, 0));
}
/**
* @struct Message
*
* IPMI message is data encapsulated in an IPMI Session packet. The IPMI
* Session packets are encapsulated in RMCP packets, which are encapsulated in
* UDP datagrams. Refer Section 13.5 of IPMI specification(IPMI Messages
* Encapsulation Under RMCP). IPMI payload is a special class of data
* encapsulated in an IPMI session packet.
*/
struct Message
{
static constexpr uint32_t MESSAGE_INVALID_SESSION_ID = 0xBADBADFF;
Message() :
payloadType(PayloadType::INVALID),
rcSessionID(Message::MESSAGE_INVALID_SESSION_ID),
bmcSessionID(Message::MESSAGE_INVALID_SESSION_ID)
{
}
/**
* @brief Special behavior for copy constructor
*
* Based on incoming message state, the resulting message will have a
* pre-baked state. This is used to simplify the flows for creating a
* response message. For each pre-session state, the response message is
* actually a different type of message. Once the session has been
* established, the response type is the same as the request type.
*/
Message(const Message& other) :
isPacketEncrypted(other.isPacketEncrypted),
isPacketAuthenticated(other.isPacketAuthenticated),
payloadType(other.payloadType), rcSessionID(other.rcSessionID),
bmcSessionID(other.bmcSessionID)
{
// special behavior for rmcp+ session creation
if (PayloadType::OPEN_SESSION_REQUEST == other.payloadType)
{
payloadType = PayloadType::OPEN_SESSION_RESPONSE;
}
else if (PayloadType::RAKP1 == other.payloadType)
{
payloadType = PayloadType::RAKP2;
}
else if (PayloadType::RAKP3 == other.payloadType)
{
payloadType = PayloadType::RAKP4;
}
}
Message& operator=(const Message&) = default;
Message(Message&&) = default;
Message& operator=(Message&&) = default;
~Message() = default;
/**
* @brief Extract the command from the IPMI payload
*
* @return Command ID in the incoming message
*/
uint32_t getCommand()
{
uint32_t command = 0;
command |= (static_cast<uint8_t>(payloadType) << 16);
if (payloadType == PayloadType::IPMI)
{
auto request =
reinterpret_cast<LAN::header::Request*>(payload.data());
command |= request->netfn << 8;
command |= request->cmd;
}
return command;
}
/**
* @brief Create the response IPMI message
*
* The IPMI outgoing message is constructed out of payload and the
* corresponding fields are populated. For the payload type IPMI, the
* LAN message header and trailer are added.
*
* @param[in] output - Payload for outgoing message
*
* @return Outgoing message on success and nullptr on failure
*/
std::shared_ptr<Message> createResponse(std::vector<uint8_t>& output)
{
// SOL packets don't reply; return NULL
if (payloadType == PayloadType::SOL)
{
return nullptr;
}
auto outMessage = std::make_shared<Message>(*this);
if (payloadType == PayloadType::IPMI)
{
outMessage->payloadType = PayloadType::IPMI;
outMessage->payload.resize(sizeof(LAN::header::Response) +
output.size() +
sizeof(LAN::trailer::Response));
auto reqHeader =
reinterpret_cast<LAN::header::Request*>(payload.data());
auto respHeader = reinterpret_cast<LAN::header::Response*>(
outMessage->payload.data());
// Add IPMI LAN Message Response Header
respHeader->rqaddr = reqHeader->rqaddr;
respHeader->netfn = reqHeader->netfn | 0x04;
respHeader->cs = crc8bit(&(respHeader->rqaddr), 2);
respHeader->rsaddr = reqHeader->rsaddr;
respHeader->rqseq = reqHeader->rqseq;
respHeader->cmd = reqHeader->cmd;
auto assembledSize = sizeof(LAN::header::Response);
// Copy the output by the execution of the command
std::copy(output.begin(), output.end(),
outMessage->payload.begin() + assembledSize);
assembledSize += output.size();
// Add the IPMI LAN Message Trailer
auto trailer = reinterpret_cast<LAN::trailer::Response*>(
outMessage->payload.data() + assembledSize);
trailer->checksum = crc8bit(&respHeader->rsaddr, assembledSize - 3);
}
else
{
outMessage->payload = output;
}
return outMessage;
}
bool isPacketEncrypted; // Message's Encryption Status
bool isPacketAuthenticated; // Message's Authentication Status
PayloadType payloadType; // Type of message payload (IPMI,SOL ..etc)
uint32_t rcSessionID; // Remote Client's Session ID
uint32_t bmcSessionID; // BMC's session ID
uint32_t sessionSeqNum; // Session Sequence Number
/** @brief Message payload
*
* “Payloads” are a capability specified for RMCP+ that enable an IPMI
* session to carry types of traffic that are in addition to IPMI Messages.
* Payloads can be ‘standard’ or ‘OEM’.Standard payload types include IPMI
* Messages, messages for session setup under RMCP+, and the payload for
* the “Serial Over LAN” capability introduced in IPMI v2.0.
*/
std::vector<uint8_t> payload;
};
} // namespace message
|
