host/lib21/host_misc.c

/* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 *
 * Host functions for verified boot.
 */

#include <stdio.h>
#include <unistd.h>

#include "2sysincludes.h"
#include "2common.h"
#include "2sha.h"
#include "vb2_common.h"
#include "host_common.h"
#include "host_misc2.h"

int vb2_read_file(const char *filename, uint8_t **data_ptr, uint32_t *size_ptr)
{
	FILE *f;
	uint8_t *buf;
	long size;

	*data_ptr = NULL;
	*size_ptr = 0;

	f = fopen(filename, "rb");
	if (!f) {
		VB2_DEBUG("Unable to open file %s\n", filename);
		return VB2_ERROR_READ_FILE_OPEN;
	}

	fseek(f, 0, SEEK_END);
	size = ftell(f);
	rewind(f);

	if (size < 0 || size > UINT32_MAX) {
		fclose(f);
		return VB2_ERROR_READ_FILE_SIZE;
	}

	buf = malloc(size);
	if (!buf) {
		fclose(f);
		return VB2_ERROR_READ_FILE_ALLOC;
	}

	if(1 != fread(buf, size, 1, f)) {
		VB2_DEBUG("Unable to read file %s\n", filename);
		fclose(f);
		free(buf);
		return VB2_ERROR_READ_FILE_DATA;
	}

	fclose(f);

	*data_ptr = buf;
	*size_ptr = size;
	return VB2_SUCCESS;
}

int vb2_write_file(const char *filename, const void *buf, uint32_t size)
{
	FILE *f = fopen(filename, "wb");

	if (!f) {
		VB2_DEBUG("Unable to open file %s\n", filename);
		return VB2_ERROR_WRITE_FILE_OPEN;
	}

	if (1 != fwrite(buf, size, 1, f)) {
		VB2_DEBUG("Unable to write to file %s\n", filename);
		fclose(f);
		unlink(filename);  /* Delete any partial file */
		return VB2_ERROR_WRITE_FILE_DATA;
	}

	fclose(f);
	return VB2_SUCCESS;
}

int vb2_write_object(const char *filename, const void *buf)
{
	const struct vb2_struct_common *cptr = buf;

	return vb2_write_file(filename, buf, cptr->total_size);
}

uint32_t vb2_desc_size(const char *desc)
{
	if (!desc || !*desc)
		return 0;

	return roundup32(strlen(desc) + 1);
}

int vb2_str_to_guid(const char *str, struct vb2_guid *guid)
{
	uint32_t time_low;
	uint16_t time_mid;
	uint16_t time_high_and_version;
	unsigned int chunk[11];

	if (!str ||
	    11 != sscanf(str,
			 "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
			 chunk+0,
			 chunk+1,
			 chunk+2,
			 chunk+3,
			 chunk+4,
			 chunk+5,
			 chunk+6,
			 chunk+7,
			 chunk+8,
			 chunk+9,
			 chunk+10)) {
		return VB2_ERROR_STR_TO_GUID;
	}

	time_low = chunk[0] & 0xffffffff;
	time_mid = chunk[1] & 0xffff;
	time_high_and_version = chunk[2] & 0xffff;

	guid->uuid.time_low = htole32(time_low);
	guid->uuid.time_mid = htole16(time_mid);
	guid->uuid.time_high_and_version = htole16(time_high_and_version);

	guid->uuid.clock_seq_high_and_reserved = chunk[3] & 0xff;
	guid->uuid.clock_seq_low = chunk[4] & 0xff;
	guid->uuid.node[0] = chunk[5] & 0xff;
	guid->uuid.node[1] = chunk[6] & 0xff;
	guid->uuid.node[2] = chunk[7] & 0xff;
	guid->uuid.node[3] = chunk[8] & 0xff;
	guid->uuid.node[4] = chunk[9] & 0xff;
	guid->uuid.node[5] = chunk[10] & 0xff;

	return VB2_SUCCESS;
}

int vb2_guid_to_str(const struct vb2_guid *guid,
		    char *buf, unsigned int buflen)
{
	int n;

	if (!buf || buflen < VB2_GUID_MIN_STRLEN)
		return VB2_ERROR_GUID_TO_STR;

	n = snprintf(buf, buflen,
		     "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
		     le32toh(guid->uuid.time_low),
		     le16toh(guid->uuid.time_mid),
		     le16toh(guid->uuid.time_high_and_version),
		     guid->uuid.clock_seq_high_and_reserved,
		     guid->uuid.clock_seq_low,
		     guid->uuid.node[0], guid->uuid.node[1],
		     guid->uuid.node[2], guid->uuid.node[3],
		     guid->uuid.node[4], guid->uuid.node[5]);

	if (n != VB2_GUID_MIN_STRLEN - 1)
		return VB2_ERROR_GUID_TO_STR;

	return VB2_SUCCESS;
}