1 /*
2 // Copyright (c) 2018 Intel Corporation
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 #pragma once
17 #include <openssl/crypto.h>
18
19 #include <ipmid/api.hpp>
20
21 #include <array>
22 #include <string>
23
24 namespace ipmi
25 {
26
27 static constexpr uint8_t maxIpmiChannels = 16;
28 static constexpr uint8_t currentChNum = 0xE;
29 static constexpr uint8_t invalidChannel = 0xff;
30 static constexpr const uint8_t ccActionNotSupportedForChannel = 0x82;
31 static constexpr const uint8_t ccAccessModeNotSupportedForChannel = 0x83;
32
33 /**
34 * @array of privilege levels
35 */
36 extern const std::array<std::string, PRIVILEGE_OEM + 1> privList;
37
38 /**
39 * @enum Channel Protocol Type (refer spec sec 6.4)
40 */
41 enum class EChannelProtocolType : uint8_t
42 {
43 na = 0x00,
44 ipmbV10 = 0x01,
45 icmbV11 = 0x02,
46 reserved = 0x03,
47 ipmiSmbus = 0x04,
48 kcs = 0x05,
49 smic = 0x06,
50 bt10 = 0x07,
51 bt15 = 0x08,
52 tMode = 0x09,
53 oem = 0x1C,
54 };
55
56 /**
57 * @enum Channel Medium Type (refer spec sec 6.5)
58 */
59 enum class EChannelMediumType : uint8_t
60 {
61 reserved = 0x00,
62 ipmb = 0x01,
63 icmbV10 = 0x02,
64 icmbV09 = 0x03,
65 lan8032 = 0x04,
66 serial = 0x05,
67 otherLan = 0x06,
68 pciSmbus = 0x07,
69 smbusV11 = 0x08,
70 smbusV20 = 0x09,
71 usbV1x = 0x0A,
72 usbV2x = 0x0B,
73 systemInterface = 0x0C,
74 oem = 0x60,
75 unknown = 0x82,
76 };
77
78 /**
79 * @enum Channel Session Type (refer spec sec 22.24 -
80 * response data byte 5)
81 */
82 enum class EChannelSessSupported : uint8_t
83 {
84 none = 0,
85 single = 1,
86 multi = 2,
87 any = 3,
88 };
89
90 /**
91 * @enum Channel Access Mode (refer spec sec 6.6)
92 */
93 enum class EChannelAccessMode : uint8_t
94 {
95 disabled = 0,
96 preboot = 1,
97 alwaysAvail = 2,
98 shared = 3,
99 };
100
101 /**
102 * @enum Authentication Types (refer spec sec 13.6 - IPMI
103 * Session Header)
104 */
105 enum class EAuthType : uint8_t
106 {
107 none = (1 << 0x0),
108 md2 = (1 << 0x1),
109 md5 = (1 << 0x2),
110 reserved = (1 << 0x3),
111 straightPasswd = (1 << 0x4),
112 oem = (1 << 0x5),
113 };
114
115 // TODO: Remove duplicate 'PayloadType' definition from netipmid's message.hpp
116 // to phosphor-ipmi-host/include
117 /**
118 * @enum Payload Types (refer spec sec 13.27.3)
119 */
120 enum class PayloadType : uint8_t
121 {
122 IPMI = 0x00,
123 SOL = 0x01,
124 OPEN_SESSION_REQUEST = 0x10,
125 OPEN_SESSION_RESPONSE = 0x11,
126 RAKP1 = 0x12,
127 RAKP2 = 0x13,
128 RAKP3 = 0x14,
129 RAKP4 = 0x15,
130 INVALID = 0xFF,
131 };
132
133 /**
134 * @enum Access mode for channel access set/get (refer spec
135 * sec 22.22 - request byte 2[7:6])
136 */
137 typedef enum
138 {
139 doNotSet = 0x00,
140 nvData = 0x01,
141 activeData = 0x02,
142 reserved = 0x03,
143 } EChannelActionType;
144
145 /**
146 * @enum Access set flag to determine changes that has to be updated
147 * in channel access data configuration.
148 */
149 enum AccessSetFlag
150 {
151 setAccessMode = (1 << 0),
152 setUserAuthEnabled = (1 << 1),
153 setMsgAuthEnabled = (1 << 2),
154 setAlertingEnabled = (1 << 3),
155 setPrivLimit = (1 << 4),
156 };
157
158 /** @struct ChannelAccess
159 *
160 * Structure to store channel access related information, defined in IPMI
161 * specification and used in Get / Set channel access (refer spec sec 22.22
162 * & 22.23)
163 */
164 struct ChannelAccess
165 {
166 uint8_t accessMode;
167 bool userAuthDisabled;
168 bool perMsgAuthDisabled;
169 bool alertingDisabled;
170 uint8_t privLimit;
171 };
172
173 /** @struct ChannelInfo
174 *
175 * Structure to store data about channel information, which identifies each
176 * channel type and information as defined in IPMI specification. (refer spec
177 * sec 22.22 & 22.23)
178 */
179 struct ChannelInfo
180 {
181 uint8_t mediumType;
182 uint8_t protocolType;
183 uint8_t sessionSupported;
184 bool isIpmi; // Is session IPMI
185 // This is used in Get LAN Configuration parameter.
186 // This holds the supported AuthTypes for a given channel.
187 uint8_t authTypeSupported;
188 };
189
190 /** @brief determines valid channel
191 *
192 * @param[in] chNum- channel number
193 *
194 * @return true if valid, false otherwise
195 */
196 bool isValidChannel(const uint8_t chNum);
197
198 /** @brief determines whether channel device exist
199 *
200 * @param[in] chNum - channel number
201 *
202 * @return true if valid, false otherwise
203 */
204 bool doesDeviceExist(const uint8_t chNum);
205
206 /** @brief determines whether privilege limit is valid
207 *
208 * @param[in] privLimit - Privilege limit
209 *
210 * @return true if valid, false otherwise
211 */
212 bool isValidPrivLimit(const uint8_t privLimit);
213
214 /** @brief determines whether access mode is valid
215 *
216 * @param[in] accessMode - Access mode
217 *
218 * @return true if valid, false otherwise
219 */
220 bool isValidAccessMode(const uint8_t accessMode);
221
222 /** @brief determines valid authentication type based on channel number
223 *
224 * @param[in] chNum - channel number
225 * @param[in] authType - authentication type
226 *
227 * @return true if valid, false otherwise
228 */
229 bool isValidAuthType(const uint8_t chNum, const EAuthType& authType);
230
231 /** @brief determines supported session type of a channel
232 *
233 * @param[in] chNum - channel number
234 *
235 * @return EChannelSessSupported - supported session type
236 */
237 EChannelSessSupported getChannelSessionSupport(const uint8_t chNum);
238
239 /** @brief determines number of active sessions on a channel
240 *
241 * @param[in] chNum - channel number
242 *
243 * @return numer of active sessions
244 */
245 int getChannelActiveSessions(const uint8_t chNum);
246
247 /** @brief determines maximum transfer size for a channel
248 *
249 * @param[in] chNum - channel number
250 *
251 * @return maximum bytes that can be transferred on this channel
252 */
253 size_t getChannelMaxTransferSize(uint8_t chNum);
254
255 /** @brief initializes channel management
256 *
257 * @return ccSuccess for success, others for failure.
258 */
259 Cc ipmiChannelInit();
260
261 /** @brief provides channel info details
262 *
263 * @param[in] chNum - channel number
264 * @param[out] chInfo - channel info details
265 *
266 * @return ccSuccess for success, others for failure.
267 */
268 Cc getChannelInfo(const uint8_t chNum, ChannelInfo& chInfo);
269
270 /** @brief provides channel access data
271 *
272 * @param[in] chNum - channel number
273 * @param[out] chAccessData -channel access data
274 *
275 * @return ccSuccess for success, others for failure.
276 */
277 Cc getChannelAccessData(const uint8_t chNum, ChannelAccess& chAccessData);
278
279 /** @brief provides function to convert current channel number (0xE)
280 *
281 * @param[in] chNum - channel number as requested in commands.
282 * @param[in] devChannel - channel number as provided by device (not 0xE)
283 *
284 * @return same channel number or proper channel number for current channel
285 * number (0xE).
286 */
convertCurrentChannelNum(const uint8_t chNum,const uint8_t devChannel)287 static inline uint8_t convertCurrentChannelNum(const uint8_t chNum,
288 const uint8_t devChannel)
289 {
290 if (chNum == currentChNum)
291 {
292 return devChannel;
293 }
294 return chNum;
295 }
296
297 /** @brief to set channel access data
298 *
299 * @param[in] chNum - channel number
300 * @param[in] chAccessData - channel access data
301 * @param[in] setFlag - flag to indicate updatable fields
302 *
303 * @return ccSuccess for success, others for failure.
304 */
305 Cc setChannelAccessData(const uint8_t chNum, const ChannelAccess& chAccessData,
306 const uint8_t setFlag);
307
308 /** @brief to get channel access data persistent data
309 *
310 * @param[in] chNum - channel number
311 * @param[out] chAccessData - channel access data
312 *
313 * @return ccSuccess for success, others for failure.
314 */
315 Cc getChannelAccessPersistData(const uint8_t chNum,
316 ChannelAccess& chAccessData);
317
318 /** @brief to set channel access data persistent data
319 *
320 * @param[in] chNum - channel number
321 * @param[in] chAccessData - channel access data
322 * @param[in] setFlag - flag to indicate updatable fields
323 *
324 * @return ccSuccess for success, others for failure.
325 */
326 Cc setChannelAccessPersistData(const uint8_t chNum,
327 const ChannelAccess& chAccessData,
328 const uint8_t setFlag);
329
330 /** @brief provides supported authentication type for the channel
331 *
332 * @param[in] chNum - channel number
333 * @param[out] authTypeSupported - supported authentication type
334 *
335 * @return ccSuccess for success, others for failure.
336 */
337 Cc getChannelAuthTypeSupported(const uint8_t chNum, uint8_t& authTypeSupported);
338
339 /** @brief provides enabled authentication type for the channel
340 *
341 * @param[in] chNum - channel number
342 * @param[in] priv - privilege
343 * @param[out] authType - enabled authentication type
344 *
345 * @return ccSuccess for success, others for failure.
346 */
347 Cc getChannelEnabledAuthType(const uint8_t chNum, const uint8_t priv,
348 EAuthType& authType);
349
350 /** @brief Retrieves the LAN channel name from the IPMI channel number
351 *
352 * @param[in] chNum - IPMI channel number
353 *
354 * @return the LAN channel name (i.e. eth0)
355 */
356 std::string getChannelName(const uint8_t chNum);
357
358 /** @brief Retrieves the LAN channel number from the IPMI channel name
359 *
360 * @param[in] chName - IPMI channel name (i.e. eth0)
361 *
362 * @return the LAN channel number
363 */
364 uint8_t getChannelByName(const std::string& chName);
365
366 /** @brief determines whether payload type is valid
367 *
368 * @param[in] payload type - Payload Type
369 *
370 * @return true if valid, false otherwise
371 */
372 bool isValidPayloadType(const PayloadType payloadType);
373
374 } // namespace ipmi
375