1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2014 Gary Mills
24 *
25 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
26 *
27 * Copyright (c) 2018, Joyent, Inc.
28 */
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <stdint.h>
33 #include <strings.h>
34 #include <assert.h>
35 #include <pthread.h>
36 #include <sys/byteorder.h>
37 #include <sys/types.h>
38 #include <sys/nvpair.h>
39
40 #include "libfru.h"
41 #include "libfrup.h"
42 #include "fru_tag.h"
43 #include "libfrureg.h"
44 #include "nvfru.h"
45
46 #define NUM_ITER_BYTES 4
47 #define HEAD_ITER 0
48 #define TAIL_ITER 1
49 #define NUM_ITER 2
50 #define MAX_ITER 3
51 #define TIMESTRINGLEN 128
52
53 #define PARSE_TIME 1
54
55 static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER;
56
57
58
59 static void
60 convert_field(const uint8_t *field, const fru_regdef_t *def, const char *path,
61 nvlist_t *nv)
62 {
63 char timestring[TIMESTRINGLEN];
64 int i;
65 uint64_t value;
66 time_t timefield;
67
68 switch (def->dataType) {
69 case FDTYPE_Binary:
70 assert(def->payloadLen <= sizeof (value));
71 switch (def->dispType) {
72 #if PARSE_TIME == 1
73 case FDISP_Time:
74 if (def->payloadLen > sizeof (timefield)) {
75 /* too big for formatting */
76 return;
77 }
78 (void) memcpy(&timefield, field, sizeof (timefield));
79 timefield = BE_32(timefield);
80 if (strftime(timestring, sizeof (timestring), "%c",
81 localtime(&timefield)) == 0) {
82 /* buffer too small */
83 return;
84 }
85 (void) nvlist_add_string(nv, path, timestring);
86 return;
87 #endif
88
89 case FDISP_Binary:
90 case FDISP_Octal:
91 case FDISP_Decimal:
92 case FDISP_Hex:
93 default:
94 value = 0;
95 (void) memcpy((((uint8_t *)&value) +
96 sizeof (value) - def->payloadLen),
97 field, def->payloadLen);
98 value = BE_64(value);
99 switch (def->payloadLen) {
100 case 1:
101 (void) nvlist_add_uint8(nv, path,
102 (uint8_t)value);
103 break;
104 case 2:
105 (void) nvlist_add_uint16(nv, path,
106 (uint16_t)value);
107 break;
108 case 4:
109 (void) nvlist_add_uint32(nv, path,
110 (uint32_t)value);
111 break;
112 default:
113 (void) nvlist_add_uint64(nv, path, value);
114 }
115 return;
116 }
117
118 case FDTYPE_ASCII:
119 (void) nvlist_add_string(nv, path, (char *)field);
120 return;
121
122 case FDTYPE_Enumeration:
123 value = 0;
124 (void) memcpy((((uint8_t *)&value) + sizeof (value) -
125 def->payloadLen), field, def->payloadLen);
126 value = BE_64(value);
127 for (i = 0; i < def->enumCount; i++) {
128 if (def->enumTable[i].value == value) {
129 (void) nvlist_add_string(nv, path,
130 def->enumTable[i].text);
131 return;
132 }
133 }
134 }
135
136 /* nothing matched above, use byte array */
137 (void) nvlist_add_byte_array(nv, path, (uchar_t *)field,
138 def->payloadLen);
139 }
140
141
142
143 static void
144 convert_element(const uint8_t *data, const fru_regdef_t *def, char *ppath,
145 nvlist_t *nv, boolean_t from_iter)
146 {
147 int i;
148 char *path;
149
150 /* construct path */
151 if ((def->iterationCount == 0) &&
152 (def->iterationType != FRU_NOT_ITERATED)) {
153 path = ppath;
154 } else {
155 path = (char *)def->name;
156 }
157
158 /* iteration, record and field */
159 if (def->iterationCount) {
160 int iterlen, n;
161 uint8_t head, num;
162 fru_regdef_t newdef;
163 nvlist_t **nv_elems;
164 char num_str[32];
165
166 iterlen = (def->payloadLen - NUM_ITER_BYTES) /
167 def->iterationCount;
168
169 /*
170 * make a new element definition to describe the components of
171 * the iteration.
172 */
173 (void) memcpy(&newdef, def, sizeof (newdef));
174 newdef.iterationCount = 0;
175 newdef.payloadLen = iterlen;
176
177 /* validate the content of the iteration control bytes */
178 if ((data[HEAD_ITER] >= def->iterationCount) ||
179 (data[NUM_ITER] > def->iterationCount) ||
180 (data[MAX_ITER] != def->iterationCount)) {
181 /* invalid. show all iterations */
182 head = 0;
183 num = def->iterationCount;
184 } else {
185 head = data[HEAD_ITER];
186 num = data[NUM_ITER];
187 }
188
189 nv_elems = (nvlist_t **)malloc(num * sizeof (nvlist_t *));
190 if (!nv_elems)
191 return;
192 for (i = head, n = 0, data += sizeof (uint32_t); n < num;
193 i = ((i + 1) % def->iterationCount), n++) {
194 if (nvlist_alloc(&nv_elems[n], NV_UNIQUE_NAME, 0) != 0)
195 return;
196 (void) snprintf(num_str, sizeof (num_str), "%d", n);
197 convert_element((data + i*iterlen), &newdef, num_str,
198 nv_elems[n], B_TRUE);
199 }
200 (void) nvlist_add_nvlist_array(nv, path, nv_elems, num);
201
202 } else if (def->dataType == FDTYPE_Record) {
203 const fru_regdef_t *component;
204 nvlist_t *nv_record;
205
206 if (!from_iter) {
207 if (nvlist_alloc(&nv_record, NV_UNIQUE_NAME, 0) != 0) {
208 return;
209 }
210 } else {
211 nv_record = nv;
212 }
213
214 for (i = 0; i < def->enumCount; i++,
215 data += component->payloadLen) {
216 component = fru_reg_lookup_def_by_name(
217 def->enumTable[i].text);
218 convert_element(data, component, "", nv_record,
219 B_FALSE);
220 }
221
222 (void) nvlist_add_nvlist(nv, path, nv_record);
223
224 } else {
225 convert_field(data, def, path, nv);
226 }
227 }
228
229
230 static fru_regdef_t *
231 alloc_unknown_fru_regdef(void)
232 {
233 fru_regdef_t *p;
234
235 p = malloc(sizeof (fru_regdef_t));
236 if (!p) {
237 return (NULL);
238 }
239 p->version = REGDEF_VERSION;
240 p->name = NULL;
241 p->tagType = -1;
242 p->tagDense = -1;
243 p->payloadLen = -1;
244 p->dataLength = -1;
245 p->dataType = FDTYPE_ByteArray;
246 p->dispType = FDISP_Hex;
247 p->purgeable = FRU_WHICH_UNDEFINED;
248 p->relocatable = FRU_WHICH_UNDEFINED;
249 p->enumCount = 0;
250 p-> enumTable = NULL;
251 p->iterationCount = 0;
252 p->iterationType = FRU_NOT_ITERATED;
253 p->exampleString = NULL;
254
255 return (p);
256 }
257
258 static int
259 convert_packet(fru_tag_t *tag, uint8_t *payload, size_t length, void *args)
260 {
261 int tag_type;
262 size_t payload_length;
263 const fru_regdef_t *def;
264 nvlist_t *nv = (nvlist_t *)args;
265 char tagname[sizeof ("?_0123456789_0123456789")];
266 tag_type = get_tag_type(tag);
267 payload_length = 0;
268
269 /* check for unrecognized tag */
270 if ((tag_type == -1) ||
271 ((payload_length = get_payload_length(tag)) != length)) {
272 fru_regdef_t *unknown;
273
274 unknown = alloc_unknown_fru_regdef();
275 unknown->payloadLen = length;
276 unknown->dataLength = unknown->payloadLen;
277
278 if (tag_type == -1) {
279 (void) snprintf(tagname, sizeof (tagname),
280 "INVALID");
281 } else {
282 (void) snprintf(tagname, sizeof (tagname),
283 "%s_%u_%u_%u", get_tagtype_str(tag_type),
284 get_tag_dense(tag), payload_length, length);
285 }
286 unknown->name = tagname;
287 convert_element(payload, unknown, "", nv, B_FALSE);
288 free(unknown);
289
290 } else if ((def = fru_reg_lookup_def_by_tag(*tag)) == NULL) {
291 fru_regdef_t *unknown;
292
293 unknown = alloc_unknown_fru_regdef();
294 unknown->payloadLen = length;
295 unknown->dataLength = unknown->payloadLen;
296
297 (void) snprintf(tagname, sizeof (tagname), "%s_%u_%u",
298 get_tagtype_str(tag_type),
299 unknown->tagDense, payload_length);
300
301 unknown->name = tagname;
302 convert_element(payload, unknown, "", nv, B_FALSE);
303 free(unknown);
304
305 } else {
306
307 convert_element(payload, def, "", nv, B_FALSE);
308
309 }
310
311 return (FRU_SUCCESS);
312 }
313
314
315 static int
316 convert_packets_in_segment(fru_seghdl_t segment, void *args)
317 {
318 char *name;
319 int ret;
320 nvlist_t *nv = (nvlist_t *)args;
321 nvlist_t *nv_segment;
322
323 ret = fru_get_segment_name(segment, &name);
324 if (ret != FRU_SUCCESS) {
325 return (ret);
326 }
327
328 /* create a new nvlist for each segment */
329 ret = nvlist_alloc(&nv_segment, NV_UNIQUE_NAME, 0);
330 if (ret) {
331 free(name);
332 return (FRU_FAILURE);
333 }
334
335 /* convert the segment to an nvlist */
336 ret = fru_for_each_packet(segment, convert_packet, nv_segment);
337 if (ret != FRU_SUCCESS) {
338 nvlist_free(nv_segment);
339 free(name);
340 return (ret);
341 }
342
343 /* add the nvlist for this segment */
344 (void) nvlist_add_nvlist(nv, name, nv_segment);
345
346 free(name);
347
348 return (FRU_SUCCESS);
349 }
350
351
352 static int
353 convert_fru(fru_nodehdl_t hdl, nvlist_t **nvlist)
354 {
355 int err;
356 nvlist_t *nv;
357 fru_node_t fru_type;
358
359 if (fru_get_node_type(hdl, &fru_type) != FRU_SUCCESS) {
360 return (-1);
361 }
362
363 if (fru_type != FRU_NODE_CONTAINER) {
364 return (-1);
365 }
366
367 err = nvlist_alloc(&nv, NV_UNIQUE_NAME, 0);
368 if (err) {
369 return (err);
370 }
371
372 if (fru_for_each_segment(hdl, convert_packets_in_segment, nv) !=
373 FRU_SUCCESS) {
374 nvlist_free(nv);
375 return (-1);
376 }
377
378 *nvlist = nv;
379
380 return (0);
381 }
382
383
384 int
385 rawfru_to_nvlist(uint8_t *buffer, size_t bufsize, char *cont_type,
386 nvlist_t **nvlist)
387 {
388 fru_errno_t fru_err;
389 fru_nodehdl_t hdl;
390 int err;
391
392 (void) pthread_mutex_lock(&gLock);
393 fru_err = fru_open_data_source("raw", buffer, bufsize, cont_type,
394 NULL);
395 if (fru_err != FRU_SUCCESS) {
396 (void) pthread_mutex_unlock(&gLock);
397 return (-1);
398 }
399 fru_err = fru_get_root(&hdl);
400 if (fru_err != FRU_SUCCESS) {
401 (void) pthread_mutex_unlock(&gLock);
402 return (-1);
403 }
404
405 err = convert_fru(hdl, nvlist);
406
407 (void) fru_close_data_source();
408
409 (void) pthread_mutex_unlock(&gLock);
410
411 return (err);
412 }