xref: /illumos-gate/usr/src/common/smbios/smb_open.c (revision 90f7985f020eb82d06bd0d75396ff794105f7528) 
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