xref: /openbmc/phosphor-host-ipmid/user_channel/channel_layer.hpp (revision 1318a5ed36cfd41335e687b54db1c17c0dde8f45)
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