1 /**
2  * Copyright © 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 #include <ipmid/api.hpp>
17 #include <ipmid/message.hpp>
18 
19 #include <gtest/gtest.h>
20 
21 // TODO: Add testing of Payload response API
22 
23 TEST(PackBasics, Uint8)
24 {
25     ipmi::message::Payload p;
26     uint8_t v = 4;
27     p.pack(v);
28     // check that the number of bytes matches
29     ASSERT_EQ(p.size(), sizeof(v));
30     // check that the bytes were correctly packed (LSB first)
31     std::vector<uint8_t> k = {0x04};
32     ASSERT_EQ(p.raw, k);
33 }
34 
35 TEST(PackBasics, Uint16)
36 {
37     ipmi::message::Payload p;
38     uint16_t v = 0x8604;
39     p.pack(v);
40     // check that the number of bytes matches
41     ASSERT_EQ(p.size(), sizeof(v));
42     // check that the bytes were correctly packed (LSB first)
43     std::vector<uint8_t> k = {0x04, 0x86};
44     ASSERT_EQ(p.raw, k);
45 }
46 
47 TEST(PackBasics, Uint32)
48 {
49     ipmi::message::Payload p;
50     uint32_t v = 0x02008604;
51     p.pack(v);
52     // check that the number of bytes matches
53     ASSERT_EQ(p.size(), sizeof(v));
54     // check that the bytes were correctly packed (LSB first)
55     std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02};
56     ASSERT_EQ(p.raw, k);
57 }
58 
59 TEST(PackBasics, Uint64)
60 {
61     ipmi::message::Payload p;
62     uint64_t v = 0x1122334402008604ull;
63     p.pack(v);
64     // check that the number of bytes matches
65     ASSERT_EQ(p.size(), sizeof(v));
66     // check that the bytes were correctly packed (LSB first)
67     std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02, 0x44, 0x33, 0x22, 0x11};
68     ASSERT_EQ(p.raw, k);
69 }
70 
71 TEST(PackBasics, Uint24)
72 {
73     ipmi::message::Payload p;
74     uint24_t v = 0x112358;
75     p.pack(v);
76     // check that the number of bytes matches
77     ASSERT_EQ(p.size(), types::nrFixedBits<decltype(v)> / CHAR_BIT);
78     // check that the bytes were correctly packed (LSB first)
79     std::vector<uint8_t> k = {0x58, 0x23, 0x11};
80     ASSERT_EQ(p.raw, k);
81 }
82 
83 TEST(PackBasics, Uint3Uint5)
84 {
85     // individual bytes are packed low-order-bits first
86     // v1 will occupy [2:0], v2 will occupy [7:3]
87     ipmi::message::Payload p;
88     uint3_t v1 = 0x1;
89     uint5_t v2 = 0x19;
90     p.pack(v1, v2);
91     // check that the number of bytes matches
92     ASSERT_EQ(p.size(), (types::nrFixedBits<decltype(v1)> +
93                          types::nrFixedBits<decltype(v2)>) /
94                             CHAR_BIT);
95     // check that the bytes were correctly packed (LSB first)
96     std::vector<uint8_t> k = {0xc9};
97     ASSERT_EQ(p.raw, k);
98 }
99 
100 TEST(PackBasics, Boolx8)
101 {
102     // individual bytes are packed low-order-bits first
103     // [v8, v7, v6, v5, v4, v3, v2, v1]
104     ipmi::message::Payload p;
105     bool v8 = true, v7 = true, v6 = false, v5 = false;
106     bool v4 = true, v3 = false, v2 = false, v1 = true;
107     p.pack(v1, v2, v3, v4, v5, v6, v7, v8);
108     // check that the number of bytes matches
109     ASSERT_EQ(p.size(), sizeof(uint8_t));
110     // check that the bytes were correctly packed (LSB first)
111     std::vector<uint8_t> k = {0xc9};
112     ASSERT_EQ(p.raw, k);
113 }
114 
115 TEST(PackBasics, Bitset8)
116 {
117     // individual bytes are packed low-order-bits first
118     // a bitset for 8 bits fills the full byte
119     ipmi::message::Payload p;
120     std::bitset<8> v(0xc9);
121     p.pack(v);
122     // check that the number of bytes matches
123     ASSERT_EQ(p.size(), v.size() / CHAR_BIT);
124     // check that the bytes were correctly packed (LSB first)
125     std::vector<uint8_t> k = {0xc9};
126     ASSERT_EQ(p.raw, k);
127 }
128 
129 TEST(PackBasics, Bitset3Bitset5)
130 {
131     // individual bytes are packed low-order-bits first
132     // v1 will occupy [2:0], v2 will occupy [7:3]
133     ipmi::message::Payload p;
134     std::bitset<3> v1(0x1);
135     std::bitset<5> v2(0x19);
136     p.pack(v1, v2);
137     // check that the number of bytes matches
138     ASSERT_EQ(p.size(), (v1.size() + v2.size()) / CHAR_BIT);
139     // check that the bytes were correctly packed (LSB first)
140     std::vector<uint8_t> k = {0xc9};
141     ASSERT_EQ(p.raw, k);
142 }
143 
144 TEST(PackBasics, Bitset32)
145 {
146     // individual bytes are packed low-order-bits first
147     // v1 will occupy 4 bytes, but in LSByte first order
148     // v1[7:0] v1[15:9] v1[23:16] v1[31:24]
149     ipmi::message::Payload p;
150     std::bitset<32> v(0x02008604);
151     p.pack(v);
152     // check that the number of bytes matches
153     ASSERT_EQ(p.size(), v.size() / CHAR_BIT);
154     // check that the bytes were correctly packed (LSB first)
155     std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02};
156     ASSERT_EQ(p.raw, k);
157 }
158 
159 TEST(PackBasics, Tuple)
160 {
161     // tuples are the new struct, pack a tuple
162     ipmi::message::Payload p;
163     auto v = std::make_tuple(static_cast<uint16_t>(0x8604), 'A');
164     p.pack(v);
165     // check that the number of bytes matches
166     ASSERT_EQ(p.size(), sizeof(uint16_t) + sizeof(char));
167     // check that the bytes were correctly packed (LSB first)
168     std::vector<uint8_t> k = {0x04, 0x86, 0x41};
169     ASSERT_EQ(p.raw, k);
170 }
171 
172 TEST(PackBasics, Array4xUint8)
173 {
174     // an array of bytes will be output verbatim, low-order element first
175     ipmi::message::Payload p;
176     std::array<uint8_t, 4> v = {{0x02, 0x00, 0x86, 0x04}};
177     p.pack(v);
178     // check that the number of bytes matches
179     ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
180     // check that the bytes were correctly packed (in byte order)
181     std::vector<uint8_t> k = {0x02, 0x00, 0x86, 0x04};
182     ASSERT_EQ(p.raw, k);
183 }
184 
185 TEST(PackBasics, Array4xUint32)
186 {
187     // an array of multi-byte values will be output in order low-order
188     // element first, each multi-byte element in LSByte order
189     // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24]
190     // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24]
191     // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24]
192     // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24]
193     ipmi::message::Payload p;
194     std::array<uint32_t, 4> v = {
195         {0x11223344, 0x22446688, 0x33557799, 0x12345678}};
196     p.pack(v);
197     // check that the number of bytes matches
198     ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
199     // check that the bytes were correctly packed (in byte order)
200     std::vector<uint8_t> k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22,
201                               0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12};
202     ASSERT_EQ(p.raw, k);
203 }
204 
205 TEST(PackBasics, VectorUint32)
206 {
207     // a vector of multi-byte values will be output in order low-order
208     // element first, each multi-byte element in LSByte order
209     // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24]
210     // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24]
211     // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24]
212     // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24]
213     ipmi::message::Payload p;
214     std::vector<uint32_t> v = {
215         {0x11223344, 0x22446688, 0x33557799, 0x12345678}};
216     p.pack(v);
217     // check that the number of bytes matches
218     ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
219     // check that the bytes were correctly packed (in byte order)
220     std::vector<uint8_t> k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22,
221                               0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12};
222     ASSERT_EQ(p.raw, k);
223 }
224 
225 TEST(PackBasics, VectorUint8)
226 {
227     // a vector of bytes will be output verbatim, low-order element first
228     ipmi::message::Payload p;
229     std::vector<uint8_t> v = {0x02, 0x00, 0x86, 0x04};
230     p.pack(v);
231     // check that the number of bytes matches
232     ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
233     // check that the bytes were correctly packed (in byte order)
234     std::vector<uint8_t> k = {0x02, 0x00, 0x86, 0x04};
235     ASSERT_EQ(p.raw, k);
236 }
237 
238 TEST(PackBasics, OptionalEmpty)
239 {
240     // an optional will only pack if the value is present
241     ipmi::message::Payload p;
242     std::optional<uint32_t> v;
243     p.pack(v);
244     // check that the number of bytes matches
245     ASSERT_EQ(p.size(), 0);
246     // check that the bytes were correctly packed (in byte order)
247     std::vector<uint8_t> k = {};
248     ASSERT_EQ(p.raw, k);
249 }
250 
251 TEST(PackBasics, OptionalContainsValue)
252 {
253     // an optional will only pack if the value is present
254     ipmi::message::Payload p;
255     std::optional<uint32_t> v(0x04860002);
256     p.pack(v);
257     // check that the number of bytes matches
258     ASSERT_EQ(p.size(), sizeof(uint32_t));
259     // check that the bytes were correctly packed (in byte order)
260     std::vector<uint8_t> k = {0x02, 0x00, 0x86, 0x04};
261     ASSERT_EQ(p.raw, k);
262 }
263 
264 TEST(PackAdvanced, Uints)
265 {
266     // all elements will be processed in order, with each multi-byte
267     // element being processed LSByte first
268     // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24]
269     // v4[7:0] v4[15:8] v4[23:16] v4[31:24]
270     // v4[39:25] v4[47:40] v4[55:48] v4[63:56]
271     ipmi::message::Payload p;
272     uint8_t v1 = 0x02;
273     uint16_t v2 = 0x0604;
274     uint32_t v3 = 0x44332211;
275     uint64_t v4 = 0xccbbaa9988776655ull;
276     p.pack(v1, v2, v3, v4);
277     // check that the number of bytes matches
278     ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4));
279     // check that the bytes were correctly packed (LSB first)
280     std::vector<uint8_t> k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55,
281                               0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc};
282     ASSERT_EQ(p.raw, k);
283 }
284 
285 TEST(PackAdvanced, TupleInts)
286 {
287     // all elements will be processed in order, with each multi-byte
288     // element being processed LSByte first
289     // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24]
290     // v4[7:0] v4[15:8] v4[23:16] v4[31:24]
291     // v4[39:25] v4[47:40] v4[55:48] v4[63:56]
292     ipmi::message::Payload p;
293     uint8_t v1 = 0x02;
294     uint16_t v2 = 0x0604;
295     uint32_t v3 = 0x44332211;
296     uint64_t v4 = 0xccbbaa9988776655ull;
297     auto v = std::make_tuple(v1, v2, v3, v4);
298     p.pack(v);
299     // check that the number of bytes matches
300     ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4));
301     // check that the bytes were correctly packed (LSB first)
302     std::vector<uint8_t> k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55,
303                               0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc};
304     ASSERT_EQ(p.raw, k);
305 }
306 
307 TEST(PackAdvanced, VariantArray)
308 {
309     ipmi::message::Payload p;
310     std::variant<std::array<uint8_t, 2>, uint32_t> variant;
311     auto data = std::array<uint8_t, 2>{2, 4};
312     variant = data;
313 
314     p.pack(variant);
315     ASSERT_EQ(p.size(), sizeof(data));
316 
317     // check that the bytes were correctly packed packed (LSB first)
318     std::vector<uint8_t> k = {2, 4};
319     ASSERT_EQ(p.raw, k);
320 }
321 
322 TEST(PackAdvanced, BoolsnBitfieldsnFixedIntsOhMy)
323 {
324     // each element will be added, filling the low-order bits first
325     // with multi-byte values getting added LSByte first
326     // v1 will occupy k[0][1:0]
327     // v2 will occupy k[0][2]
328     // v3[4:0] will occupy k[0][7:3], v3[6:5] will occupy k[1][1:0]
329     // v4 will occupy k[1][2]
330     // v5 will occupy k[1][7:3]
331     ipmi::message::Payload p;
332     uint2_t v1 = 2;          // binary 0b10
333     bool v2 = true;          // binary 0b1
334     std::bitset<7> v3(0x73); // binary 0b1110011
335     bool v4 = false;         // binary 0b0
336     uint5_t v5 = 27;         // binary 0b11011
337     // concat binary: 0b1101101110011110 -> 0xdb9e -> 0x9e 0xdb (LSByte first)
338     p.pack(v1, v2, v3, v4, v5);
339     // check that the number of bytes matches
340     ASSERT_EQ(p.size(), sizeof(uint16_t));
341     // check that the bytes were correctly packed (LSB first)
342     std::vector<uint8_t> k = {0x9e, 0xdb};
343     ASSERT_EQ(p.raw, k);
344 }
345 
346 TEST(PackAdvanced, UnalignedBitPacking)
347 {
348     // unaligned multi-byte values will be packed the same as
349     // other bits, effectively building up a large value, low-order
350     // bits first, then outputting a stream of LSByte values
351     // v1 will occupy k[0][1:0]
352     // v2[5:0] will occupy k[0][7:2], v2[7:6] will occupy k[1][1:0]
353     // v3 will occupy k[1][2]
354     // v4[4:0] will occupy k[1][7:3] v4[12:5] will occupy k[2][7:0]
355     // v4[15:13] will occupy k[3][2:0]
356     // v5 will occupy k[3][3]
357     // v6[3:0] will occupy k[3][7:0] v6[11:4] will occupy k[4][7:0]
358     // v6[19:12] will occupy k[5][7:0] v6[27:20] will occupy k[6][7:0]
359     // v6[31:28] will occupy k[7][3:0]
360     // v7 will occupy k[7][7:4]
361     ipmi::message::Payload p;
362     uint2_t v1 = 2;           // binary 0b10
363     uint8_t v2 = 0xa5;        // binary 0b10100101
364     bool v3 = false;          // binary 0b0
365     uint16_t v4 = 0xa55a;     // binary 0b1010010101011010
366     bool v5 = true;           // binary 0b1
367     uint32_t v6 = 0xdbc3bd3c; // binary 0b11011011110000111011110100111100
368     uint4_t v7 = 9;           // binary 0b1001
369     // concat binary:
370     //   0b1001110110111100001110111101001111001101001010101101001010010110
371     //   -> 0x9dbc3bd3cd2ad296 -> 0x96 0xd2 0x2a 0xcd 0xd3 0x3b 0xbc 0x9d
372     p.pack(v1, v2, v3, v4, v5, v6, v7);
373     // check that the number of bytes matches
374     ASSERT_EQ(p.size(), sizeof(uint64_t));
375     // check that the bytes were correctly packed (LSB first)
376     std::vector<uint8_t> k = {0x96, 0xd2, 0x2a, 0xcd, 0xd3, 0x3b, 0xbc, 0x9d};
377     ASSERT_EQ(p.raw, k);
378 }
379 
380 TEST(PackAdvanced, ComplexOptionalTuple)
381 {
382     constexpr size_t macSize = 6;
383     // inspired from a real-world case of Get Session Info
384     constexpr uint8_t handle = 0x23;       // handle for active session
385     constexpr uint8_t maxSessions = 15;    // number of possible active sessions
386     constexpr uint8_t currentSessions = 4; // number of current active sessions
387     std::optional<                         // only returned for active session
388         std::tuple<uint8_t,                // user ID
389                    uint8_t,                // privilege
390                    uint4_t,                // channel number
391                    uint4_t                 // protocol (RMCP+)
392                    >>
393         activeSession;
394     std::optional<           // only returned for channel type LAN
395         std::tuple<uint32_t, // IPv4 address
396                    std::array<uint8_t, macSize>, // MAC address
397                    uint16_t                      // port
398                    >>
399         lanSession;
400 
401     constexpr uint8_t userID = 7;
402     constexpr uint8_t priv = 4;
403     constexpr uint4_t channel = 2;
404     constexpr uint4_t protocol = 1;
405     activeSession.emplace(userID, priv, channel, protocol);
406     constexpr std::array<uint8_t, macSize> macAddr{0};
407     lanSession.emplace(0x0a010105, macAddr, 55327);
408 
409     ipmi::message::Payload p;
410     p.pack(handle, maxSessions, currentSessions, activeSession, lanSession);
411     ASSERT_EQ(p.size(), sizeof(handle) + sizeof(maxSessions) +
412                             sizeof(currentSessions) + 3 * sizeof(uint8_t) +
413                             sizeof(uint32_t) + sizeof(uint8_t) * macSize +
414                             sizeof(uint16_t));
415     uint8_t protocol_channel =
416         (static_cast<uint8_t>(protocol) << 4) | static_cast<uint8_t>(channel);
417     std::vector<uint8_t> k = {handle, maxSessions, currentSessions, userID,
418                               priv, protocol_channel,
419                               // ip addr
420                               0x05, 0x01, 0x01, 0x0a,
421                               // mac addr
422                               0, 0, 0, 0, 0, 0,
423                               // port
424                               0x1f, 0xd8};
425     ASSERT_EQ(p.raw, k);
426 }
427