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 2015 OmniTI Computer Consulting, Inc. All rights reserved.
24 * Copyright 2018 Joyent, Inc.
25 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
26 * Use is subject to license terms.
27 */
28
29 #include <sys/smbios_impl.h>
30
31 static const uint_t _smb_hashlen = 64; /* hash length (must be Pof2) */
32 static const char _smb_emptystr[] = ""; /* empty string to return */
33 int _smb_debug = 0; /* default debug mode */
34
35 /*
36 * Strip out identification information for you privacy weenies. This is quite
37 * simple using our smbios_info_common() abstraction: we just locate any serial
38 * numbers and asset tags for each record, and then zero out those strings.
39 * Then we must handle two special cases: SMB_TYPE_SYSTEM holds a 16-byte UUID
40 * and SMB_TYPE_BATTERY stores a Smart Battery Data Spec 16-bit serial number.
41 * We use a literal '0' rather than '\0' for zeroing strings because \0\0 in
42 * the SMBIOS string table has a special meaning (denotes end-of-record).
43 */
44 static void
smb_strip(smbios_hdl_t * shp)45 smb_strip(smbios_hdl_t *shp)
46 {
47 uint_t i;
48
49 for (i = 0; i < shp->sh_nstructs; i++) {
50 const smb_header_t *hp = shp->sh_structs[i].smbst_hdr;
51 smbios_info_t info;
52 char *p;
53
54 if (hp->smbh_type == SMB_TYPE_SYSTEM &&
55 hp->smbh_len >= offsetof(smb_system_t, smbsi_wakeup)) {
56 smb_system_t *sp = (smb_system_t *)(uintptr_t)hp;
57 bzero(sp->smbsi_uuid, sizeof (sp->smbsi_uuid));
58 }
59
60 if (hp->smbh_type == SMB_TYPE_BATTERY &&
61 hp->smbh_len >= offsetof(smb_battery_t, smbbat_sdate)) {
62 smb_battery_t *bp = (smb_battery_t *)(uintptr_t)hp;
63 bp->smbbat_ssn = 0;
64 }
65
66 if (smbios_info_common(shp, hp->smbh_hdl, &info) != SMB_ERR) {
67 for (p = (char *)info.smbi_serial; *p != '\0'; p++)
68 *p = '0';
69 for (p = (char *)info.smbi_asset; *p != '\0'; p++)
70 *p = '0';
71 }
72 }
73 }
74
75 static int
smbios_bufopen_21(smbios_hdl_t * shp,const smbios_21_entry_t * ep,size_t len,int flags)76 smbios_bufopen_21(smbios_hdl_t *shp, const smbios_21_entry_t *ep, size_t len,
77 int flags)
78 {
79 if (strncmp(ep->smbe_eanchor, SMB_ENTRY_EANCHOR, SMB_ENTRY_EANCHORLEN))
80 return (ESMB_HEADER);
81
82 if (strncmp(ep->smbe_ianchor, SMB_ENTRY_IANCHOR, SMB_ENTRY_IANCHORLEN))
83 return (ESMB_HEADER);
84
85 smb_dprintf(shp, "opening SMBIOS version %u.%u bcdrev 0x%x\n",
86 ep->smbe_major, ep->smbe_minor, ep->smbe_bcdrev);
87
88 if (!(flags & SMB_O_NOVERS)) {
89 if (ep->smbe_major > SMB_MAJOR(SMB_VERSION))
90 return (ESMB_NEW);
91
92 if (ep->smbe_major < SMB_MAJOR(SMB_VERSION_23) || (
93 ep->smbe_major == SMB_MAJOR(SMB_VERSION_23) &&
94 ep->smbe_minor < SMB_MINOR(SMB_VERSION_23)))
95 return (ESMB_OLD);
96 }
97
98 if (len < sizeof (smb_header_t) ||
99 ep->smbe_stlen < sizeof (smb_header_t) || len < ep->smbe_stlen)
100 return (ESMB_SHORT);
101
102 if (!(flags & SMB_O_NOCKSUM)) {
103 uint8_t esum = 0, isum = 0;
104 const uchar_t *p, *q;
105 q = (uchar_t *)ep;
106
107 for (p = q; p < q + ep->smbe_elen; p++)
108 esum += *p;
109
110 for (p = (uchar_t *)ep->smbe_ianchor; p < q + sizeof (*ep); p++)
111 isum += *p;
112
113 if (esum != 0 || isum != 0) {
114 smb_dprintf(shp, "bad cksum: e=%x i=%x\n", esum, isum);
115 return (ESMB_CKSUM);
116 }
117 }
118
119 /*
120 * Copy the entry point into our handle. The underlying entry point
121 * may be larger than our structure definition, so reset smbe_elen
122 * to our internal size and recompute good checksums for our copy.
123 */
124 shp->sh_ent_type = SMBIOS_ENTRY_POINT_21;
125 bcopy(ep, &shp->sh_ent, sizeof (smbios_entry_t));
126 shp->sh_ent.ep21.smbe_elen = sizeof (smbios_entry_t);
127 smbios_checksum(shp, &shp->sh_ent);
128
129 shp->sh_ent_stnum = ep->smbe_stnum;
130 shp->sh_smbvers = SMB_MAJMIN(ep->smbe_major, ep->smbe_minor);
131 return (0);
132 }
133
134 static int
smbios_bufopen_30(smbios_hdl_t * shp,const smbios_30_entry_t * ep,size_t len,int flags)135 smbios_bufopen_30(smbios_hdl_t *shp, const smbios_30_entry_t *ep, size_t len,
136 int flags)
137 {
138 if (strncmp(ep->smbe_eanchor, SMB3_ENTRY_EANCHOR,
139 SMB3_ENTRY_EANCHORLEN))
140 return (ESMB_HEADER);
141
142 smb_dprintf(shp, "opening SMBIOS version %u.%u\n",
143 ep->smbe_major, ep->smbe_minor);
144
145 if (!(flags & SMB_O_NOVERS)) {
146 if (ep->smbe_major > SMB_MAJOR(SMB_VERSION))
147 return (ESMB_NEW);
148
149 if (ep->smbe_major < SMB_MAJOR(SMB_VERSION_23) || (
150 ep->smbe_major == SMB_MAJOR(SMB_VERSION_23) &&
151 ep->smbe_minor < SMB_MINOR(SMB_VERSION_23)))
152 return (ESMB_OLD);
153 }
154
155 if (len < sizeof (smb_header_t) ||
156 ep->smbe_stlen < sizeof (smb_header_t) || len < ep->smbe_stlen)
157 return (ESMB_SHORT);
158
159 if (!(flags & SMB_O_NOCKSUM)) {
160 uint8_t esum = 0;
161 const uchar_t *p, *q;
162 q = (uchar_t *)ep;
163
164 for (p = q; p < q + ep->smbe_elen; p++)
165 esum += *p;
166
167 if (esum != 0) {
168 smb_dprintf(shp, "bad cksum: e=%x\n", esum);
169 return (ESMB_CKSUM);
170 }
171 }
172
173 /*
174 * Copy the entry point into our handle. The underlying entry point
175 * may be larger than our structure definition, so reset smbe_elen
176 * to our internal size and recompute good checksums for our copy.
177 */
178 shp->sh_ent_type = SMBIOS_ENTRY_POINT_30;
179 bcopy(ep, &shp->sh_ent, sizeof (smbios_entry_t));
180 shp->sh_ent.ep30.smbe_elen = sizeof (smbios_entry_t);
181 smbios_checksum(shp, &shp->sh_ent);
182
183 shp->sh_smbvers = SMB_MAJMIN(ep->smbe_major, ep->smbe_minor);
184
185 return (0);
186 }
187
188 static uint_t
smbios_table_nentries(const char * smbe_staddr,uint32_t smbe_stlen)189 smbios_table_nentries(const char *smbe_staddr, uint32_t smbe_stlen)
190 {
191 uint_t i = 0;
192 char *dmi;
193 smb_header_t *hdr;
194
195 if (smbe_staddr == NULL)
196 return (i);
197
198 for (dmi = (char *)smbe_staddr; dmi < smbe_staddr + smbe_stlen; i++) {
199 hdr = (smb_header_t *)dmi;
200 dmi += hdr->smbh_len;
201 /*
202 * Search for the end of the string area.
203 */
204 while (dmi + 1 < smbe_staddr + smbe_stlen &&
205 dmi[0] != '\0' && dmi[1] != '\0') {
206 dmi++;
207 }
208 dmi += 2;
209 }
210 return (i);
211 }
212
213 smbios_hdl_t *
smbios_bufopen(const smbios_entry_t * ep,const void * buf,size_t len,int version,int flags,int * errp)214 smbios_bufopen(const smbios_entry_t *ep, const void *buf, size_t len,
215 int version, int flags, int *errp)
216 {
217 smbios_hdl_t *shp = smb_zalloc(sizeof (smbios_hdl_t));
218 const smb_header_t *hp, *nhp;
219 const uchar_t *p, *q, *s;
220 uint_t i, h;
221 int err;
222
223 switch (version) {
224 case SMB_VERSION_23:
225 case SMB_VERSION_24:
226 case SMB_VERSION_25:
227 case SMB_VERSION_26:
228 case SMB_VERSION_27:
229 case SMB_VERSION_28:
230 case SMB_VERSION_30:
231 case SMB_VERSION_31:
232 case SMB_VERSION_32:
233 break;
234 default:
235 return (smb_open_error(shp, errp, ESMB_VERSION));
236 }
237
238 if (ep == NULL || buf == NULL || len == 0 || (flags & ~SMB_O_MASK))
239 return (smb_open_error(shp, errp, ESMB_INVAL));
240
241 if (shp == NULL)
242 return (smb_open_error(shp, errp, ESMB_NOMEM));
243
244 if (_smb_debug)
245 shp->sh_flags |= SMB_FL_DEBUG;
246
247 err = smbios_bufopen_21(shp, &ep->ep21, len, flags);
248 if (err != 0) {
249 err = smbios_bufopen_30(shp, &ep->ep30, len, flags);
250 if (err != 0)
251 return (smb_open_error(shp, errp, err));
252 shp->sh_ent_stnum =
253 smbios_table_nentries(buf, ep->ep30.smbe_stlen);
254 }
255
256 shp->sh_buf = buf;
257 shp->sh_buflen = len;
258 shp->sh_structs = smb_alloc(sizeof (smb_struct_t) * shp->sh_ent_stnum);
259 shp->sh_nstructs = 0;
260 shp->sh_hashlen = _smb_hashlen;
261 shp->sh_hash = smb_zalloc(sizeof (smb_struct_t *) * shp->sh_hashlen);
262 shp->sh_libvers = version;
263
264 if (shp->sh_structs == NULL || shp->sh_hash == NULL)
265 return (smb_open_error(shp, errp, ESMB_NOMEM));
266
267 hp = shp->sh_buf;
268 switch (shp->sh_ent_type) {
269 case SMBIOS_ENTRY_POINT_21:
270 q = (const uchar_t *)buf + MIN(ep->ep21.smbe_stlen, len);
271 break;
272 case SMBIOS_ENTRY_POINT_30:
273 q = (const uchar_t *)buf + MIN(ep->ep30.smbe_stlen, len);
274 break;
275 default:
276 return (smb_open_error(shp, errp, ESMB_VERSION));
277 }
278
279 for (i = 0; i < shp->sh_ent_stnum; i++, hp = nhp) {
280 smb_struct_t *stp = &shp->sh_structs[i];
281 uint_t n = 0;
282
283 if ((const uchar_t *)hp + sizeof (smb_header_t) > q) {
284 shp->sh_flags |= SMB_FL_TRUNC;
285 break;
286 }
287
288 smb_dprintf(shp, "struct [%u] type %u len %u hdl %u at %p\n",
289 i, hp->smbh_type, hp->smbh_len, hp->smbh_hdl, (void *)hp);
290
291 if (hp->smbh_type == SMB_TYPE_EOT)
292 break; /* ignore any entries beyond end-of-table */
293
294 if ((const uchar_t *)hp + hp->smbh_len > q - 2) {
295 shp->sh_flags |= SMB_FL_TRUNC;
296 break;
297 }
298
299 h = hp->smbh_hdl & (shp->sh_hashlen - 1);
300 p = s = (const uchar_t *)hp + hp->smbh_len;
301
302 while (p <= q - 2 && (p[0] != '\0' || p[1] != '\0')) {
303 if (*p++ == '\0')
304 n++; /* count strings until \0\0 delimiter */
305 }
306
307 if (p > q - 2) {
308 shp->sh_flags |= SMB_FL_TRUNC;
309 break;
310 }
311
312 if (p > s)
313 n++; /* add one for final string in string table */
314
315 stp->smbst_hdr = hp;
316 stp->smbst_str = s;
317 stp->smbst_end = p;
318 stp->smbst_next = shp->sh_hash[h];
319 stp->smbst_strtab = smb_alloc(sizeof (uint16_t) * n);
320 stp->smbst_strtablen = n;
321
322 if (n != 0 && stp->smbst_strtab == NULL)
323 return (smb_open_error(shp, errp, ESMB_NOMEM));
324
325 shp->sh_hash[h] = stp;
326 nhp = (void *)(p + 2);
327 shp->sh_nstructs++;
328
329 for (n = 0, p = s; n < stp->smbst_strtablen; p++) {
330 if (*p == '\0') {
331 stp->smbst_strtab[n++] =
332 (uint16_t)(s - stp->smbst_str);
333 s = p + 1;
334 }
335 }
336 }
337
338 /* error out if we couldn't find any complete entries in the table */
339 if ((shp->sh_flags & SMB_FL_TRUNC) && i == 0)
340 return (smb_open_error(shp, errp, ESMB_CORRUPT));
341
342 if (flags & SMB_O_ZIDS)
343 smb_strip(shp);
344
345 return (shp);
346 }
347
348 void
smbios_close(smbios_hdl_t * shp)349 smbios_close(smbios_hdl_t *shp)
350 {
351 uint_t i;
352
353 for (i = 0; i < shp->sh_nstructs; i++) {
354 smb_free(shp->sh_structs[i].smbst_strtab,
355 sizeof (uint16_t) * shp->sh_structs[i].smbst_strtablen);
356 }
357
358 smb_free(shp->sh_structs, sizeof (smb_struct_t) * shp->sh_ent_stnum);
359 smb_free(shp->sh_hash, sizeof (smb_struct_t *) * shp->sh_hashlen);
360
361 if (shp->sh_flags & SMB_FL_BUFALLOC)
362 smb_free((void *)shp->sh_buf, shp->sh_buflen);
363
364 smb_free(shp, sizeof (smbios_hdl_t));
365 }
366
367 /*
368 * Recompute the values of the entry point checksums based upon the content
369 * of the specified SMBIOS entry point. We don't need 'shp' but require it
370 * anyway in case future versioning requires variations in the algorithm.
371 */
372 /*ARGSUSED*/
373 void
smbios_checksum(smbios_hdl_t * shp,smbios_entry_t * ep)374 smbios_checksum(smbios_hdl_t *shp, smbios_entry_t *ep)
375 {
376 uchar_t *p, *q = (uchar_t *)ep;
377 uint8_t esum = 0, isum = 0;
378
379 switch (shp->sh_ent_type) {
380 case SMBIOS_ENTRY_POINT_21:
381 ep->ep21.smbe_ecksum = ep->ep21.smbe_icksum = 0;
382
383 for (p = (uchar_t *)ep->ep21.smbe_ianchor;
384 p < q + sizeof (*ep); p++) {
385 isum += *p;
386 }
387
388 ep->ep21.smbe_icksum = -isum;
389
390 for (p = q; p < q + ep->ep21.smbe_elen; p++)
391 esum += *p;
392
393 ep->ep21.smbe_ecksum = -esum;
394 break;
395 case SMBIOS_ENTRY_POINT_30:
396 ep->ep30.smbe_ecksum = 0;
397 for (p = q; p < q + ep->ep30.smbe_elen; p++)
398 esum += *p;
399
400 ep->ep30.smbe_ecksum = -esum;
401 break;
402 default:
403 break;
404 }
405 }
406
407 const void *
smbios_buf(smbios_hdl_t * shp)408 smbios_buf(smbios_hdl_t *shp)
409 {
410 return (shp->sh_buf);
411 }
412
413 size_t
smbios_buflen(smbios_hdl_t * shp)414 smbios_buflen(smbios_hdl_t *shp)
415 {
416 return (shp->sh_buflen);
417 }
418
419 static smbios_struct_t *
smb_export(const smb_struct_t * stp,smbios_struct_t * sp)420 smb_export(const smb_struct_t *stp, smbios_struct_t *sp)
421 {
422 const smb_header_t *hdr = stp->smbst_hdr;
423
424 sp->smbstr_id = hdr->smbh_hdl;
425 sp->smbstr_type = hdr->smbh_type;
426 sp->smbstr_data = hdr;
427 sp->smbstr_size = (size_t)(stp->smbst_end - (uchar_t *)hdr);
428
429 return (sp);
430 }
431
432 int
smbios_lookup_id(smbios_hdl_t * shp,id_t id,smbios_struct_t * sp)433 smbios_lookup_id(smbios_hdl_t *shp, id_t id, smbios_struct_t *sp)
434 {
435 const smb_struct_t *stp = smb_lookup_id(shp, id);
436
437 if (stp == NULL)
438 return (-1); /* errno is set for us */
439
440 if (sp != NULL)
441 (void) smb_export(stp, sp);
442
443 return (0);
444 }
445
446 int
smbios_lookup_type(smbios_hdl_t * shp,uint_t type,smbios_struct_t * sp)447 smbios_lookup_type(smbios_hdl_t *shp, uint_t type, smbios_struct_t *sp)
448 {
449 const smb_struct_t *stp = smb_lookup_type(shp, type);
450
451 if (stp == NULL)
452 return (-1); /* errno is set for us */
453
454 if (sp != NULL)
455 (void) smb_export(stp, sp);
456
457 return (0);
458 }
459
460 int
smbios_iter(smbios_hdl_t * shp,smbios_struct_f * func,void * data)461 smbios_iter(smbios_hdl_t *shp, smbios_struct_f *func, void *data)
462 {
463 const smb_struct_t *sp = shp->sh_structs;
464 smbios_struct_t s;
465 int i, rv = 0;
466
467 for (i = 0; i < shp->sh_nstructs; i++, sp++) {
468 if (sp->smbst_hdr->smbh_type != SMB_TYPE_INACTIVE &&
469 (rv = func(shp, smb_export(sp, &s), data)) != 0)
470 break;
471 }
472
473 return (rv);
474 }
475
476 const smb_struct_t *
smb_lookup_type(smbios_hdl_t * shp,uint_t type)477 smb_lookup_type(smbios_hdl_t *shp, uint_t type)
478 {
479 uint_t i;
480
481 for (i = 0; i < shp->sh_nstructs; i++) {
482 if (shp->sh_structs[i].smbst_hdr->smbh_type == type)
483 return (&shp->sh_structs[i]);
484 }
485
486 (void) smb_set_errno(shp, ESMB_NOENT);
487 return (NULL);
488 }
489
490 const smb_struct_t *
smb_lookup_id(smbios_hdl_t * shp,uint_t id)491 smb_lookup_id(smbios_hdl_t *shp, uint_t id)
492 {
493 const smb_struct_t *stp = shp->sh_hash[id & (shp->sh_hashlen - 1)];
494
495 switch (id) {
496 case SMB_ID_NOTSUP:
497 (void) smb_set_errno(shp, ESMB_NOTSUP);
498 return (NULL);
499 case SMB_ID_NONE:
500 (void) smb_set_errno(shp, ESMB_NOENT);
501 return (NULL);
502 }
503
504 for (; stp != NULL; stp = stp->smbst_next) {
505 if (stp->smbst_hdr->smbh_hdl == id)
506 break;
507 }
508
509 if (stp == NULL)
510 (void) smb_set_errno(shp, ESMB_NOENT);
511
512 return (stp);
513 }
514
515 const char *
smb_strptr(const smb_struct_t * stp,uint_t i)516 smb_strptr(const smb_struct_t *stp, uint_t i)
517 {
518 if (i == 0 || i > stp->smbst_strtablen)
519 return (_smb_emptystr);
520 else
521 return ((char *)stp->smbst_str + stp->smbst_strtab[i - 1]);
522 }
523
524 int
smb_libgteq(smbios_hdl_t * shp,int version)525 smb_libgteq(smbios_hdl_t *shp, int version)
526 {
527 return (SMB_MAJOR(shp->sh_libvers) > SMB_MAJOR(version) || (
528 SMB_MAJOR(shp->sh_libvers) == SMB_MAJOR(version) &&
529 SMB_MINOR(shp->sh_libvers) >= SMB_MINOR(version)));
530 }
531
532 int
smb_gteq(smbios_hdl_t * shp,int version)533 smb_gteq(smbios_hdl_t *shp, int version)
534 {
535 return (SMB_MAJOR(shp->sh_smbvers) > SMB_MAJOR(version) || (
536 SMB_MAJOR(shp->sh_smbvers) == SMB_MAJOR(version) &&
537 SMB_MINOR(shp->sh_smbvers) >= SMB_MINOR(version)));
538 }
539
540 boolean_t
smbios_truncated(smbios_hdl_t * shp)541 smbios_truncated(smbios_hdl_t *shp)
542 {
543 return ((shp->sh_flags & SMB_FL_TRUNC) != 0);
544 }
545