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 
17 #include "channel_layer.hpp"
18 
19 #include "channel_mgmt.hpp"
20 
21 #include <phosphor-logging/log.hpp>
22 
23 namespace ipmi
24 {
25 
26 bool doesDeviceExist(const uint8_t chNum)
27 {
28     // TODO: This is not the reliable way to find the device
29     // associated with ethernet interface as the channel number to
30     // eth association is not done. Need to revisit later
31     struct stat fileStat = {0};
32     std::string devName("/sys/class/net/" +
33                         getChannelConfigObject().getChannelName(chNum));
34 
35     if (stat(devName.data(), &fileStat) != 0)
36     {
37         phosphor::logging::log<phosphor::logging::level::DEBUG>(
38             "Ethernet device not found");
39         return false;
40     }
41 
42     return true;
43 }
44 
45 bool isValidPrivLimit(const uint8_t privLimit)
46 {
47     return ((privLimit >= PRIVILEGE_CALLBACK) && (privLimit <= PRIVILEGE_OEM));
48 }
49 
50 bool isValidAccessMode(const uint8_t accessMode)
51 {
52     return (
53         (accessMode >= static_cast<uint8_t>(EChannelAccessMode::disabled)) &&
54         (accessMode <= static_cast<uint8_t>(EChannelAccessMode::shared)));
55 }
56 
57 bool isValidChannel(const uint8_t chNum)
58 {
59     return getChannelConfigObject().isValidChannel(chNum);
60 }
61 
62 uint8_t convertCurrentChannelNum(const uint8_t chNum)
63 {
64     return getChannelConfigObject().convertToChannelIndexNumber(chNum);
65 }
66 
67 bool isValidAuthType(const uint8_t chNum, const EAuthType& authType)
68 {
69     return getChannelConfigObject().isValidAuthType(chNum, authType);
70 }
71 
72 EChannelSessSupported getChannelSessionSupport(const uint8_t chNum)
73 {
74     return getChannelConfigObject().getChannelSessionSupport(chNum);
75 }
76 
77 int getChannelActiveSessions(const uint8_t chNum)
78 {
79     return getChannelConfigObject().getChannelActiveSessions(chNum);
80 }
81 
82 size_t getChannelMaxTransferSize(uint8_t chNum)
83 {
84     return getChannelConfigObject().getChannelMaxTransferSize(chNum);
85 }
86 
87 ipmi_ret_t ipmiChannelInit()
88 {
89     getChannelConfigObject();
90     return IPMI_CC_OK;
91 }
92 
93 ipmi_ret_t getChannelInfo(const uint8_t chNum, ChannelInfo& chInfo)
94 {
95     return getChannelConfigObject().getChannelInfo(chNum, chInfo);
96 }
97 
98 ipmi_ret_t getChannelAccessData(const uint8_t chNum,
99                                 ChannelAccess& chAccessData)
100 {
101     return getChannelConfigObject().getChannelAccessData(chNum, chAccessData);
102 }
103 
104 ipmi_ret_t setChannelAccessData(const uint8_t chNum,
105                                 const ChannelAccess& chAccessData,
106                                 const uint8_t setFlag)
107 {
108     return getChannelConfigObject().setChannelAccessData(chNum, chAccessData,
109                                                          setFlag);
110 }
111 
112 ipmi_ret_t getChannelAccessPersistData(const uint8_t chNum,
113                                        ChannelAccess& chAccessData)
114 {
115     return getChannelConfigObject().getChannelAccessPersistData(chNum,
116                                                                 chAccessData);
117 }
118 
119 ipmi_ret_t setChannelAccessPersistData(const uint8_t chNum,
120                                        const ChannelAccess& chAccessData,
121                                        const uint8_t setFlag)
122 {
123     return getChannelConfigObject().setChannelAccessPersistData(
124         chNum, chAccessData, setFlag);
125 }
126 
127 ipmi_ret_t getChannelAuthTypeSupported(const uint8_t chNum,
128                                        uint8_t& authTypeSupported)
129 {
130     return getChannelConfigObject().getChannelAuthTypeSupported(
131         chNum, authTypeSupported);
132 }
133 
134 ipmi_ret_t getChannelEnabledAuthType(const uint8_t chNum, const uint8_t priv,
135                                      EAuthType& authType)
136 {
137     return getChannelConfigObject().getChannelEnabledAuthType(chNum, priv,
138                                                               authType);
139 }
140 
141 } // namespace ipmi
142