1 #include "sol_cmds.hpp"
2 
3 #include "main.hpp"
4 #include "sol/sol_context.hpp"
5 #include "sol/sol_manager.hpp"
6 
7 #include <phosphor-logging/log.hpp>
8 
9 namespace sol
10 {
11 
12 namespace command
13 {
14 
15 using namespace phosphor::logging;
16 
17 std::vector<uint8_t> payloadHandler(const std::vector<uint8_t>& inPayload,
18                                     const message::Handler& handler)
19 {
20     // Check inPayload size is at least Payload
21     if (inPayload.size() < sizeof(Payload))
22     {
23         return std::vector<uint8_t>();
24     }
25 
26     auto request = reinterpret_cast<const Payload*>(inPayload.data());
27     auto solDataSize = inPayload.size() - sizeof(Payload);
28 
29     std::vector<uint8_t> charData(solDataSize);
30     if (solDataSize > 0)
31     {
32         std::copy_n(inPayload.data() + sizeof(Payload), solDataSize,
33                     charData.begin());
34     }
35 
36     try
37     {
38         auto& context = std::get<sol::Manager&>(singletonPool)
39                             .getContext(handler.sessionID);
40 
41         context.processInboundPayload(
42             request->packetSeqNum, request->packetAckSeqNum,
43             request->acceptedCharCount, request->inOperation.ack, charData);
44     }
45     catch (std::exception& e)
46     {
47         log<level::ERR>(e.what());
48         return std::vector<uint8_t>();
49     }
50 
51     return std::vector<uint8_t>();
52 }
53 
54 void activating(uint8_t payloadInstance, uint32_t sessionID)
55 {
56     std::vector<uint8_t> outPayload(sizeof(ActivatingRequest));
57 
58     auto request = reinterpret_cast<ActivatingRequest*>(outPayload.data());
59 
60     request->sessionState = 0;
61     request->payloadInstance = payloadInstance;
62     request->majorVersion = MAJOR_VERSION;
63     request->minorVersion = MINOR_VERSION;
64 
65     auto session =
66         std::get<session::Manager&>(singletonPool).getSession(sessionID);
67 
68     message::Handler msgHandler(session->channelPtr, sessionID);
69 
70     msgHandler.sendUnsolicitedIPMIPayload(netfnTransport, solActivatingCmd,
71                                           outPayload);
72 }
73 
74 std::vector<uint8_t> getConfParams(const std::vector<uint8_t>& inPayload,
75                                    const message::Handler& handler)
76 {
77     std::vector<uint8_t> outPayload(sizeof(GetConfParamsResponse));
78     auto request =
79         reinterpret_cast<const GetConfParamsRequest*>(inPayload.data());
80     auto response = reinterpret_cast<GetConfParamsResponse*>(outPayload.data());
81     response->completionCode = IPMI_CC_OK;
82     response->paramRev = parameterRevision;
83 
84     if (request->getParamRev)
85     {
86         return outPayload;
87     }
88 
89     switch (static_cast<Parameter>(request->paramSelector))
90     {
91         case Parameter::PROGRESS:
92         {
93             outPayload.push_back(
94                 std::get<sol::Manager&>(singletonPool).progress);
95             break;
96         }
97         case Parameter::ENABLE:
98         {
99             outPayload.push_back(std::get<sol::Manager&>(singletonPool).enable);
100             break;
101         }
102         case Parameter::AUTHENTICATION:
103         {
104             Auth value{0};
105 
106             value.encrypt = std::get<sol::Manager&>(singletonPool).forceEncrypt;
107             value.auth = std::get<sol::Manager&>(singletonPool).forceAuth;
108             value.privilege = static_cast<uint8_t>(
109                 std::get<sol::Manager&>(singletonPool).solMinPrivilege);
110             auto buffer = reinterpret_cast<const uint8_t*>(&value);
111 
112             std::copy_n(buffer, sizeof(value), std::back_inserter(outPayload));
113             break;
114         }
115         case Parameter::ACCUMULATE:
116         {
117             Accumulate value{0};
118 
119             value.interval = std::get<sol::Manager&>(singletonPool)
120                                  .accumulateInterval.count() /
121                              sol::accIntervalFactor;
122             value.threshold =
123                 std::get<sol::Manager&>(singletonPool).sendThreshold;
124             auto buffer = reinterpret_cast<const uint8_t*>(&value);
125 
126             std::copy_n(buffer, sizeof(value), std::back_inserter(outPayload));
127             break;
128         }
129         case Parameter::RETRY:
130         {
131             Retry value{0};
132 
133             value.count = std::get<sol::Manager&>(singletonPool).retryCount;
134             value.interval =
135                 std::get<sol::Manager&>(singletonPool).retryInterval.count() /
136                 sol::retryIntervalFactor;
137             auto buffer = reinterpret_cast<const uint8_t*>(&value);
138 
139             std::copy_n(buffer, sizeof(value), std::back_inserter(outPayload));
140             break;
141         }
142         case Parameter::PORT:
143         {
144             auto port = endian::to_ipmi<uint16_t>(IPMI_STD_PORT);
145             auto buffer = reinterpret_cast<const uint8_t*>(&port);
146 
147             std::copy_n(buffer, sizeof(port), std::back_inserter(outPayload));
148             break;
149         }
150         case Parameter::CHANNEL:
151         {
152             outPayload.push_back(
153                 std::get<sol::Manager&>(singletonPool).channel);
154             break;
155         }
156         case Parameter::NVBITRATE:
157         case Parameter::VBITRATE:
158         default:
159             response->completionCode = ipmiCCParamNotSupported;
160     }
161 
162     return outPayload;
163 }
164 
165 } // namespace command
166 
167 } // namespace sol
168