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/" + getChannelName(chNum));
33 
34     if (stat(devName.data(), &fileStat) != 0)
35     {
36         phosphor::logging::log<phosphor::logging::level::DEBUG>(
37             "Ethernet device not found");
38         return false;
39     }
40 
41     return true;
42 }
43 
44 bool isValidPrivLimit(const uint8_t privLimit)
45 {
46     return ((privLimit >= PRIVILEGE_CALLBACK) && (privLimit <= PRIVILEGE_OEM));
47 }
48 
49 bool isValidAccessMode(const uint8_t accessMode)
50 {
51     return (
52         (accessMode >= static_cast<uint8_t>(EChannelAccessMode::disabled)) &&
53         (accessMode <= static_cast<uint8_t>(EChannelAccessMode::shared)));
54 }
55 
56 bool isValidChannel(const uint8_t chNum)
57 {
58     return getChannelConfigObject().isValidChannel(chNum);
59 }
60 
61 uint8_t convertCurrentChannelNum(const uint8_t chNum)
62 {
63     return getChannelConfigObject().convertToChannelIndexNumber(chNum);
64 }
65 
66 bool isValidAuthType(const uint8_t chNum, const EAuthType& authType)
67 {
68     return getChannelConfigObject().isValidAuthType(chNum, authType);
69 }
70 
71 EChannelSessSupported getChannelSessionSupport(const uint8_t chNum)
72 {
73     return getChannelConfigObject().getChannelSessionSupport(chNum);
74 }
75 
76 int getChannelActiveSessions(const uint8_t chNum)
77 {
78     return getChannelConfigObject().getChannelActiveSessions(chNum);
79 }
80 
81 size_t getChannelMaxTransferSize(uint8_t chNum)
82 {
83     return getChannelConfigObject().getChannelMaxTransferSize(chNum);
84 }
85 
86 ipmi_ret_t ipmiChannelInit()
87 {
88     getChannelConfigObject();
89     return IPMI_CC_OK;
90 }
91 
92 ipmi_ret_t getChannelInfo(const uint8_t chNum, ChannelInfo& chInfo)
93 {
94     return getChannelConfigObject().getChannelInfo(chNum, chInfo);
95 }
96 
97 ipmi_ret_t getChannelAccessData(const uint8_t chNum,
98                                 ChannelAccess& chAccessData)
99 {
100     return getChannelConfigObject().getChannelAccessData(chNum, chAccessData);
101 }
102 
103 ipmi_ret_t setChannelAccessData(const uint8_t chNum,
104                                 const ChannelAccess& chAccessData,
105                                 const uint8_t setFlag)
106 {
107     return getChannelConfigObject().setChannelAccessData(chNum, chAccessData,
108                                                          setFlag);
109 }
110 
111 ipmi_ret_t getChannelAccessPersistData(const uint8_t chNum,
112                                        ChannelAccess& chAccessData)
113 {
114     return getChannelConfigObject().getChannelAccessPersistData(chNum,
115                                                                 chAccessData);
116 }
117 
118 ipmi_ret_t setChannelAccessPersistData(const uint8_t chNum,
119                                        const ChannelAccess& chAccessData,
120                                        const uint8_t setFlag)
121 {
122     return getChannelConfigObject().setChannelAccessPersistData(
123         chNum, chAccessData, setFlag);
124 }
125 
126 ipmi_ret_t getChannelAuthTypeSupported(const uint8_t chNum,
127                                        uint8_t& authTypeSupported)
128 {
129     return getChannelConfigObject().getChannelAuthTypeSupported(
130         chNum, authTypeSupported);
131 }
132 
133 ipmi_ret_t getChannelEnabledAuthType(const uint8_t chNum, const uint8_t priv,
134                                      EAuthType& authType)
135 {
136     return getChannelConfigObject().getChannelEnabledAuthType(chNum, priv,
137                                                               authType);
138 }
139 
140 std::string getChannelName(const uint8_t chNum)
141 {
142     return getChannelConfigObject().getChannelName(chNum);
143 }
144 
145 } // namespace ipmi
146