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