fwupd/plugins/redfish/fu-redfish-smbios.c

/*
 * Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1+
 */

#include "config.h"

#include <fwupdplugin.h>

#include "fu-redfish-common.h"
#include "fu-redfish-smbios.h"

struct _FuRedfishSmbios {
	FuFirmwareClass		 parent_instance;
	guint16			 port;
	gchar			*hostname;
	gchar			*mac_addr;
	gchar			*ip_addr;
	guint16			 vid;
	guint16			 pid;
};

G_DEFINE_TYPE (FuRedfishSmbios, fu_redfish_smbios, FU_TYPE_FIRMWARE)

typedef struct __attribute__((packed)) {
	guint8		 service_uuid[16];
	guint8		 host_ip_assignment_type;
	guint8		 host_ip_address_format;
	guint8		 host_ip_address[16];
	guint8		 host_ip_mask[16];
	guint8		 service_ip_assignment_type;
	guint8		 service_ip_address_format;
	guint8		 service_ip_address[16];
	guint8		 service_ip_mask[16];
	guint16		 service_ip_port;
	guint32		 service_ip_vlan_id;
	guint8		 service_hostname_len;
	/* optional service_hostname goes here */
} FuRedfishProtocolOverIp;

guint16
fu_redfish_smbios_get_port (FuRedfishSmbios *self)
{
	return self->port;
}

guint16
fu_redfish_smbios_get_vid (FuRedfishSmbios *self)
{
	return self->vid;
}

guint16
fu_redfish_smbios_get_pid (FuRedfishSmbios *self)
{
	return self->pid;
}

const gchar *
fu_redfish_smbios_get_hostname (FuRedfishSmbios *self)
{
	return self->hostname;
}

const gchar *
fu_redfish_smbios_get_mac_addr (FuRedfishSmbios *self)
{
	return self->mac_addr;
}

const gchar *
fu_redfish_smbios_get_ip_addr (FuRedfishSmbios *self)
{
	return self->ip_addr;
}

static void
fu_redfish_smbios_set_hostname (FuRedfishSmbios *self, const gchar *hostname)
{
	g_free (self->hostname);
	self->hostname = g_strdup (hostname);
}

static void
fu_redfish_smbios_set_mac_addr (FuRedfishSmbios *self, const gchar *mac_addr)
{
	g_free (self->mac_addr);
	self->mac_addr = g_strdup (mac_addr);
}

static void
fu_redfish_smbios_set_ip_addr (FuRedfishSmbios *self, const gchar *ip_addr)
{
	g_free (self->ip_addr);
	self->ip_addr = g_strdup (ip_addr);
}

static void
fu_redfish_smbios_set_port (FuRedfishSmbios *self, guint16 port)
{
	self->port = port;
}

static void
fu_redfish_smbios_export (FuFirmware *firmware,
			FuFirmwareExportFlags flags,
			XbBuilderNode *bn)
{
	FuRedfishSmbios *self = FU_REDFISH_SMBIOS (firmware);
	fu_xmlb_builder_insert_kx (bn, "port", self->port);
	fu_xmlb_builder_insert_kv (bn, "hostname", self->hostname);
	fu_xmlb_builder_insert_kv (bn, "mac_addr", self->mac_addr);
	fu_xmlb_builder_insert_kv (bn, "ip_addr", self->ip_addr);
	fu_xmlb_builder_insert_kx (bn, "vid", self->vid);
	fu_xmlb_builder_insert_kx (bn, "pid", self->pid);
}

static gboolean
fu_redfish_smbios_build (FuFirmware *firmware, XbNode *n, GError **error)
{
	FuRedfishSmbios *self = FU_REDFISH_SMBIOS (firmware);
	const gchar *tmp;
	guint64 tmpu;

	/* optional properties */
	tmpu = xb_node_query_text_as_uint (n, "port", NULL);
	if (tmpu != G_MAXUINT64)
		fu_redfish_smbios_set_port (self, (guint16) tmpu);
	tmpu = xb_node_query_text_as_uint (n, "vid", NULL);
	if (tmpu != G_MAXUINT64)
		self->vid = (guint16) tmpu;
	tmpu = xb_node_query_text_as_uint (n, "pid", NULL);
	if (tmpu != G_MAXUINT64)
		self->pid = (guint16) tmpu;
	tmp = xb_node_query_text (n, "hostname", NULL);
	if (tmp != NULL)
		fu_redfish_smbios_set_hostname (self, tmp);
	tmp = xb_node_query_text (n, "mac_addr", NULL);
	if (tmp != NULL)
		fu_redfish_smbios_set_mac_addr (self, tmp);
	tmp = xb_node_query_text (n, "ip_addr", NULL);
	if (tmp != NULL)
		fu_redfish_smbios_set_ip_addr (self, tmp);

	/* success */
	return TRUE;
}

static gboolean
fu_redfish_smbios_parse_interface_data (FuRedfishSmbios *self,
					GBytes *fw, gsize offset,
					GError **error)
{
	gsize bufsz = 0;
	gsize offset_mac_addr = G_MAXSIZE;
	gsize offset_vid_pid = G_MAXSIZE;
	guint8 interface_type = 0x0;
	const guint8 *buf = g_bytes_get_data (fw, &bufsz);

	/* parse the data depending on the interface type */
	if (!fu_common_read_uint8_safe (buf, bufsz, offset,
					&interface_type, error))
		return FALSE;
	offset++;
	switch (interface_type) {
	case REDFISH_INTERFACE_TYPE_USB_NETWORK:
	case REDFISH_INTERFACE_TYPE_PCI_NETWORK:
		offset_vid_pid = 0x00;
		break;
	case REDFISH_INTERFACE_TYPE_USB_NETWORK_V2:
		offset_vid_pid = 0x01;
		offset_mac_addr = 0x06;
		break;
	case REDFISH_INTERFACE_TYPE_PCI_NETWORK_V2:
		offset_vid_pid = 0x01;
		offset_mac_addr = 0x09;
		break;
	default:
		g_debug ("unknown Network Interface");
		break;
	}

	/* MAC address */
	if (offset_mac_addr != G_MAXSIZE) {
		guint8 mac_addr[6] = { 0x0 };
		g_autofree gchar *mac_addr_str = NULL;
		if (!fu_memcpy_safe (mac_addr, sizeof(mac_addr), 0x0,		/* dst */
				     buf, bufsz, offset + offset_mac_addr,	/* src */
				     sizeof(mac_addr), error))
			return FALSE;
		mac_addr_str = fu_redfish_common_buffer_to_mac (mac_addr);
		fu_redfish_smbios_set_mac_addr (self, mac_addr_str);
	}

	/* VID:PID */
	if (offset_vid_pid != G_MAXSIZE) {
		if (!fu_common_read_uint16_safe (buf, bufsz, offset + offset_vid_pid,
						 &self->vid, G_LITTLE_ENDIAN, error))
			return FALSE;
		if (!fu_common_read_uint16_safe (buf, bufsz, offset + offset_vid_pid + 0x02,
						 &self->pid, G_LITTLE_ENDIAN, error))
			return FALSE;
	}

	/* success */
	return TRUE;
}

static gboolean
fu_redfish_smbios_parse_over_ip (FuRedfishSmbios *self,
				 GBytes *fw, gsize offset,
				 GError **error)
{
	gsize bufsz = 0;
	const guint8 *buf = g_bytes_get_data (fw, &bufsz);
	guint8 hostname_length = 0x0;
	guint8 service_ip_address_format = 0x0;
	guint16 service_ip_port = 0x0;
	guint8 service_ip_address[16] = { 0x0 };

	/* port */
	if (!fu_common_read_uint16_safe (buf, bufsz,
					 offset + G_STRUCT_OFFSET(FuRedfishProtocolOverIp,
								  service_ip_port),
					 &service_ip_port, G_LITTLE_ENDIAN, error))
		return FALSE;
	fu_redfish_smbios_set_port (self, service_ip_port);

	/* IP address */
	if (!fu_memcpy_safe (service_ip_address, sizeof(service_ip_address), 0x0,	/* dst */
			     buf, bufsz, offset + G_STRUCT_OFFSET(FuRedfishProtocolOverIp,
								  service_ip_address),	/* src */
			     sizeof(service_ip_address), error))
		return FALSE;
	if (!fu_common_read_uint8_safe (buf, bufsz,
					offset + G_STRUCT_OFFSET(FuRedfishProtocolOverIp,
								 service_ip_address_format),
					&service_ip_address_format, error))
		return FALSE;
	if (service_ip_address_format == REDFISH_IP_ADDRESS_FORMAT_V4) {
		g_autofree gchar *tmp = NULL;
		tmp = fu_redfish_common_buffer_to_ipv4 (service_ip_address);
		fu_redfish_smbios_set_ip_addr (self, tmp);
	} else if (service_ip_address_format == REDFISH_IP_ADDRESS_FORMAT_V6) {
		g_autofree gchar *tmp = NULL;
		tmp = fu_redfish_common_buffer_to_ipv6 (service_ip_address);
		fu_redfish_smbios_set_ip_addr (self, tmp);
	} else {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_INVALID_FILE,
				     "address format is invalid");
		return FALSE;
	}

	/* hostname */
	if (!fu_common_read_uint8_safe (buf, bufsz,
					offset + G_STRUCT_OFFSET(FuRedfishProtocolOverIp,
								 service_hostname_len),
					&hostname_length, error))
		return FALSE;
	if (hostname_length > 0) {
		g_autofree gchar *hostname = g_malloc0 (hostname_length + 1);
		if (!fu_memcpy_safe ((guint8 *) hostname, hostname_length, 0x0,			/* dst */
				     buf, bufsz, offset + sizeof(FuRedfishProtocolOverIp),	/* src */
				     hostname_length, error))
			return FALSE;
		fu_redfish_smbios_set_hostname (self, hostname);
	}

	/* success */
	return TRUE;
}

static gboolean
fu_redfish_smbios_parse (FuFirmware *firmware,
			 GBytes *fw,
			 guint64 addr_start,
			 guint64 addr_end,
			 FwupdInstallFlags flags,
			 GError **error)
{
	FuRedfishSmbios *self = FU_REDFISH_SMBIOS (firmware);
	gsize bufsz = 0;
	gsize offset = 0;
	guint8 protocol_rcds = 0;
	const guint8 *buf = g_bytes_get_data (fw, &bufsz);

	/* check size */
	if (bufsz < 0x09) {
		g_set_error (error,
			     FWUPD_ERROR,
			     FWUPD_ERROR_INVALID_FILE,
			     "SMBIOS entry too small: %" G_GSIZE_FORMAT,
			     bufsz);
		return FALSE;
	}

	/* check type */
	if (buf[0x0] != REDFISH_SMBIOS_TABLE_TYPE) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_INVALID_FILE,
				     "not Management Controller Host Interface");
		return FALSE;
	}
	if (buf[0x1] != bufsz) {
		g_set_error (error,
			     FWUPD_ERROR,
			     FWUPD_ERROR_INVALID_FILE,
			     "size of table 0x%x does not match binary 0x%x",
			     buf[0x1], (guint) bufsz);
		return FALSE;
	}

	/* check interface type */
	if (buf[0x04] != REDFISH_CONTROLLER_INTERFACE_TYPE_NETWORK_HOST) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_INVALID_FILE,
				     "only Network Host Interface supported");
		return FALSE;
	}

	/* check length */
	if (buf[0x05] > 0) {
		if (!fu_redfish_smbios_parse_interface_data (self, fw, 0x06, error))
			return FALSE;
	}

	/* parse protocol records */
	if (!fu_common_read_uint8_safe (buf, bufsz, 0x06 + buf[0x05],
					&protocol_rcds, error))
		return FALSE;
	offset = 0x07 + buf[0x05];
	g_debug ("protocol_rcds: %u", protocol_rcds);
	for (guint i = 0; i < protocol_rcds; i++) {
		guint8 protocol_id = 0;
		guint8 protocol_sz = 0;
		if (!fu_common_read_uint8_safe (buf, bufsz, offset,
						&protocol_id, error))
			return FALSE;
		if (!fu_common_read_uint8_safe (buf, bufsz, offset + 0x1,
						&protocol_sz, error))
			return FALSE;
		if (protocol_id == REDFISH_PROTOCOL_REDFISH_OVER_IP) {
			if (!fu_redfish_smbios_parse_over_ip (self, fw, offset + 0x2, error))
				return FALSE;
		} else {
			g_debug ("ignoring protocol ID 0x%02x", protocol_id);
		}
		offset += protocol_sz + 1;
	}

	/* success */
	return TRUE;
}

static GBytes *
fu_redfish_smbios_write (FuFirmware *firmware, GError **error)
{
	FuRedfishProtocolOverIp proto = { 0x0 };
	FuRedfishSmbios *self = FU_REDFISH_SMBIOS (firmware);
	gsize hostname_sz = 0;
	g_autoptr(GByteArray) buf = g_byte_array_new ();

	if (self->hostname != NULL)
		hostname_sz = strlen (self->hostname);
	fu_byte_array_append_uint8 (buf, REDFISH_SMBIOS_TABLE_TYPE);
	fu_byte_array_append_uint8 (buf, 0x6D + hostname_sz);		/* length */
	fu_byte_array_append_uint16 (buf, 0x1234, G_LITTLE_ENDIAN);	/* handle */
	fu_byte_array_append_uint8 (buf, REDFISH_CONTROLLER_INTERFACE_TYPE_NETWORK_HOST);
	fu_byte_array_append_uint8 (buf, 0x09);				/* iface datalen */
	fu_byte_array_append_uint8 (buf, REDFISH_INTERFACE_TYPE_USB_NETWORK);	/* iface */
	fu_byte_array_append_uint16 (buf, self->vid, G_LITTLE_ENDIAN);	/* iface:VID */
	fu_byte_array_append_uint16 (buf, self->pid, G_LITTLE_ENDIAN);	/* iface:PID */
	fu_byte_array_append_uint8 (buf, 0x02);				/* iface:serialsz */
	fu_byte_array_append_uint8 (buf, 0x03);				/* iType */
	fu_byte_array_append_uint8 (buf, 'S');				/* iface:serial */
	fu_byte_array_append_uint8 (buf, 'n');				/* iface:serial */
	fu_byte_array_append_uint8 (buf, 0x1);				/* nr protocol rcds */

	/* protocol record */
	fu_byte_array_append_uint8 (buf, REDFISH_PROTOCOL_REDFISH_OVER_IP);
	fu_byte_array_append_uint8 (buf, sizeof(FuRedfishProtocolOverIp) + hostname_sz);
	if (!fu_common_write_uint16_safe ((guint8 *) &proto, sizeof(proto),
					  G_STRUCT_OFFSET(FuRedfishProtocolOverIp, service_ip_port),
					  self->port, G_LITTLE_ENDIAN, error))
		return NULL;
	if (!fu_common_write_uint8_safe ((guint8 *) &proto, sizeof(proto),
					 G_STRUCT_OFFSET(FuRedfishProtocolOverIp, service_ip_address_format),
					 REDFISH_IP_ADDRESS_FORMAT_V4, error))
		return NULL;
	if (!fu_common_write_uint8_safe ((guint8 *) &proto, sizeof(proto),
					 G_STRUCT_OFFSET(FuRedfishProtocolOverIp, service_ip_assignment_type),
					 REDFISH_IP_ASSIGNMENT_TYPE_STATIC, error))
		return NULL;
	if (self->hostname != NULL)
		hostname_sz = strlen (self->hostname);
	if (hostname_sz > 0) {
		if (!fu_common_write_uint8_safe ((guint8 *) &proto, sizeof(proto),
						 G_STRUCT_OFFSET(FuRedfishProtocolOverIp, service_hostname_len),
						 hostname_sz, error)) {
			g_prefix_error (error, "cannot write length: ");
			return NULL;
		}
	}
	g_byte_array_append (buf, (guint8 *) &proto, sizeof(proto));
	if (hostname_sz > 0)
		g_byte_array_append (buf, (guint8 *) self->hostname, hostname_sz);
	return g_byte_array_free_to_bytes (g_steal_pointer (&buf));
}

static void
fu_redfish_smbios_finalize (GObject *object)
{
	FuRedfishSmbios *self = FU_REDFISH_SMBIOS (object);
	g_free (self->hostname);
	g_free (self->mac_addr);
	g_free (self->ip_addr);
	G_OBJECT_CLASS (fu_redfish_smbios_parent_class)->finalize (object);
}

static void
fu_redfish_smbios_init (FuRedfishSmbios *self)
{
}

static void
fu_redfish_smbios_class_init (FuRedfishSmbiosClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);
	FuFirmwareClass *klass_firmware = FU_FIRMWARE_CLASS (klass);
	object_class->finalize = fu_redfish_smbios_finalize;
	klass_firmware->parse = fu_redfish_smbios_parse;
	klass_firmware->write = fu_redfish_smbios_write;
	klass_firmware->build = fu_redfish_smbios_build;
	klass_firmware->export = fu_redfish_smbios_export;
}

FuRedfishSmbios *
fu_redfish_smbios_new (void)
{
	return FU_REDFISH_SMBIOS (g_object_new (FU_TYPE_REDFISH_SMBIOS, NULL));
}