1 /**
2  * Copyright © 2019 IBM 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 #include "user_data.hpp"
17 
18 #include "json_utils.hpp"
19 #include "pel_types.hpp"
20 #include "user_data_formats.hpp"
21 #ifdef PELTOOL
22 #include "user_data_json.hpp"
23 #endif
24 
25 #include <fmt/format.h>
26 
27 #include <phosphor-logging/log.hpp>
28 
29 namespace openpower
30 {
31 namespace pels
32 {
33 
34 using namespace phosphor::logging;
35 
36 void UserData::unflatten(Stream& stream)
37 {
38     stream >> _header;
39 
40     if (_header.size <= SectionHeader::flattenedSize())
41     {
42         throw std::out_of_range(
43             "UserData::unflatten: SectionHeader::size field too small");
44     }
45 
46     size_t dataLength = _header.size - SectionHeader::flattenedSize();
47     _data.resize(dataLength);
48 
49     stream >> _data;
50 }
51 
52 void UserData::flatten(Stream& stream) const
53 {
54     stream << _header << _data;
55 }
56 
57 UserData::UserData(Stream& pel)
58 {
59     try
60     {
61         unflatten(pel);
62         validate();
63     }
64     catch (const std::exception& e)
65     {
66         log<level::ERR>(
67             fmt::format("Cannot unflatten user data: {}", e.what()).c_str());
68         _valid = false;
69     }
70 }
71 
72 UserData::UserData(uint16_t componentID, uint8_t subType, uint8_t version,
73                    const std::vector<uint8_t>& data)
74 {
75     _header.id = static_cast<uint16_t>(SectionID::userData);
76     _header.size = Section::flattenedSize() + data.size();
77     _header.version = version;
78     _header.subType = subType;
79     _header.componentID = componentID;
80 
81     _data = data;
82 
83     _valid = true;
84 }
85 
86 void UserData::validate()
87 {
88     if (header().id != static_cast<uint16_t>(SectionID::userData))
89     {
90         log<level::ERR>(
91             fmt::format("Invalid UserData section ID: {0:#x}", header().id)
92                 .c_str());
93         _valid = false;
94     }
95     else
96     {
97         _valid = true;
98     }
99 }
100 
101 std::optional<std::string>
102     UserData::getJSON(uint8_t creatorID [[maybe_unused]],
103                       const std::vector<std::string>& plugins
104                       [[maybe_unused]]) const
105 {
106 #ifdef PELTOOL
107     return user_data::getJSON(_header.componentID, _header.subType,
108                               _header.version, _data, creatorID, plugins);
109 #endif
110     return std::nullopt;
111 }
112 
113 bool UserData::shrink(size_t newSize)
114 {
115     // minimum size is 4 bytes plus the 8B header
116     if ((newSize < flattenedSize()) &&
117         (newSize >= (Section::flattenedSize() + 4)))
118     {
119         auto dataSize = newSize - Section::flattenedSize();
120 
121         // Ensure it's 4B aligned
122         _data.resize((dataSize / 4) * 4);
123         _header.size = Section::flattenedSize() + _data.size();
124         return true;
125     }
126 
127     return false;
128 }
129 
130 } // namespace pels
131 } // namespace openpower
132