usr/src/common/smbios/smb_open.c

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