1 // Copyright 2024 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "bios_setting.hpp"
16
17 #include "commands.hpp"
18 #include "errors.hpp"
19 #include "handler.hpp"
20
21 #include <ipmid/api-types.hpp>
22 #include <stdplus/fd/create.hpp>
23 #include <stdplus/fd/managed.hpp>
24 #include <stdplus/fd/ops.hpp>
25 #include <stdplus/numeric/endian.hpp>
26 #include <stdplus/print.hpp>
27 #include <stdplus/raw.hpp>
28
29 #include <filesystem>
30 #include <fstream>
31 #include <span>
32 #include <vector>
33
34 namespace google
35 {
36 namespace ipmi
37 {
38
readBiosSettingFromFile(const std::string & biosSettingPath)39 std::vector<uint8_t> readBiosSettingFromFile(const std::string& biosSettingPath)
40 {
41 std::vector<uint8_t> biosSettings;
42 try
43 {
44 stdplus::ManagedFd managedFd = stdplus::fd::open(
45 biosSettingPath,
46 stdplus::fd::OpenFlags(stdplus::fd::OpenAccess::ReadOnly));
47 biosSettings = stdplus::fd::readAll<std::vector<uint8_t>>(managedFd);
48 }
49 catch (const std::exception& e)
50 {
51 stdplus::print(stderr, "Read unsuccessful: {}\n", e.what());
52 return {};
53 }
54 return biosSettings;
55 }
56
readBiosSetting(std::span<const uint8_t>,HandlerInterface *,const std::string & biosSettingPath)57 Resp readBiosSetting(std::span<const uint8_t>, HandlerInterface*,
58 const std::string& biosSettingPath)
59 {
60 std::vector<uint8_t> biosSettings =
61 readBiosSettingFromFile(biosSettingPath);
62 size_t settingsLength = biosSettings.size();
63 if (settingsLength == 0)
64 {
65 return ::ipmi::responseRetBytesUnavailable();
66 }
67
68 // Reply format is: Length of the payload (1 byte) + payload
69 std::vector<std::uint8_t> reply;
70 reply.reserve(1 + settingsLength);
71 reply.emplace_back(static_cast<uint8_t>(settingsLength));
72 reply.insert(reply.end(), biosSettings.begin(), biosSettings.end());
73
74 return ::ipmi::responseSuccess(SysOEMCommands::SysReadBiosSetting, reply);
75 }
76
writeBiosSetting(std::span<const uint8_t> data,HandlerInterface *,const std::string & biosSettingPath)77 Resp writeBiosSetting(std::span<const uint8_t> data, HandlerInterface*,
78 const std::string& biosSettingPath)
79 {
80 std::uint8_t payloadSize;
81 try
82 {
83 // This subspans the data automatically
84 payloadSize = stdplus::raw::extract<
85 stdplus::EndianPacked<decltype(payloadSize), std::endian::little>>(
86 data);
87 }
88 catch (const std::exception& e)
89 {
90 stdplus::print(stderr, "Extracting payload failed: {}\n", e.what());
91 return ::ipmi::responseReqDataLenInvalid();
92 }
93
94 if (data.size() != payloadSize)
95 {
96 stdplus::print(stderr, "Invalid command length {} vs. payloadSize {}\n",
97 static_cast<uint32_t>(data.size()),
98 static_cast<uint32_t>(payloadSize));
99 return ::ipmi::responseReqDataLenInvalid();
100 }
101
102 // Write the setting
103 try
104 {
105 stdplus::ManagedFd managedFd = stdplus::fd::open(
106 biosSettingPath,
107 stdplus::fd::OpenFlags(stdplus::fd::OpenAccess::WriteOnly)
108 .set(stdplus::fd::OpenFlag::Trunc)
109 .set(stdplus::fd::OpenFlag::Create));
110 stdplus::fd::writeExact(managedFd, data);
111 }
112 catch (const std::exception& e)
113 {
114 stdplus::print(stderr, "Write unsuccessful: {}\n", e.what());
115 return ::ipmi::responseRetBytesUnavailable();
116 }
117
118 // Reply format is: Length of the payload written
119 std::vector<std::uint8_t> reply;
120 reply.reserve(1);
121 reply.emplace_back(static_cast<uint8_t>(payloadSize));
122
123 return ::ipmi::responseSuccess(SysOEMCommands::SysWriteBiosSetting, reply);
124 }
125
126 } // namespace ipmi
127 } // namespace google
128