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  */
287 static inline uint8_t
convertCurrentChannelNum(const uint8_t chNum,const uint8_t devChannel)288     convertCurrentChannelNum(const uint8_t chNum, 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