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 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 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 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 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 * 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 case SMB_VERSION_33: 234 case SMB_VERSION_34: 235 break; 236 default: 237 return (smb_open_error(shp, errp, ESMB_VERSION)); 238 } 239 240 if (ep == NULL || buf == NULL || len == 0 || (flags & ~SMB_O_MASK)) 241 return (smb_open_error(shp, errp, ESMB_INVAL)); 242 243 if (shp == NULL) 244 return (smb_open_error(shp, errp, ESMB_NOMEM)); 245 246 if (_smb_debug) 247 shp->sh_flags |= SMB_FL_DEBUG; 248 249 err = smbios_bufopen_21(shp, &ep->ep21, len, flags); 250 if (err != 0) { 251 err = smbios_bufopen_30(shp, &ep->ep30, len, flags); 252 if (err != 0) 253 return (smb_open_error(shp, errp, err)); 254 shp->sh_ent_stnum = 255 smbios_table_nentries(buf, ep->ep30.smbe_stlen); 256 } 257 258 shp->sh_buf = buf; 259 shp->sh_buflen = len; 260 shp->sh_structs = smb_alloc(sizeof (smb_struct_t) * shp->sh_ent_stnum); 261 shp->sh_nstructs = 0; 262 shp->sh_hashlen = _smb_hashlen; 263 shp->sh_hash = smb_zalloc(sizeof (smb_struct_t *) * shp->sh_hashlen); 264 shp->sh_libvers = version; 265 266 if (shp->sh_structs == NULL || shp->sh_hash == NULL) 267 return (smb_open_error(shp, errp, ESMB_NOMEM)); 268 269 hp = shp->sh_buf; 270 switch (shp->sh_ent_type) { 271 case SMBIOS_ENTRY_POINT_21: 272 q = (const uchar_t *)buf + MIN(ep->ep21.smbe_stlen, len); 273 break; 274 case SMBIOS_ENTRY_POINT_30: 275 q = (const uchar_t *)buf + MIN(ep->ep30.smbe_stlen, len); 276 break; 277 default: 278 return (smb_open_error(shp, errp, ESMB_VERSION)); 279 } 280 281 for (i = 0; i < shp->sh_ent_stnum; i++, hp = nhp) { 282 smb_struct_t *stp = &shp->sh_structs[i]; 283 uint_t n = 0; 284 285 if ((const uchar_t *)hp + sizeof (smb_header_t) > q) { 286 shp->sh_flags |= SMB_FL_TRUNC; 287 break; 288 } 289 290 smb_dprintf(shp, "struct [%u] type %u len %u hdl %u at %p\n", 291 i, hp->smbh_type, hp->smbh_len, hp->smbh_hdl, (void *)hp); 292 293 if (hp->smbh_type == SMB_TYPE_EOT) 294 break; /* ignore any entries beyond end-of-table */ 295 296 if ((const uchar_t *)hp + hp->smbh_len > q - 2) { 297 shp->sh_flags |= SMB_FL_TRUNC; 298 break; 299 } 300 301 h = hp->smbh_hdl & (shp->sh_hashlen - 1); 302 p = s = (const uchar_t *)hp + hp->smbh_len; 303 304 while (p <= q - 2 && (p[0] != '\0' || p[1] != '\0')) { 305 if (*p++ == '\0') 306 n++; /* count strings until \0\0 delimiter */ 307 } 308 309 if (p > q - 2) { 310 shp->sh_flags |= SMB_FL_TRUNC; 311 break; 312 } 313 314 if (p > s) 315 n++; /* add one for final string in string table */ 316 317 stp->smbst_hdr = hp; 318 stp->smbst_str = s; 319 stp->smbst_end = p; 320 stp->smbst_next = shp->sh_hash[h]; 321 stp->smbst_strtab = smb_alloc(sizeof (uint16_t) * n); 322 stp->smbst_strtablen = n; 323 324 if (n != 0 && stp->smbst_strtab == NULL) 325 return (smb_open_error(shp, errp, ESMB_NOMEM)); 326 327 shp->sh_hash[h] = stp; 328 nhp = (void *)(p + 2); 329 shp->sh_nstructs++; 330 331 for (n = 0, p = s; n < stp->smbst_strtablen; p++) { 332 if (*p == '\0') { 333 stp->smbst_strtab[n++] = 334 (uint16_t)(s - stp->smbst_str); 335 s = p + 1; 336 } 337 } 338 } 339 340 /* error out if we couldn't find any complete entries in the table */ 341 if ((shp->sh_flags & SMB_FL_TRUNC) && i == 0) 342 return (smb_open_error(shp, errp, ESMB_CORRUPT)); 343 344 if (flags & SMB_O_ZIDS) 345 smb_strip(shp); 346 347 return (shp); 348 } 349 350 void 351 smbios_close(smbios_hdl_t *shp) 352 { 353 uint_t i; 354 355 for (i = 0; i < shp->sh_nstructs; i++) { 356 smb_free(shp->sh_structs[i].smbst_strtab, 357 sizeof (uint16_t) * shp->sh_structs[i].smbst_strtablen); 358 } 359 360 smb_free(shp->sh_structs, sizeof (smb_struct_t) * shp->sh_ent_stnum); 361 smb_free(shp->sh_hash, sizeof (smb_struct_t *) * shp->sh_hashlen); 362 363 if (shp->sh_flags & SMB_FL_BUFALLOC) 364 smb_free((void *)shp->sh_buf, shp->sh_buflen); 365 366 smb_free(shp, sizeof (smbios_hdl_t)); 367 } 368 369 /* 370 * Recompute the values of the entry point checksums based upon the content 371 * of the specified SMBIOS entry point. We don't need 'shp' but require it 372 * anyway in case future versioning requires variations in the algorithm. 373 */ 374 /*ARGSUSED*/ 375 void 376 smbios_checksum(smbios_hdl_t *shp, smbios_entry_t *ep) 377 { 378 uchar_t *p, *q = (uchar_t *)ep; 379 uint8_t esum = 0, isum = 0; 380 381 switch (shp->sh_ent_type) { 382 case SMBIOS_ENTRY_POINT_21: 383 ep->ep21.smbe_ecksum = ep->ep21.smbe_icksum = 0; 384 385 for (p = (uchar_t *)ep->ep21.smbe_ianchor; 386 p < q + sizeof (*ep); p++) { 387 isum += *p; 388 } 389 390 ep->ep21.smbe_icksum = -isum; 391 392 for (p = q; p < q + ep->ep21.smbe_elen; p++) 393 esum += *p; 394 395 ep->ep21.smbe_ecksum = -esum; 396 break; 397 case SMBIOS_ENTRY_POINT_30: 398 ep->ep30.smbe_ecksum = 0; 399 for (p = q; p < q + ep->ep30.smbe_elen; p++) 400 esum += *p; 401 402 ep->ep30.smbe_ecksum = -esum; 403 break; 404 default: 405 break; 406 } 407 } 408 409 const void * 410 smbios_buf(smbios_hdl_t *shp) 411 { 412 return (shp->sh_buf); 413 } 414 415 size_t 416 smbios_buflen(smbios_hdl_t *shp) 417 { 418 return (shp->sh_buflen); 419 } 420 421 static smbios_struct_t * 422 smb_export(const smb_struct_t *stp, smbios_struct_t *sp) 423 { 424 const smb_header_t *hdr = stp->smbst_hdr; 425 426 sp->smbstr_id = hdr->smbh_hdl; 427 sp->smbstr_type = hdr->smbh_type; 428 sp->smbstr_data = hdr; 429 sp->smbstr_size = (size_t)(stp->smbst_end - (uchar_t *)hdr); 430 431 return (sp); 432 } 433 434 int 435 smbios_lookup_id(smbios_hdl_t *shp, id_t id, smbios_struct_t *sp) 436 { 437 const smb_struct_t *stp = smb_lookup_id(shp, id); 438 439 if (stp == NULL) 440 return (-1); /* errno is set for us */ 441 442 if (sp != NULL) 443 (void) smb_export(stp, sp); 444 445 return (0); 446 } 447 448 int 449 smbios_lookup_type(smbios_hdl_t *shp, uint_t type, smbios_struct_t *sp) 450 { 451 const smb_struct_t *stp = smb_lookup_type(shp, type); 452 453 if (stp == NULL) 454 return (-1); /* errno is set for us */ 455 456 if (sp != NULL) 457 (void) smb_export(stp, sp); 458 459 return (0); 460 } 461 462 int 463 smbios_iter(smbios_hdl_t *shp, smbios_struct_f *func, void *data) 464 { 465 const smb_struct_t *sp = shp->sh_structs; 466 smbios_struct_t s; 467 int i, rv = 0; 468 469 for (i = 0; i < shp->sh_nstructs; i++, sp++) { 470 if (sp->smbst_hdr->smbh_type != SMB_TYPE_INACTIVE && 471 (rv = func(shp, smb_export(sp, &s), data)) != 0) 472 break; 473 } 474 475 return (rv); 476 } 477 478 const smb_struct_t * 479 smb_lookup_type(smbios_hdl_t *shp, uint_t type) 480 { 481 uint_t i; 482 483 for (i = 0; i < shp->sh_nstructs; i++) { 484 if (shp->sh_structs[i].smbst_hdr->smbh_type == type) 485 return (&shp->sh_structs[i]); 486 } 487 488 (void) smb_set_errno(shp, ESMB_NOENT); 489 return (NULL); 490 } 491 492 const smb_struct_t * 493 smb_lookup_id(smbios_hdl_t *shp, uint_t id) 494 { 495 const smb_struct_t *stp = shp->sh_hash[id & (shp->sh_hashlen - 1)]; 496 497 switch (id) { 498 case SMB_ID_NOTSUP: 499 (void) smb_set_errno(shp, ESMB_NOTSUP); 500 return (NULL); 501 case SMB_ID_NONE: 502 (void) smb_set_errno(shp, ESMB_NOENT); 503 return (NULL); 504 } 505 506 for (; stp != NULL; stp = stp->smbst_next) { 507 if (stp->smbst_hdr->smbh_hdl == id) 508 break; 509 } 510 511 if (stp == NULL) 512 (void) smb_set_errno(shp, ESMB_NOENT); 513 514 return (stp); 515 } 516 517 const char * 518 smb_strptr(const smb_struct_t *stp, uint_t i) 519 { 520 if (i == 0 || i > stp->smbst_strtablen) 521 return (_smb_emptystr); 522 else 523 return ((char *)stp->smbst_str + stp->smbst_strtab[i - 1]); 524 } 525 526 int 527 smb_libgteq(smbios_hdl_t *shp, int version) 528 { 529 return (SMB_MAJOR(shp->sh_libvers) > SMB_MAJOR(version) || ( 530 SMB_MAJOR(shp->sh_libvers) == SMB_MAJOR(version) && 531 SMB_MINOR(shp->sh_libvers) >= SMB_MINOR(version))); 532 } 533 534 int 535 smb_gteq(smbios_hdl_t *shp, int version) 536 { 537 return (SMB_MAJOR(shp->sh_smbvers) > SMB_MAJOR(version) || ( 538 SMB_MAJOR(shp->sh_smbvers) == SMB_MAJOR(version) && 539 SMB_MINOR(shp->sh_smbvers) >= SMB_MINOR(version))); 540 } 541 542 boolean_t 543 smbios_truncated(smbios_hdl_t *shp) 544 { 545 return ((shp->sh_flags & SMB_FL_TRUNC) != 0); 546 } 547