lib/runnercomms.c - platform/external/igt-gpu-tools - Git at Google

 /* SPDX-License-Identifier: MIT */
 /*
  * Copyright © 2022 Intel Corporation
  */

 #include <assert.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include "igt_aux.h"
 #include "runnercomms.h"

 /**
  * SECTION:runnercomms
  * @short_description: Structured communication to igt_runner
  * @title: runnercomms
  * @include: runnercomms.h
  *
  * This library provides means for the tests to communicate to
  * igt_runner with a formally specified protocol, avoiding
  * shortcomings and pain points of text-based communication.
  */

 static sig_atomic_t runner_socket_fd = -1;

 /**
  * set_runner_socket:
  * @fd: socket connected to runner
  *
  * If the passed fd is a valid socket, globally sets it to be the fd
  * to use to talk to igt_runner.
  */
 void set_runner_socket(int fd)
 {
 	struct stat sb;

 	if (fstat(fd, &sb))
 		return;

 	if (!S_ISSOCK(sb.st_mode))
 		return;

 	/*
 	 * We only sanity-check that the fd is a socket. We don't
 	 * check that it's a datagram socket etc.
 	 */

 	runner_socket_fd = fd;
 }

 /**
  * runner_connected:
  *
  * Returns whether set_runner_socket has been called with a valid
  * socket fd. Note: Will be true forever after that point. This
  * function is used to mainly determine whether log strings will be
  * output to the socket or to stdout/stderr and that cannot be changed
  * even if the socket is lost midway.
  */
 bool runner_connected(void)
 {
 	return runner_socket_fd >= 0;
 }

 /**
  * send_to_runner:
  * @packet: packet to send
  *
  * Sends the given communications packet to igt_runner. Calls free()
  * on the packet, don't reuse it.
  */
 void send_to_runner(struct runnerpacket *packet)
 {
 	if (runner_connected())
 		write(runner_socket_fd, packet, packet->size);
 	free(packet);
 }

 /* If enough data left, copy the data to dst, advance p, reduce size */
 static void read_integer(void* dst, size_t bytes, const char **p, uint32_t *size)
 {
 	if (*size < bytes) {
 		*size = 0;
 		return;
 	}

 	memcpy(dst, *p, bytes);
 	*p += bytes;
 	*size -= bytes;
 }

 /* If nul-termination can be found, set dststr to point to the cstring, advance p, reduce size */
 static void read_cstring(const char **dststr, const char **p, uint32_t *size)
 {
 	const char *end;

 	end = memchr(*p, '\0', *size);
 	if (end == NULL) {
 		*size = 0;
 		return;
 	}

 	*dststr = *p;
 	*size -= end - *p + 1;
 	*p = end + 1;
 }

 /**
  * read_runnerpacket:
  * @packet: runner communications packet to read
  *
  * Checks that the internal data of the communications packet is valid
  * and the contents can safely be inspected without further checking
  * for out-of-bounds etc. Constructs a runnerpacket_read_helper which
  * will, for c-style strings, point to various sub-values directly in
  * the #data field within @packet. Those are valid only as long as
  * @packet is valid.
  *
  * Returns: An appropriately constructed runnerpacket_read_helper. On
  * data validation errors, the #type of the returned value will be
  * #PACKETTYPE_INVALID.
  */
 runnerpacket_read_helper read_runnerpacket(const struct runnerpacket *packet)
 {
 	runnerpacket_read_helper ret = {};
 	uint32_t sizeleft;
 	const char *p;

 	if (packet->size < sizeof(*packet)) {
 		ret.type = PACKETTYPE_INVALID;
 		return ret;
 	}

 	ret.type = packet->type;
 	sizeleft = packet->size - sizeof(*packet);
 	p = packet->data;

 	switch (packet->type) {
 	case PACKETTYPE_LOG:
 		read_integer(&ret.log.stream, sizeof(ret.log.stream), &p, &sizeleft);
 		read_cstring(&ret.log.text, &p, &sizeleft);

 		if (ret.log.text == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	case PACKETTYPE_EXEC:
 		read_cstring(&ret.exec.cmdline, &p, &sizeleft);

 		if (ret.exec.cmdline == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	case PACKETTYPE_EXIT:
 		read_integer(&ret.exit.exitcode, sizeof(ret.exit.exitcode), &p, &sizeleft);
 		read_cstring(&ret.exit.timeused, &p, &sizeleft);

 		break;
 	case PACKETTYPE_SUBTEST_START:
 		read_cstring(&ret.subteststart.name, &p, &sizeleft);

 		if (ret.subteststart.name == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	case PACKETTYPE_SUBTEST_RESULT:
 		read_cstring(&ret.subtestresult.name, &p, &sizeleft);
 		read_cstring(&ret.subtestresult.result, &p, &sizeleft);
 		read_cstring(&ret.subtestresult.timeused, &p, &sizeleft);
 		read_cstring(&ret.subtestresult.reason, &p, &sizeleft);

 		if (ret.subtestresult.name == NULL ||
 		    ret.subtestresult.result == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	case PACKETTYPE_DYNAMIC_SUBTEST_START:
 		read_cstring(&ret.dynamicsubteststart.name, &p, &sizeleft);

 		if (ret.dynamicsubteststart.name == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	case PACKETTYPE_DYNAMIC_SUBTEST_RESULT:
 		read_cstring(&ret.dynamicsubtestresult.name, &p, &sizeleft);
 		read_cstring(&ret.dynamicsubtestresult.result, &p, &sizeleft);
 		read_cstring(&ret.dynamicsubtestresult.timeused, &p, &sizeleft);
 		read_cstring(&ret.dynamicsubtestresult.reason, &p, &sizeleft);

 		if (ret.dynamicsubtestresult.name == NULL ||
 		    ret.dynamicsubtestresult.result == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	case PACKETTYPE_VERSIONSTRING:
 		read_cstring(&ret.versionstring.text, &p, &sizeleft);

 		if (ret.versionstring.text == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	case PACKETTYPE_RESULT_OVERRIDE:
 		read_cstring(&ret.resultoverride.result, &p, &sizeleft);

 		if (ret.resultoverride.result == NULL)
 			ret.type = PACKETTYPE_INVALID;

 		break;
 	default:
 		ret.type = PACKETTYPE_INVALID;
 		break;
 	}

 	return ret;
 }

 struct runnerpacket *runnerpacket_log(uint8_t stream, const char *text)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	size = sizeof(struct runnerpacket) + sizeof(stream) + strlen(text) + 1;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_LOG;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	memcpy(p, &stream, sizeof(stream));
 	p += sizeof(stream);

 	strcpy(p, text);
 	p += strlen(text) + 1;

 	return packet;
 }

 struct runnerpacket *runnerpacket_exec(char **argv)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;
 	int i;

 	size = sizeof(struct runnerpacket);

 	for (i = 0; argv[i] != NULL; i++)
 		size += strlen(argv[i]) + 1; // followed by a space of \0 so +1 either way for each

 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_EXEC;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	for (i = 0; argv[i] != NULL; i++) {
 		if (i != 0)
 			*p++ = ' ';

 		strcpy(p, argv[i]);
 		p += strlen(argv[i]);
 	}
 	p[0] = '\0';

 	return packet;
 }

 struct runnerpacket *runnerpacket_exit(int32_t exitcode, const char *timeused)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	size = sizeof(struct runnerpacket) + sizeof(exitcode) + strlen(timeused) + 1;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_EXIT;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	memcpy(p, &exitcode, sizeof(exitcode));
 	p += sizeof(exitcode);

 	strcpy(p, timeused);
 	p += strlen(timeused) + 1;

 	return packet;
 }

 struct runnerpacket *runnerpacket_subtest_start(const char *name)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	size = sizeof(struct runnerpacket) + strlen(name) + 1;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_SUBTEST_START;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	strcpy(p, name);
 	p += strlen(name) + 1;

 	return packet;
 }

 struct runnerpacket *runnerpacket_subtest_result(const char *name, const char *result,
 						 const char *timeused, const char *reason)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	if (reason == NULL)
 		reason = "";

 	size = sizeof(struct runnerpacket) + strlen(name) + strlen(result) + strlen(timeused) + strlen(reason) + 4;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_SUBTEST_RESULT;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	strcpy(p, name);
 	p += strlen(name) + 1;

 	strcpy(p, result);
 	p += strlen(result) + 1;

 	strcpy(p, timeused);
 	p += strlen(timeused) + 1;

 	strcpy(p, reason);
 	p += strlen(reason) + 1;

 	return packet;
 }

 struct runnerpacket *runnerpacket_dynamic_subtest_start(const char *name)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	size = sizeof(struct runnerpacket) + strlen(name) + 1;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_DYNAMIC_SUBTEST_START;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	strcpy(p, name);
 	p += strlen(name) + 1;

 	return packet;
 }

 struct runnerpacket *runnerpacket_dynamic_subtest_result(const char *name, const char *result,
 							 const char *timeused, const char *reason)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	if (reason == NULL)
 		reason = "";

 	size = sizeof(struct runnerpacket) + strlen(name) + strlen(result) + strlen(timeused) + strlen(reason) + 4;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_DYNAMIC_SUBTEST_RESULT;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	strcpy(p, name);
 	p += strlen(name) + 1;

 	strcpy(p, result);
 	p += strlen(result) + 1;

 	strcpy(p, timeused);
 	p += strlen(timeused) + 1;

 	strcpy(p, reason);
 	p += strlen(reason) + 1;

 	return packet;
 }

 struct runnerpacket *runnerpacket_versionstring(const char *text)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	size = sizeof(struct runnerpacket) + strlen(text) + 1;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_VERSIONSTRING;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	strcpy(p, text);
 	p += strlen(text) + 1;

 	return packet;
 }

 struct runnerpacket *runnerpacket_resultoverride(const char *result)
 {
 	struct runnerpacket *packet;
 	uint32_t size;
 	char *p;

 	size = sizeof(struct runnerpacket) + strlen(result) + 1;
 	packet = malloc(size);

 	packet->size = size;
 	packet->type = PACKETTYPE_RESULT_OVERRIDE;
 	packet->senderpid = getpid();
 	packet->sendertid = gettid();

 	p = packet->data;

 	strcpy(p, result);
 	p += strlen(result) + 1;

 	return packet;
 }

 uint32_t socket_dump_canary(void)
 {
 	return 'I' << 24 | 'G' << 16 | 'T' << 8 | '1';
 }

 void log_to_runner_sig_safe(const char *str, size_t len)
 {
 	size_t prlen = len;

 	struct runnerpacket_log_sig_safe p = {
 					      .size = sizeof(struct runnerpacket) + sizeof(uint8_t),
 					      .type = PACKETTYPE_LOG,
 					      .senderpid = getpid(),
 					      .sendertid = 0, /* gettid() not signal safe */
 					      .stream = STDERR_FILENO,
 	};

 	if (len > sizeof(p.data) - 1)
 		prlen = sizeof(p.data) - 1;
 	memcpy(p.data, str, prlen);
 	p.size += prlen + 1;

 	write(runner_socket_fd, &p, p.size);

 	len -= prlen;
 	if (len)
 		log_to_runner_sig_safe(str + prlen, len);
 }

 /**
  * comms_read_dump:
  * @fd: Open fd to a comms dump file
  * @visitor: Collection of packet handlers
  *
  * Reads a comms dump file, calling specified handler functions for
  * individual packets.
  *
  * Returns: #COMMSPARSE_ERROR for failures reading or parsing the
  * dump, #COMMSPARSE_EMPTY for empty dumps (no comms used),
  * #COMMSPARSE_SUCCESS for successful read.
  */
 int comms_read_dump(int fd, struct comms_visitor *visitor)
 {
 	struct stat statbuf;
 	char *buf, *bufend, *p;
 	int ret = COMMSPARSE_EMPTY;
 	bool cont = true;

 	if (fd < 0)
 		return COMMSPARSE_EMPTY;

 	if (fstat(fd, &statbuf))
 		return COMMSPARSE_ERROR;

 	if (statbuf.st_size == 0)
 		return COMMSPARSE_EMPTY;

 	buf = mmap(NULL, statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0);
 	if (buf == MAP_FAILED)
 		return COMMSPARSE_ERROR;

 	bufend = buf + statbuf.st_size;
 	p = buf;

 	while (p != NULL && p != bufend && cont) {
 		const struct runnerpacket *packet;
 		runnerpacket_read_helper helper;

 		if (bufend - p >= sizeof(uint32_t)) {
 			uint32_t canary;

 			memcpy(&canary, p, sizeof(canary));
 			if (canary != socket_dump_canary()) {
 				fprintf(stderr,
 					"Invalid canary while parsing comms: %"PRIu32", expected %"PRIu32"\n",
 					canary, socket_dump_canary());
 				munmap(buf, statbuf.st_size);
 				return COMMSPARSE_ERROR;
 			}
 		}
 		p += sizeof(uint32_t);

 		if (bufend -p < sizeof(struct runnerpacket)) {
 			fprintf(stderr,
 				"Error parsing comms: Expected runnerpacket after canary, truncated file?\n");
 			munmap(buf, statbuf.st_size);
 			return COMMSPARSE_ERROR;
 		}

 		packet = (struct runnerpacket *)p;
 		if (bufend -p < packet->size) {
 			fprintf(stderr,
 				"Error parsing comms: Unexpected end of file, truncated file?\n");
 			munmap(buf, statbuf.st_size);
 			return COMMSPARSE_ERROR;
 		}
 		p += packet->size;

 		/*
 		 * Runner sends EXEC itself before executing the test.
 		 * If we get other types, it indicates the test really
 		 * uses socket comms.
 		 */
 		if (packet->type != PACKETTYPE_EXEC)
 			ret = COMMSPARSE_SUCCESS;

 		switch (packet->type) {
 		case PACKETTYPE_INVALID:
 			printf("Warning: Unknown packet type %"PRIu32", skipping\n", packet->type);
 			break;
 		case PACKETTYPE_LOG:
 			if (visitor->log) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->log(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_EXEC:
 			if (visitor->exec) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->exec(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_EXIT:
 			if (visitor->exit) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->exit(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_SUBTEST_START:
 			if (visitor->subtest_start) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->subtest_start(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_SUBTEST_RESULT:
 			if (visitor->subtest_result) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->subtest_result(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_DYNAMIC_SUBTEST_START:
 			if (visitor->dynamic_subtest_start) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->dynamic_subtest_start(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_DYNAMIC_SUBTEST_RESULT:
 			if (visitor->dynamic_subtest_result) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->dynamic_subtest_result(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_VERSIONSTRING:
 			if (visitor->versionstring) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->versionstring(packet, helper, visitor->userdata);
 			}
 			break;
 		case PACKETTYPE_RESULT_OVERRIDE:
 			if (visitor->result_override) {
 				helper = read_runnerpacket(packet);
 				cont = visitor->result_override(packet, helper, visitor->userdata);
 			}
 			break;
 		default:
 			printf("Warning: Unknown packet type %"PRIu32"\n", helper.type);
 			break;
 		}
 	}

 	munmap(buf, statbuf.st_size);
 	return cont ? ret : COMMSPARSE_ERROR;
 }
	/* SPDX-License-Identifier: MIT */
	/*
	* Copyright © 2022 Intel Corporation
	*/

	#include <assert.h>
	#include <signal.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include "igt_aux.h"
	#include "runnercomms.h"

	/**
	* SECTION:runnercomms
	* @short_description: Structured communication to igt_runner
	* @title: runnercomms
	* @include: runnercomms.h
	*
	* This library provides means for the tests to communicate to
	* igt_runner with a formally specified protocol, avoiding
	* shortcomings and pain points of text-based communication.
	*/

	static sig_atomic_t runner_socket_fd = -1;

	/**
	* set_runner_socket:
	* @fd: socket connected to runner
	*
	* If the passed fd is a valid socket, globally sets it to be the fd
	* to use to talk to igt_runner.
	*/
	void set_runner_socket(int fd)
	{
	struct stat sb;

	if (fstat(fd, &sb))
	return;

	if (!S_ISSOCK(sb.st_mode))
	return;

	/*
	* We only sanity-check that the fd is a socket. We don't
	* check that it's a datagram socket etc.
	*/

	runner_socket_fd = fd;
	}

	/**
	* runner_connected:
	*
	* Returns whether set_runner_socket has been called with a valid
	* socket fd. Note: Will be true forever after that point. This
	* function is used to mainly determine whether log strings will be
	* output to the socket or to stdout/stderr and that cannot be changed
	* even if the socket is lost midway.
	*/
	bool runner_connected(void)
	{
	return runner_socket_fd >= 0;
	}

	/**
	* send_to_runner:
	* @packet: packet to send
	*
	* Sends the given communications packet to igt_runner. Calls free()
	* on the packet, don't reuse it.
	*/
	void send_to_runner(struct runnerpacket *packet)
	{
	if (runner_connected())
	write(runner_socket_fd, packet, packet->size);
	free(packet);
	}

	/* If enough data left, copy the data to dst, advance p, reduce size */
	static void read_integer(void* dst, size_t bytes, const char *p, uint32_t size)
	{
	if (*size < bytes) {
	*size = 0;
	return;
	}

	memcpy(dst, *p, bytes);
	*p += bytes;
	*size -= bytes;
	}

	/* If nul-termination can be found, set dststr to point to the cstring, advance p, reduce size */
	static void read_cstring(const char dststr, const char p, uint32_t *size)
	{
	const char *end;

	end = memchr(p, '\0', size);
	if (end == NULL) {
	*size = 0;
	return;
	}

	dststr = p;
	size -= end - p + 1;
	*p = end + 1;
	}

	/**
	* read_runnerpacket:
	* @packet: runner communications packet to read
	*
	* Checks that the internal data of the communications packet is valid
	* and the contents can safely be inspected without further checking
	* for out-of-bounds etc. Constructs a runnerpacket_read_helper which
	* will, for c-style strings, point to various sub-values directly in
	* the #data field within @packet. Those are valid only as long as
	* @packet is valid.
	*
	* Returns: An appropriately constructed runnerpacket_read_helper. On
	* data validation errors, the #type of the returned value will be
	* #PACKETTYPE_INVALID.
	*/
	runnerpacket_read_helper read_runnerpacket(const struct runnerpacket *packet)
	{
	runnerpacket_read_helper ret = {};
	uint32_t sizeleft;
	const char *p;

	if (packet->size < sizeof(*packet)) {
	ret.type = PACKETTYPE_INVALID;
	return ret;
	}

	ret.type = packet->type;
	sizeleft = packet->size - sizeof(*packet);
	p = packet->data;

	switch (packet->type) {
	case PACKETTYPE_LOG:
	read_integer(&ret.log.stream, sizeof(ret.log.stream), &p, &sizeleft);
	read_cstring(&ret.log.text, &p, &sizeleft);

	if (ret.log.text == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	case PACKETTYPE_EXEC:
	read_cstring(&ret.exec.cmdline, &p, &sizeleft);

	if (ret.exec.cmdline == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	case PACKETTYPE_EXIT:
	read_integer(&ret.exit.exitcode, sizeof(ret.exit.exitcode), &p, &sizeleft);
	read_cstring(&ret.exit.timeused, &p, &sizeleft);

	break;
	case PACKETTYPE_SUBTEST_START:
	read_cstring(&ret.subteststart.name, &p, &sizeleft);

	if (ret.subteststart.name == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	case PACKETTYPE_SUBTEST_RESULT:
	read_cstring(&ret.subtestresult.name, &p, &sizeleft);
	read_cstring(&ret.subtestresult.result, &p, &sizeleft);
	read_cstring(&ret.subtestresult.timeused, &p, &sizeleft);
	read_cstring(&ret.subtestresult.reason, &p, &sizeleft);

	if (ret.subtestresult.name == NULL \|\|
	ret.subtestresult.result == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	case PACKETTYPE_DYNAMIC_SUBTEST_START:
	read_cstring(&ret.dynamicsubteststart.name, &p, &sizeleft);

	if (ret.dynamicsubteststart.name == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	case PACKETTYPE_DYNAMIC_SUBTEST_RESULT:
	read_cstring(&ret.dynamicsubtestresult.name, &p, &sizeleft);
	read_cstring(&ret.dynamicsubtestresult.result, &p, &sizeleft);
	read_cstring(&ret.dynamicsubtestresult.timeused, &p, &sizeleft);
	read_cstring(&ret.dynamicsubtestresult.reason, &p, &sizeleft);

	if (ret.dynamicsubtestresult.name == NULL \|\|
	ret.dynamicsubtestresult.result == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	case PACKETTYPE_VERSIONSTRING:
	read_cstring(&ret.versionstring.text, &p, &sizeleft);

	if (ret.versionstring.text == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	case PACKETTYPE_RESULT_OVERRIDE:
	read_cstring(&ret.resultoverride.result, &p, &sizeleft);

	if (ret.resultoverride.result == NULL)
	ret.type = PACKETTYPE_INVALID;

	break;
	default:
	ret.type = PACKETTYPE_INVALID;
	break;
	}

	return ret;
	}

	struct runnerpacket runnerpacket_log(uint8_t stream, const char text)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	size = sizeof(struct runnerpacket) + sizeof(stream) + strlen(text) + 1;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_LOG;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	memcpy(p, &stream, sizeof(stream));
	p += sizeof(stream);

	strcpy(p, text);
	p += strlen(text) + 1;

	return packet;
	}

	struct runnerpacket runnerpacket_exec(char *argv)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;
	int i;

	size = sizeof(struct runnerpacket);

	for (i = 0; argv[i] != NULL; i++)
	size += strlen(argv[i]) + 1; // followed by a space of \0 so +1 either way for each

	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_EXEC;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	for (i = 0; argv[i] != NULL; i++) {
	if (i != 0)
	*p++ = ' ';

	strcpy(p, argv[i]);
	p += strlen(argv[i]);
	}
	p[0] = '\0';

	return packet;
	}

	struct runnerpacket runnerpacket_exit(int32_t exitcode, const char timeused)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	size = sizeof(struct runnerpacket) + sizeof(exitcode) + strlen(timeused) + 1;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_EXIT;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	memcpy(p, &exitcode, sizeof(exitcode));
	p += sizeof(exitcode);

	strcpy(p, timeused);
	p += strlen(timeused) + 1;

	return packet;
	}

	struct runnerpacket runnerpacket_subtest_start(const char name)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	size = sizeof(struct runnerpacket) + strlen(name) + 1;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_SUBTEST_START;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	strcpy(p, name);
	p += strlen(name) + 1;

	return packet;
	}

	struct runnerpacket runnerpacket_subtest_result(const char name, const char *result,
	const char timeused, const char reason)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	if (reason == NULL)
	reason = "";

	size = sizeof(struct runnerpacket) + strlen(name) + strlen(result) + strlen(timeused) + strlen(reason) + 4;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_SUBTEST_RESULT;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	strcpy(p, name);
	p += strlen(name) + 1;

	strcpy(p, result);
	p += strlen(result) + 1;

	strcpy(p, timeused);
	p += strlen(timeused) + 1;

	strcpy(p, reason);
	p += strlen(reason) + 1;

	return packet;
	}

	struct runnerpacket runnerpacket_dynamic_subtest_start(const char name)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	size = sizeof(struct runnerpacket) + strlen(name) + 1;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_DYNAMIC_SUBTEST_START;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	strcpy(p, name);
	p += strlen(name) + 1;

	return packet;
	}

	struct runnerpacket runnerpacket_dynamic_subtest_result(const char name, const char *result,
	const char timeused, const char reason)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	if (reason == NULL)
	reason = "";

	size = sizeof(struct runnerpacket) + strlen(name) + strlen(result) + strlen(timeused) + strlen(reason) + 4;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_DYNAMIC_SUBTEST_RESULT;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	strcpy(p, name);
	p += strlen(name) + 1;

	strcpy(p, result);
	p += strlen(result) + 1;

	strcpy(p, timeused);
	p += strlen(timeused) + 1;

	strcpy(p, reason);
	p += strlen(reason) + 1;

	return packet;
	}

	struct runnerpacket runnerpacket_versionstring(const char text)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	size = sizeof(struct runnerpacket) + strlen(text) + 1;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_VERSIONSTRING;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	strcpy(p, text);
	p += strlen(text) + 1;

	return packet;
	}

	struct runnerpacket runnerpacket_resultoverride(const char result)
	{
	struct runnerpacket *packet;
	uint32_t size;
	char *p;

	size = sizeof(struct runnerpacket) + strlen(result) + 1;
	packet = malloc(size);

	packet->size = size;
	packet->type = PACKETTYPE_RESULT_OVERRIDE;
	packet->senderpid = getpid();
	packet->sendertid = gettid();

	p = packet->data;

	strcpy(p, result);
	p += strlen(result) + 1;

	return packet;
	}

	uint32_t socket_dump_canary(void)
	{
	return 'I' << 24 \| 'G' << 16 \| 'T' << 8 \| '1';
	}

	void log_to_runner_sig_safe(const char *str, size_t len)
	{
	size_t prlen = len;

	struct runnerpacket_log_sig_safe p = {
	.size = sizeof(struct runnerpacket) + sizeof(uint8_t),
	.type = PACKETTYPE_LOG,
	.senderpid = getpid(),
	.sendertid = 0, /* gettid() not signal safe */
	.stream = STDERR_FILENO,
	};

	if (len > sizeof(p.data) - 1)
	prlen = sizeof(p.data) - 1;
	memcpy(p.data, str, prlen);
	p.size += prlen + 1;

	write(runner_socket_fd, &p, p.size);

	len -= prlen;
	if (len)
	log_to_runner_sig_safe(str + prlen, len);
	}

	/**
	* comms_read_dump:
	* @fd: Open fd to a comms dump file
	* @visitor: Collection of packet handlers
	*
	* Reads a comms dump file, calling specified handler functions for
	* individual packets.
	*
	* Returns: #COMMSPARSE_ERROR for failures reading or parsing the
	* dump, #COMMSPARSE_EMPTY for empty dumps (no comms used),
	* #COMMSPARSE_SUCCESS for successful read.
	*/
	int comms_read_dump(int fd, struct comms_visitor *visitor)
	{
	struct stat statbuf;
	char buf, bufend, *p;
	int ret = COMMSPARSE_EMPTY;
	bool cont = true;

	if (fd < 0)
	return COMMSPARSE_EMPTY;

	if (fstat(fd, &statbuf))
	return COMMSPARSE_ERROR;

	if (statbuf.st_size == 0)
	return COMMSPARSE_EMPTY;

	buf = mmap(NULL, statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0);
	if (buf == MAP_FAILED)
	return COMMSPARSE_ERROR;

	bufend = buf + statbuf.st_size;
	p = buf;

	while (p != NULL && p != bufend && cont) {
	const struct runnerpacket *packet;
	runnerpacket_read_helper helper;

	if (bufend - p >= sizeof(uint32_t)) {
	uint32_t canary;

	memcpy(&canary, p, sizeof(canary));
	if (canary != socket_dump_canary()) {
	fprintf(stderr,
	"Invalid canary while parsing comms: %"PRIu32", expected %"PRIu32"\n",
	canary, socket_dump_canary());
	munmap(buf, statbuf.st_size);
	return COMMSPARSE_ERROR;
	}
	}
	p += sizeof(uint32_t);

	if (bufend -p < sizeof(struct runnerpacket)) {
	fprintf(stderr,
	"Error parsing comms: Expected runnerpacket after canary, truncated file?\n");
	munmap(buf, statbuf.st_size);
	return COMMSPARSE_ERROR;
	}

	packet = (struct runnerpacket *)p;
	if (bufend -p < packet->size) {
	fprintf(stderr,
	"Error parsing comms: Unexpected end of file, truncated file?\n");
	munmap(buf, statbuf.st_size);
	return COMMSPARSE_ERROR;
	}
	p += packet->size;

	/*
	* Runner sends EXEC itself before executing the test.
	* If we get other types, it indicates the test really
	* uses socket comms.
	*/
	if (packet->type != PACKETTYPE_EXEC)
	ret = COMMSPARSE_SUCCESS;

	switch (packet->type) {
	case PACKETTYPE_INVALID:
	printf("Warning: Unknown packet type %"PRIu32", skipping\n", packet->type);
	break;
	case PACKETTYPE_LOG:
	if (visitor->log) {
	helper = read_runnerpacket(packet);
	cont = visitor->log(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_EXEC:
	if (visitor->exec) {
	helper = read_runnerpacket(packet);
	cont = visitor->exec(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_EXIT:
	if (visitor->exit) {
	helper = read_runnerpacket(packet);
	cont = visitor->exit(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_SUBTEST_START:
	if (visitor->subtest_start) {
	helper = read_runnerpacket(packet);
	cont = visitor->subtest_start(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_SUBTEST_RESULT:
	if (visitor->subtest_result) {
	helper = read_runnerpacket(packet);
	cont = visitor->subtest_result(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_DYNAMIC_SUBTEST_START:
	if (visitor->dynamic_subtest_start) {
	helper = read_runnerpacket(packet);
	cont = visitor->dynamic_subtest_start(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_DYNAMIC_SUBTEST_RESULT:
	if (visitor->dynamic_subtest_result) {
	helper = read_runnerpacket(packet);
	cont = visitor->dynamic_subtest_result(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_VERSIONSTRING:
	if (visitor->versionstring) {
	helper = read_runnerpacket(packet);
	cont = visitor->versionstring(packet, helper, visitor->userdata);
	}
	break;
	case PACKETTYPE_RESULT_OVERRIDE:
	if (visitor->result_override) {
	helper = read_runnerpacket(packet);
	cont = visitor->result_override(packet, helper, visitor->userdata);
	}
	break;
	default:
	printf("Warning: Unknown packet type %"PRIu32"\n", helper.type);
	break;
	}
	}

	munmap(buf, statbuf.st_size);
	return cont ? ret : COMMSPARSE_ERROR;
	}