1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67#include <stdio.h>
68#include <stdlib.h>
69#include <string.h>
70#include <fcntl.h>
71#include <sys/ioctl.h>
72#include <unistd.h>
73#include <errno.h>
74#include <stdint.h>
75#include <stdbool.h>
76#include <bits/wordsize.h>
77#include <linux/mei.h>
78
79
80
81
82
83#define mei_msg(_me, fmt, ARGS...) do { \
84 if (_me->verbose) \
85 fprintf(stderr, fmt, ##ARGS); \
86} while (0)
87
88#define mei_err(_me, fmt, ARGS...) do { \
89 fprintf(stderr, "Error: " fmt, ##ARGS); \
90} while (0)
91
92struct mei {
93 uuid_le guid;
94 bool initialized;
95 bool verbose;
96 unsigned int buf_size;
97 unsigned char prot_ver;
98 int fd;
99};
100
101static void mei_deinit(struct mei *cl)
102{
103 if (cl->fd != -1)
104 close(cl->fd);
105 cl->fd = -1;
106 cl->buf_size = 0;
107 cl->prot_ver = 0;
108 cl->initialized = false;
109}
110
111static bool mei_init(struct mei *me, const uuid_le *guid,
112 unsigned char req_protocol_version, bool verbose)
113{
114 int result;
115 struct mei_client *cl;
116 struct mei_connect_client_data data;
117
118 mei_deinit(me);
119
120 me->verbose = verbose;
121
122 me->fd = open("/dev/mei", O_RDWR);
123 if (me->fd == -1) {
124 mei_err(me, "Cannot establish a handle to the Intel MEI driver\n");
125 goto err;
126 }
127 memcpy(&me->guid, guid, sizeof(*guid));
128 memset(&data, 0, sizeof(data));
129 me->initialized = true;
130
131 memcpy(&data.in_client_uuid, &me->guid, sizeof(me->guid));
132 result = ioctl(me->fd, IOCTL_MEI_CONNECT_CLIENT, &data);
133 if (result) {
134 mei_err(me, "IOCTL_MEI_CONNECT_CLIENT receive message. err=%d\n", result);
135 goto err;
136 }
137 cl = &data.out_client_properties;
138 mei_msg(me, "max_message_length %d\n", cl->max_msg_length);
139 mei_msg(me, "protocol_version %d\n", cl->protocol_version);
140
141 if ((req_protocol_version > 0) &&
142 (cl->protocol_version != req_protocol_version)) {
143 mei_err(me, "Intel MEI protocol version not supported\n");
144 goto err;
145 }
146
147 me->buf_size = cl->max_msg_length;
148 me->prot_ver = cl->protocol_version;
149
150 return true;
151err:
152 mei_deinit(me);
153 return false;
154}
155
156static ssize_t mei_recv_msg(struct mei *me, unsigned char *buffer,
157 ssize_t len, unsigned long timeout)
158{
159 ssize_t rc;
160
161 mei_msg(me, "call read length = %zd\n", len);
162
163 rc = read(me->fd, buffer, len);
164 if (rc < 0) {
165 mei_err(me, "read failed with status %zd %s\n",
166 rc, strerror(errno));
167 mei_deinit(me);
168 } else {
169 mei_msg(me, "read succeeded with result %zd\n", rc);
170 }
171 return rc;
172}
173
174static ssize_t mei_send_msg(struct mei *me, const unsigned char *buffer,
175 ssize_t len, unsigned long timeout)
176{
177 struct timeval tv;
178 ssize_t written;
179 ssize_t rc;
180 fd_set set;
181
182 tv.tv_sec = timeout / 1000;
183 tv.tv_usec = (timeout % 1000) * 1000000;
184
185 mei_msg(me, "call write length = %zd\n", len);
186
187 written = write(me->fd, buffer, len);
188 if (written < 0) {
189 rc = -errno;
190 mei_err(me, "write failed with status %zd %s\n",
191 written, strerror(errno));
192 goto out;
193 }
194
195 FD_ZERO(&set);
196 FD_SET(me->fd, &set);
197 rc = select(me->fd + 1 , &set, NULL, NULL, &tv);
198 if (rc > 0 && FD_ISSET(me->fd, &set)) {
199 mei_msg(me, "write success\n");
200 } else if (rc == 0) {
201 mei_err(me, "write failed on timeout with status\n");
202 goto out;
203 } else {
204 mei_err(me, "write failed on select with status %zd\n", rc);
205 goto out;
206 }
207
208 rc = written;
209out:
210 if (rc < 0)
211 mei_deinit(me);
212
213 return rc;
214}
215
216
217
218
219
220#define AMT_MAJOR_VERSION 1
221#define AMT_MINOR_VERSION 1
222
223#define AMT_STATUS_SUCCESS 0x0
224#define AMT_STATUS_INTERNAL_ERROR 0x1
225#define AMT_STATUS_NOT_READY 0x2
226#define AMT_STATUS_INVALID_AMT_MODE 0x3
227#define AMT_STATUS_INVALID_MESSAGE_LENGTH 0x4
228
229#define AMT_STATUS_HOST_IF_EMPTY_RESPONSE 0x4000
230#define AMT_STATUS_SDK_RESOURCES 0x1004
231
232
233#define AMT_BIOS_VERSION_LEN 65
234#define AMT_VERSIONS_NUMBER 50
235#define AMT_UNICODE_STRING_LEN 20
236
237struct amt_unicode_string {
238 uint16_t length;
239 char string[AMT_UNICODE_STRING_LEN];
240} __attribute__((packed));
241
242struct amt_version_type {
243 struct amt_unicode_string description;
244 struct amt_unicode_string version;
245} __attribute__((packed));
246
247struct amt_version {
248 uint8_t major;
249 uint8_t minor;
250} __attribute__((packed));
251
252struct amt_code_versions {
253 uint8_t bios[AMT_BIOS_VERSION_LEN];
254 uint32_t count;
255 struct amt_version_type versions[AMT_VERSIONS_NUMBER];
256} __attribute__((packed));
257
258
259
260
261
262struct amt_host_if_msg_header {
263 struct amt_version version;
264 uint16_t _reserved;
265 uint32_t command;
266 uint32_t length;
267} __attribute__((packed));
268
269struct amt_host_if_resp_header {
270 struct amt_host_if_msg_header header;
271 uint32_t status;
272 unsigned char data[0];
273} __attribute__((packed));
274
275const uuid_le MEI_IAMTHIF = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d, \
276 0xac, 0xa8, 0x46, 0xe0, 0xff, 0x65, 0x81, 0x4c);
277
278#define AMT_HOST_IF_CODE_VERSIONS_REQUEST 0x0400001A
279#define AMT_HOST_IF_CODE_VERSIONS_RESPONSE 0x0480001A
280
281const struct amt_host_if_msg_header CODE_VERSION_REQ = {
282 .version = {AMT_MAJOR_VERSION, AMT_MINOR_VERSION},
283 ._reserved = 0,
284 .command = AMT_HOST_IF_CODE_VERSIONS_REQUEST,
285 .length = 0
286};
287
288
289struct amt_host_if {
290 struct mei mei_cl;
291 unsigned long send_timeout;
292 bool initialized;
293};
294
295
296static bool amt_host_if_init(struct amt_host_if *acmd,
297 unsigned long send_timeout, bool verbose)
298{
299 acmd->send_timeout = (send_timeout) ? send_timeout : 20000;
300 acmd->initialized = mei_init(&acmd->mei_cl, &MEI_IAMTHIF, 0, verbose);
301 return acmd->initialized;
302}
303
304static void amt_host_if_deinit(struct amt_host_if *acmd)
305{
306 mei_deinit(&acmd->mei_cl);
307 acmd->initialized = false;
308}
309
310static uint32_t amt_verify_code_versions(const struct amt_host_if_resp_header *resp)
311{
312 uint32_t status = AMT_STATUS_SUCCESS;
313 struct amt_code_versions *code_ver;
314 size_t code_ver_len;
315 uint32_t ver_type_cnt;
316 uint32_t len;
317 uint32_t i;
318
319 code_ver = (struct amt_code_versions *)resp->data;
320
321 code_ver_len = resp->header.length - sizeof(uint32_t);
322 ver_type_cnt = code_ver_len -
323 sizeof(code_ver->bios) -
324 sizeof(code_ver->count);
325 if (code_ver->count != ver_type_cnt / sizeof(struct amt_version_type)) {
326 status = AMT_STATUS_INTERNAL_ERROR;
327 goto out;
328 }
329
330 for (i = 0; i < code_ver->count; i++) {
331 len = code_ver->versions[i].description.length;
332
333 if (len > AMT_UNICODE_STRING_LEN) {
334 status = AMT_STATUS_INTERNAL_ERROR;
335 goto out;
336 }
337
338 len = code_ver->versions[i].version.length;
339 if (code_ver->versions[i].version.string[len] != '\0' ||
340 len != strlen(code_ver->versions[i].version.string)) {
341 status = AMT_STATUS_INTERNAL_ERROR;
342 goto out;
343 }
344 }
345out:
346 return status;
347}
348
349static uint32_t amt_verify_response_header(uint32_t command,
350 const struct amt_host_if_msg_header *resp_hdr,
351 uint32_t response_size)
352{
353 if (response_size < sizeof(struct amt_host_if_resp_header)) {
354 return AMT_STATUS_INTERNAL_ERROR;
355 } else if (response_size != (resp_hdr->length +
356 sizeof(struct amt_host_if_msg_header))) {
357 return AMT_STATUS_INTERNAL_ERROR;
358 } else if (resp_hdr->command != command) {
359 return AMT_STATUS_INTERNAL_ERROR;
360 } else if (resp_hdr->_reserved != 0) {
361 return AMT_STATUS_INTERNAL_ERROR;
362 } else if (resp_hdr->version.major != AMT_MAJOR_VERSION ||
363 resp_hdr->version.minor < AMT_MINOR_VERSION) {
364 return AMT_STATUS_INTERNAL_ERROR;
365 }
366 return AMT_STATUS_SUCCESS;
367}
368
369static uint32_t amt_host_if_call(struct amt_host_if *acmd,
370 const unsigned char *command, ssize_t command_sz,
371 uint8_t **read_buf, uint32_t rcmd,
372 unsigned int expected_sz)
373{
374 uint32_t in_buf_sz;
375 uint32_t out_buf_sz;
376 ssize_t written;
377 uint32_t status;
378 struct amt_host_if_resp_header *msg_hdr;
379
380 in_buf_sz = acmd->mei_cl.buf_size;
381 *read_buf = (uint8_t *)malloc(sizeof(uint8_t) * in_buf_sz);
382 if (*read_buf == NULL)
383 return AMT_STATUS_SDK_RESOURCES;
384 memset(*read_buf, 0, in_buf_sz);
385 msg_hdr = (struct amt_host_if_resp_header *)*read_buf;
386
387 written = mei_send_msg(&acmd->mei_cl,
388 command, command_sz, acmd->send_timeout);
389 if (written != command_sz)
390 return AMT_STATUS_INTERNAL_ERROR;
391
392 out_buf_sz = mei_recv_msg(&acmd->mei_cl, *read_buf, in_buf_sz, 2000);
393 if (out_buf_sz <= 0)
394 return AMT_STATUS_HOST_IF_EMPTY_RESPONSE;
395
396 status = msg_hdr->status;
397 if (status != AMT_STATUS_SUCCESS)
398 return status;
399
400 status = amt_verify_response_header(rcmd,
401 &msg_hdr->header, out_buf_sz);
402 if (status != AMT_STATUS_SUCCESS)
403 return status;
404
405 if (expected_sz && expected_sz != out_buf_sz)
406 return AMT_STATUS_INTERNAL_ERROR;
407
408 return AMT_STATUS_SUCCESS;
409}
410
411
412static uint32_t amt_get_code_versions(struct amt_host_if *cmd,
413 struct amt_code_versions *versions)
414{
415 struct amt_host_if_resp_header *response = NULL;
416 uint32_t status;
417
418 status = amt_host_if_call(cmd,
419 (const unsigned char *)&CODE_VERSION_REQ,
420 sizeof(CODE_VERSION_REQ),
421 (uint8_t **)&response,
422 AMT_HOST_IF_CODE_VERSIONS_RESPONSE, 0);
423
424 if (status != AMT_STATUS_SUCCESS)
425 goto out;
426
427 status = amt_verify_code_versions(response);
428 if (status != AMT_STATUS_SUCCESS)
429 goto out;
430
431 memcpy(versions, response->data, sizeof(struct amt_code_versions));
432out:
433 if (response != NULL)
434 free(response);
435
436 return status;
437}
438
439
440int main(int argc, char **argv)
441{
442 struct amt_code_versions ver;
443 struct amt_host_if acmd;
444 unsigned int i;
445 uint32_t status;
446 int ret;
447 bool verbose;
448
449 verbose = (argc > 1 && strcmp(argv[1], "-v") == 0);
450
451 if (!amt_host_if_init(&acmd, 5000, verbose)) {
452 ret = 1;
453 goto out;
454 }
455
456 status = amt_get_code_versions(&acmd, &ver);
457
458 amt_host_if_deinit(&acmd);
459
460 switch (status) {
461 case AMT_STATUS_HOST_IF_EMPTY_RESPONSE:
462 printf("Intel AMT: DISABLED\n");
463 ret = 0;
464 break;
465 case AMT_STATUS_SUCCESS:
466 printf("Intel AMT: ENABLED\n");
467 for (i = 0; i < ver.count; i++) {
468 printf("%s:\t%s\n", ver.versions[i].description.string,
469 ver.versions[i].version.string);
470 }
471 ret = 0;
472 break;
473 default:
474 printf("An error has occurred\n");
475 ret = 1;
476 break;
477 }
478
479out:
480 return ret;
481}
482
