/work/fu-fmap-struct.c

Source (jump to first uncovered line)
/* auto-generated, do not modify */
#include "config.h"

#include "fu-fmap-struct.h"
#include "fu-byte-array.h"
#include "fu-mem-private.h"
#include "fu-string.h"

#ifdef G_LOG_DOMAIN
  #undef G_LOG_DOMAIN
#endif
#define G_LOG_DOMAIN "FuStruct"
/* getters */
/**
 * fu_struct_fmap_get_signature: (skip):
 **/
static gchar *
fu_struct_fmap_get_signature(const FuStructFmap *st)
{
    g_return_val_if_fail(st != NULL, NULL);
    return fu_memstrsafe(st->data, st->len, 0, 8, NULL);
}
/**
 * fu_struct_fmap_get_ver_major: (skip):
 **/
guint8
fu_struct_fmap_get_ver_major(const FuStructFmap *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return st->data[8];
}
/**
 * fu_struct_fmap_get_ver_minor: (skip):
 **/
guint8
fu_struct_fmap_get_ver_minor(const FuStructFmap *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return st->data[9];
}
/**
 * fu_struct_fmap_get_base: (skip):
 **/
guint64
fu_struct_fmap_get_base(const FuStructFmap *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return fu_memread_uint64(st->data + 10, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_get_size: (skip):
 **/
guint32
fu_struct_fmap_get_size(const FuStructFmap *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return fu_memread_uint32(st->data + 18, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_get_name: (skip):
 **/
gchar *
fu_struct_fmap_get_name(const FuStructFmap *st)
{
    g_return_val_if_fail(st != NULL, NULL);
    return fu_memstrsafe(st->data, st->len, 22, 32, NULL);
}
/**
 * fu_struct_fmap_get_nareas: (skip):
 **/
guint16
fu_struct_fmap_get_nareas(const FuStructFmap *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return fu_memread_uint16(st->data + 54, G_LITTLE_ENDIAN);
}

/* setters */
/**
 * fu_struct_fmap_set_signature: (skip):
 **/
static gboolean
fu_struct_fmap_set_signature(FuStructFmap *st, const gchar *value, GError **error)
{
    gsize len;
    g_return_val_if_fail(st != NULL, FALSE);
    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
    if (value == NULL) {
        memset(st->data + 0, 0x0, 8);
        return TRUE;
    }
    len = strlen(value);
    if (len > 8) {
        g_set_error(error,
                    FWUPD_ERROR,
                    FWUPD_ERROR_INVALID_DATA,
                    "string '%s' (0x%x bytes) does not fit in FuStructFmap.signature (0x%x bytes)",
                    value, (guint) len, (guint) 8);
        return FALSE;
    }
    return fu_memcpy_safe(st->data, st->len, 0, (const guint8 *)value, len, 0x0, len, error);
}
/**
 * fu_struct_fmap_set_ver_major: (skip):
 **/
void
fu_struct_fmap_set_ver_major(FuStructFmap *st, guint8 value)
{
    g_return_if_fail(st != NULL);
    st->data[8] = value;
}
/**
 * fu_struct_fmap_set_ver_minor: (skip):
 **/
void
fu_struct_fmap_set_ver_minor(FuStructFmap *st, guint8 value)
{
    g_return_if_fail(st != NULL);
    st->data[9] = value;
}
/**
 * fu_struct_fmap_set_base: (skip):
 **/
void
fu_struct_fmap_set_base(FuStructFmap *st, guint64 value)
{
    g_return_if_fail(st != NULL);
    fu_memwrite_uint64(st->data + 10, value, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_set_size: (skip):
 **/
void
fu_struct_fmap_set_size(FuStructFmap *st, guint32 value)
{
    g_return_if_fail(st != NULL);
    fu_memwrite_uint32(st->data + 18, value, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_set_name: (skip):
 **/
gboolean
fu_struct_fmap_set_name(FuStructFmap *st, const gchar *value, GError **error)
{
    gsize len;
    g_return_val_if_fail(st != NULL, FALSE);
    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
    if (value == NULL) {
        memset(st->data + 22, 0x0, 32);
        return TRUE;
    }
    len = strlen(value);
    if (len > 32) {
        g_set_error(error,
                    FWUPD_ERROR,
                    FWUPD_ERROR_INVALID_DATA,
                    "string '%s' (0x%x bytes) does not fit in FuStructFmap.name (0x%x bytes)",
                    value, (guint) len, (guint) 32);
        return FALSE;
    }
    return fu_memcpy_safe(st->data, st->len, 22, (const guint8 *)value, len, 0x0, len, error);
}
/**
 * fu_struct_fmap_set_nareas: (skip):
 **/
void
fu_struct_fmap_set_nareas(FuStructFmap *st, guint16 value)
{
    g_return_if_fail(st != NULL);
    fu_memwrite_uint16(st->data + 54, value, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_new: (skip):
 **/
FuStructFmap *
fu_struct_fmap_new(void)
{
    FuStructFmap *st = g_byte_array_sized_new(56);
    fu_byte_array_set_size(st, 56, 0x0);
    fu_struct_fmap_set_signature(st, "__FMAP__", NULL);
    fu_struct_fmap_set_ver_major(st, 0x1);
    fu_struct_fmap_set_ver_minor(st, 0x1);
    return st;
}
/**
 * fu_struct_fmap_to_string: (skip):
 **/
static gchar *
fu_struct_fmap_to_string(const FuStructFmap *st)
{
    g_autoptr(GString) str = g_string_new("FuStructFmap:\n");
    g_return_val_if_fail(st != NULL, NULL);
    g_string_append_printf(str, "  ver_major: 0x%x\n",
                           (guint) fu_struct_fmap_get_ver_major(st));
    g_string_append_printf(str, "  ver_minor: 0x%x\n",
                           (guint) fu_struct_fmap_get_ver_minor(st));
    g_string_append_printf(str, "  base: 0x%x\n",
                           (guint) fu_struct_fmap_get_base(st));
    g_string_append_printf(str, "  size: 0x%x\n",
                           (guint) fu_struct_fmap_get_size(st));
    {
        g_autofree gchar *tmp = fu_struct_fmap_get_name(st);
        if (tmp != NULL)
            g_string_append_printf(str, "  name: %s\n", tmp);
    }
    g_string_append_printf(str, "  nareas: 0x%x\n",
                           (guint) fu_struct_fmap_get_nareas(st));
    if (str->len > 0)
        g_string_set_size(str, str->len - 1);
    return g_string_free(g_steal_pointer(&str), FALSE);
}
static gboolean
fu_struct_fmap_validate_internal(FuStructFmap *st, GError **error)
{
    g_return_val_if_fail(st != NULL, FALSE);
    if (strncmp((const gchar *) (st->data + 0), "__FMAP__", 8) != 0) {
        g_autofree gchar *str = fu_struct_fmap_get_signature(st);
        g_set_error(error,
                    FWUPD_ERROR,
                    FWUPD_ERROR_INVALID_DATA,
                    "constant FuStructFmap.signature was not valid, "
                    "expected '__FMAP__' and got '%s'",
                    str);
        return FALSE;
    }
    return TRUE;
}
/**
 * fu_struct_fmap_validate_stream: (skip):
 **/
gboolean
fu_struct_fmap_validate_stream(GInputStream *stream, gsize offset, GError **error)
{
    g_autoptr(GByteArray) st = NULL;
    g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE);
    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
    st = fu_input_stream_read_byte_array(stream, offset, 56, NULL, error);
    if (st == NULL) {
        g_prefix_error(error, "FuStructFmap failed read of 0x%x: ", (guint) 56);
        return FALSE;
    }
    if (st->len != 56) {
        g_set_error(error,
                    FWUPD_ERROR,
                    FWUPD_ERROR_INVALID_DATA,
                    "FuStructFmap requested 0x%x and got 0x%x",
                    (guint) 56,
                    (guint) st->len);
        return FALSE;
    }
    return fu_struct_fmap_validate_internal(st, error);
}
static gboolean
fu_struct_fmap_parse_internal(FuStructFmap *st, GError **error)
{
    if (g_getenv("FWUPD_VERBOSE") != NULL) {
        g_autofree gchar *str = fu_struct_fmap_to_string(st);
        g_debug("%s", str);
    }
    if (!fu_struct_fmap_validate_internal(st, error))
        return FALSE;
    return TRUE;
}
/**
 * fu_struct_fmap_parse_stream: (skip):
 **/
FuStructFmap *
fu_struct_fmap_parse_stream(GInputStream *stream, gsize offset, GError **error)
{
    g_autoptr(GByteArray) st = NULL;
    st = fu_input_stream_read_byte_array(stream, offset, 56, NULL, error);
    if (st == NULL) {
        g_prefix_error(error, "FuStructFmap failed read of 0x%x: ", (guint) 56);
        return NULL;
    }
    if (st->len != 56) {
        g_set_error(error,
                    FWUPD_ERROR,
                    FWUPD_ERROR_INVALID_DATA,
                    "FuStructFmap requested 0x%x and got 0x%x",
                    (guint) 56,
                    (guint) st->len);
        return NULL;
    }
    if (!fu_struct_fmap_parse_internal(st, error))
        return NULL;
    return g_steal_pointer(&st);
}
/* getters */
/**
 * fu_struct_fmap_area_get_offset: (skip):
 **/
guint32
fu_struct_fmap_area_get_offset(const FuStructFmapArea *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return fu_memread_uint32(st->data + 0, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_area_get_size: (skip):
 **/
guint32
fu_struct_fmap_area_get_size(const FuStructFmapArea *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return fu_memread_uint32(st->data + 4, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_area_get_name: (skip):
 **/
gchar *
fu_struct_fmap_area_get_name(const FuStructFmapArea *st)
{
    g_return_val_if_fail(st != NULL, NULL);
    return fu_memstrsafe(st->data, st->len, 8, 32, NULL);
}
/**
 * fu_struct_fmap_area_get_flags: (skip):
 **/
guint16
fu_struct_fmap_area_get_flags(const FuStructFmapArea *st)
{
    g_return_val_if_fail(st != NULL, 0x0);
    return fu_memread_uint16(st->data + 40, G_LITTLE_ENDIAN);
}

/* setters */
/**
 * fu_struct_fmap_area_set_offset: (skip):
 **/
void
fu_struct_fmap_area_set_offset(FuStructFmapArea *st, guint32 value)
{
    g_return_if_fail(st != NULL);
    fu_memwrite_uint32(st->data + 0, value, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_area_set_size: (skip):
 **/
void
fu_struct_fmap_area_set_size(FuStructFmapArea *st, guint32 value)
{
    g_return_if_fail(st != NULL);
    fu_memwrite_uint32(st->data + 4, value, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_area_set_name: (skip):
 **/
gboolean
fu_struct_fmap_area_set_name(FuStructFmapArea *st, const gchar *value, GError **error)
{
    gsize len;
    g_return_val_if_fail(st != NULL, FALSE);
    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
    if (value == NULL) {
        memset(st->data + 8, 0x0, 32);
        return TRUE;
    }
    len = strlen(value);
    if (len > 32) {
        g_set_error(error,
                    FWUPD_ERROR,
                    FWUPD_ERROR_INVALID_DATA,
                    "string '%s' (0x%x bytes) does not fit in FuStructFmapArea.name (0x%x bytes)",
                    value, (guint) len, (guint) 32);
        return FALSE;
    }
    return fu_memcpy_safe(st->data, st->len, 8, (const guint8 *)value, len, 0x0, len, error);
}
/**
 * fu_struct_fmap_area_set_flags: (skip):
 **/
void
fu_struct_fmap_area_set_flags(FuStructFmapArea *st, guint16 value)
{
    g_return_if_fail(st != NULL);
    fu_memwrite_uint16(st->data + 40, value, G_LITTLE_ENDIAN);
}
/**
 * fu_struct_fmap_area_new: (skip):
 **/
FuStructFmapArea *
fu_struct_fmap_area_new(void)
{
    FuStructFmapArea *st = g_byte_array_sized_new(42);
    fu_byte_array_set_size(st, 42, 0x0);
    return st;
}
/**
 * fu_struct_fmap_area_to_string: (skip):
 **/
static gchar *
fu_struct_fmap_area_to_string(const FuStructFmapArea *st)
{
    g_autoptr(GString) str = g_string_new("FuStructFmapArea:\n");
    g_return_val_if_fail(st != NULL, NULL);
    g_string_append_printf(str, "  offset: 0x%x\n",
                           (guint) fu_struct_fmap_area_get_offset(st));
    g_string_append_printf(str, "  size: 0x%x\n",
                           (guint) fu_struct_fmap_area_get_size(st));
    {
        g_autofree gchar *tmp = fu_struct_fmap_area_get_name(st);
        if (tmp != NULL)
            g_string_append_printf(str, "  name: %s\n", tmp);
    }
    g_string_append_printf(str, "  flags: 0x%x\n",
                           (guint) fu_struct_fmap_area_get_flags(st));
    if (str->len > 0)
        g_string_set_size(str, str->len - 1);
    return g_string_free(g_steal_pointer(&str), FALSE);
}
static gboolean
fu_struct_fmap_area_validate_internal(FuStructFmapArea *st, GError **error)
{
    g_return_val_if_fail(st != NULL, FALSE);
    return TRUE;
}
static gboolean
fu_struct_fmap_area_parse_internal(FuStructFmapArea *st, GError **error)
{
    if (g_getenv("FWUPD_VERBOSE") != NULL) {
        g_autofree gchar *str = fu_struct_fmap_area_to_string(st);
        g_debug("%s", str);
    }
    if (!fu_struct_fmap_area_validate_internal(st, error))
        return FALSE;
    return TRUE;
}
/**
 * fu_struct_fmap_area_parse_stream: (skip):
 **/
FuStructFmapArea *
fu_struct_fmap_area_parse_stream(GInputStream *stream, gsize offset, GError **error)
{
    g_autoptr(GByteArray) st = NULL;
    st = fu_input_stream_read_byte_array(stream, offset, 42, NULL, error);
    if (st == NULL) {
        g_prefix_error(error, "FuStructFmapArea failed read of 0x%x: ", (guint) 42);
        return NULL;
    }
    if (st->len != 42) {
        g_set_error(error,
                    FWUPD_ERROR,
                    FWUPD_ERROR_INVALID_DATA,
                    "FuStructFmapArea requested 0x%x and got 0x%x",
                    (guint) 42,
                    (guint) st->len);
        return NULL;
    }
    if (!fu_struct_fmap_area_parse_internal(st, error))
        return NULL;
    return g_steal_pointer(&st);
}

Coverage Report

Created: 2025-07-11 06:31

Line	Count	Source (jump to first uncovered line)
1		/* auto-generated, do not modify */
2		#include "config.h"
3
4		#include "fu-fmap-struct.h"
5		#include "fu-byte-array.h"
6		#include "fu-mem-private.h"
7		#include "fu-string.h"
8
9		#ifdef G_LOG_DOMAIN
10		#undef G_LOG_DOMAIN
11		#endif
12	0	#define G_LOG_DOMAIN "FuStruct"
13		/* getters */
14		/**
15		* fu_struct_fmap_get_signature: (skip):
16		**/
17		static gchar *
18		fu_struct_fmap_get_signature(const FuStructFmap *st)
19	0	{
20	0	g_return_val_if_fail(st != NULL, NULL);
21	0	return fu_memstrsafe(st->data, st->len, 0, 8, NULL);
22	0	}
23		/**
24		* fu_struct_fmap_get_ver_major: (skip):
25		**/
26		guint8
27		fu_struct_fmap_get_ver_major(const FuStructFmap *st)
28	1.87k	{
29	1.87k	g_return_val_if_fail(st != NULL, 0x0);
30	1.87k	return st->data[8];
31	1.87k	}
32		/**
33		* fu_struct_fmap_get_ver_minor: (skip):
34		**/
35		guint8
36		fu_struct_fmap_get_ver_minor(const FuStructFmap *st)
37	1.87k	{
38	1.87k	g_return_val_if_fail(st != NULL, 0x0);
39	1.87k	return st->data[9];
40	1.87k	}
41		/**
42		* fu_struct_fmap_get_base: (skip):
43		**/
44		guint64
45		fu_struct_fmap_get_base(const FuStructFmap *st)
46	680	{
47	680	g_return_val_if_fail(st != NULL, 0x0);
48	680	return fu_memread_uint64(st->data + 10, G_LITTLE_ENDIAN);
49	680	}
50		/**
51		* fu_struct_fmap_get_size: (skip):
52		**/
53		guint32
54		fu_struct_fmap_get_size(const FuStructFmap *st)
55	839	{
56	839	g_return_val_if_fail(st != NULL, 0x0);
57	839	return fu_memread_uint32(st->data + 18, G_LITTLE_ENDIAN);
58	839	}
59		/**
60		* fu_struct_fmap_get_name: (skip):
61		**/
62		gchar *
63		fu_struct_fmap_get_name(const FuStructFmap *st)
64	0	{
65	0	g_return_val_if_fail(st != NULL, NULL);
66	0	return fu_memstrsafe(st->data, st->len, 22, 32, NULL);
67	0	}
68		/**
69		* fu_struct_fmap_get_nareas: (skip):
70		**/
71		guint16
72		fu_struct_fmap_get_nareas(const FuStructFmap *st)
73	521	{
74	521	g_return_val_if_fail(st != NULL, 0x0);
75	521	return fu_memread_uint16(st->data + 54, G_LITTLE_ENDIAN);
76	521	}
77
78		/* setters */
79		/**
80		* fu_struct_fmap_set_signature: (skip):
81		**/
82		static gboolean
83		fu_struct_fmap_set_signature(FuStructFmap st, const gchar value, GError **error)
84	180	{
85	180	gsize len;
86	180	g_return_val_if_fail(st != NULL, FALSE);
87	180	g_return_val_if_fail(error == NULL \|\| *error == NULL, FALSE);
88	180	if (value == NULL) {
89	0	memset(st->data + 0, 0x0, 8);
90	0	return TRUE;
91	0	}
92	180	len = strlen(value);
93	180	if (len > 8) {
94	0	g_set_error(error,
95	0	FWUPD_ERROR,
96	0	FWUPD_ERROR_INVALID_DATA,
97	0	"string '%s' (0x%x bytes) does not fit in FuStructFmap.signature (0x%x bytes)",
98	0	value, (guint) len, (guint) 8);
99	0	return FALSE;
100	0	}
101	180	return fu_memcpy_safe(st->data, st->len, 0, (const guint8 *)value, len, 0x0, len, error);
102	180	}
103		/**
104		* fu_struct_fmap_set_ver_major: (skip):
105		**/
106		void
107		fu_struct_fmap_set_ver_major(FuStructFmap *st, guint8 value)
108	180	{
109	180	g_return_if_fail(st != NULL);
110	180	st->data[8] = value;
111	180	}
112		/**
113		* fu_struct_fmap_set_ver_minor: (skip):
114		**/
115		void
116		fu_struct_fmap_set_ver_minor(FuStructFmap *st, guint8 value)
117	180	{
118	180	g_return_if_fail(st != NULL);
119	180	st->data[9] = value;
120	180	}
121		/**
122		* fu_struct_fmap_set_base: (skip):
123		**/
124		void
125		fu_struct_fmap_set_base(FuStructFmap *st, guint64 value)
126	90	{
127	90	g_return_if_fail(st != NULL);
128	90	fu_memwrite_uint64(st->data + 10, value, G_LITTLE_ENDIAN);
129	90	}
130		/**
131		* fu_struct_fmap_set_size: (skip):
132		**/
133		void
134		fu_struct_fmap_set_size(FuStructFmap *st, guint32 value)
135	90	{
136	90	g_return_if_fail(st != NULL);
137	90	fu_memwrite_uint32(st->data + 18, value, G_LITTLE_ENDIAN);
138	90	}
139		/**
140		* fu_struct_fmap_set_name: (skip):
141		**/
142		gboolean
143		fu_struct_fmap_set_name(FuStructFmap st, const gchar value, GError **error)
144	0	{
145	0	gsize len;
146	0	g_return_val_if_fail(st != NULL, FALSE);
147	0	g_return_val_if_fail(error == NULL \|\| *error == NULL, FALSE);
148	0	if (value == NULL) {
149	0	memset(st->data + 22, 0x0, 32);
150	0	return TRUE;
151	0	}
152	0	len = strlen(value);
153	0	if (len > 32) {
154	0	g_set_error(error,
155	0	FWUPD_ERROR,
156	0	FWUPD_ERROR_INVALID_DATA,
157	0	"string '%s' (0x%x bytes) does not fit in FuStructFmap.name (0x%x bytes)",
158	0	value, (guint) len, (guint) 32);
159	0	return FALSE;
160	0	}
161	0	return fu_memcpy_safe(st->data, st->len, 22, (const guint8 *)value, len, 0x0, len, error);
162	0	}
163		/**
164		* fu_struct_fmap_set_nareas: (skip):
165		**/
166		void
167		fu_struct_fmap_set_nareas(FuStructFmap *st, guint16 value)
168	90	{
169	90	g_return_if_fail(st != NULL);
170	90	fu_memwrite_uint16(st->data + 54, value, G_LITTLE_ENDIAN);
171	90	}
172		/**
173		* fu_struct_fmap_new: (skip):
174		**/
175		FuStructFmap *
176		fu_struct_fmap_new(void)
177	180	{
178	180	FuStructFmap *st = g_byte_array_sized_new(56);
179	180	fu_byte_array_set_size(st, 56, 0x0);
180	180	fu_struct_fmap_set_signature(st, "__FMAP__", NULL);
181	180	fu_struct_fmap_set_ver_major(st, 0x1);
182	180	fu_struct_fmap_set_ver_minor(st, 0x1);
183	180	return st;
184	180	}
185		/**
186		* fu_struct_fmap_to_string: (skip):
187		**/
188		static gchar *
189		fu_struct_fmap_to_string(const FuStructFmap *st)
190	0	{
191	0	g_autoptr(GString) str = g_string_new("FuStructFmap:\n");
192	0	g_return_val_if_fail(st != NULL, NULL);
193	0	g_string_append_printf(str, " ver_major: 0x%x\n",
194	0	(guint) fu_struct_fmap_get_ver_major(st));
195	0	g_string_append_printf(str, " ver_minor: 0x%x\n",
196	0	(guint) fu_struct_fmap_get_ver_minor(st));
197	0	g_string_append_printf(str, " base: 0x%x\n",
198	0	(guint) fu_struct_fmap_get_base(st));
199	0	g_string_append_printf(str, " size: 0x%x\n",
200	0	(guint) fu_struct_fmap_get_size(st));
201	0	{
202	0	g_autofree gchar *tmp = fu_struct_fmap_get_name(st);
203	0	if (tmp != NULL)
204	0	g_string_append_printf(str, " name: %s\n", tmp);
205	0	}
206	0	g_string_append_printf(str, " nareas: 0x%x\n",
207	0	(guint) fu_struct_fmap_get_nareas(st));
208	0	if (str->len > 0)
209	0	g_string_set_size(str, str->len - 1);
210	0	return g_string_free(g_steal_pointer(&str), FALSE);
211	0	}
212		static gboolean
213		fu_struct_fmap_validate_internal(FuStructFmap st, GError *error)
214	680	{
215	680	g_return_val_if_fail(st != NULL, FALSE);
216	680	if (strncmp((const gchar *) (st->data + 0), "__FMAP__", 8) != 0) {
217	0	g_autofree gchar *str = fu_struct_fmap_get_signature(st);
218	0	g_set_error(error,
219	0	FWUPD_ERROR,
220	0	FWUPD_ERROR_INVALID_DATA,
221	0	"constant FuStructFmap.signature was not valid, "
222	0	"expected '__FMAP__' and got '%s'",
223	0	str);
224	0	return FALSE;
225	0	}
226	680	return TRUE;
227	680	}
228		/**
229		* fu_struct_fmap_validate_stream: (skip):
230		**/
231		gboolean
232		fu_struct_fmap_validate_stream(GInputStream stream, gsize offset, GError *error)
233	0	{
234	0	g_autoptr(GByteArray) st = NULL;
235	0	g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE);
236	0	g_return_val_if_fail(error == NULL \|\| *error == NULL, FALSE);
237	0	st = fu_input_stream_read_byte_array(stream, offset, 56, NULL, error);
238	0	if (st == NULL) {
239	0	g_prefix_error(error, "FuStructFmap failed read of 0x%x: ", (guint) 56);
240	0	return FALSE;
241	0	}
242	0	if (st->len != 56) {
243	0	g_set_error(error,
244	0	FWUPD_ERROR,
245	0	FWUPD_ERROR_INVALID_DATA,
246	0	"FuStructFmap requested 0x%x and got 0x%x",
247	0	(guint) 56,
248	0	(guint) st->len);
249	0	return FALSE;
250	0	}
251	0	return fu_struct_fmap_validate_internal(st, error);
252	0	}
253		static gboolean
254		fu_struct_fmap_parse_internal(FuStructFmap st, GError *error)
255	680	{
256	680	if (g_getenv("FWUPD_VERBOSE") != NULL) {
257	0	g_autofree gchar *str = fu_struct_fmap_to_string(st);
258	0	g_debug("%s", str);
259	0	}
260	680	if (!fu_struct_fmap_validate_internal(st, error))
261	0	return FALSE;
262	680	return TRUE;
263	680	}
264		/**
265		* fu_struct_fmap_parse_stream: (skip):
266		**/
267		FuStructFmap *
268		fu_struct_fmap_parse_stream(GInputStream stream, gsize offset, GError *error)
269	740	{
270	740	g_autoptr(GByteArray) st = NULL;
271	740	st = fu_input_stream_read_byte_array(stream, offset, 56, NULL, error);
272	740	if (st == NULL) {
273	0	g_prefix_error(error, "FuStructFmap failed read of 0x%x: ", (guint) 56);
274	0	return NULL;
275	0	}
276	740	if (st->len != 56) {
277	60	g_set_error(error,
278	60	FWUPD_ERROR,
279	60	FWUPD_ERROR_INVALID_DATA,
280	60	"FuStructFmap requested 0x%x and got 0x%x",
281	60	(guint) 56,
282	60	(guint) st->len);
283	60	return NULL;
284	60	}
285	680	if (!fu_struct_fmap_parse_internal(st, error))
286	0	return NULL;
287	680	return g_steal_pointer(&st);
288	680	}
289		/* getters */
290		/**
291		* fu_struct_fmap_area_get_offset: (skip):
292		**/
293		guint32
294		fu_struct_fmap_area_get_offset(const FuStructFmapArea *st)
295	13.6k	{
296	13.6k	g_return_val_if_fail(st != NULL, 0x0);
297	13.6k	return fu_memread_uint32(st->data + 0, G_LITTLE_ENDIAN);
298	13.6k	}
299		/**
300		* fu_struct_fmap_area_get_size: (skip):
301		**/
302		guint32
303		fu_struct_fmap_area_get_size(const FuStructFmapArea *st)
304	4.02M	{
305	4.02M	g_return_val_if_fail(st != NULL, 0x0);
306	4.02M	return fu_memread_uint32(st->data + 4, G_LITTLE_ENDIAN);
307	4.02M	}
308		/**
309		* fu_struct_fmap_area_get_name: (skip):
310		**/
311		gchar *
312		fu_struct_fmap_area_get_name(const FuStructFmapArea *st)
313	13.4k	{
314	13.4k	g_return_val_if_fail(st != NULL, NULL);
315	13.4k	return fu_memstrsafe(st->data, st->len, 8, 32, NULL);
316	13.4k	}
317		/**
318		* fu_struct_fmap_area_get_flags: (skip):
319		**/
320		guint16
321		fu_struct_fmap_area_get_flags(const FuStructFmapArea *st)
322	0	{
323	0	g_return_val_if_fail(st != NULL, 0x0);
324	0	return fu_memread_uint16(st->data + 40, G_LITTLE_ENDIAN);
325	0	}
326
327		/* setters */
328		/**
329		* fu_struct_fmap_area_set_offset: (skip):
330		**/
331		void
332		fu_struct_fmap_area_set_offset(FuStructFmapArea *st, guint32 value)
333	0	{
334	0	g_return_if_fail(st != NULL);
335	0	fu_memwrite_uint32(st->data + 0, value, G_LITTLE_ENDIAN);
336	0	}
337		/**
338		* fu_struct_fmap_area_set_size: (skip):
339		**/
340		void
341		fu_struct_fmap_area_set_size(FuStructFmapArea *st, guint32 value)
342	0	{
343	0	g_return_if_fail(st != NULL);
344	0	fu_memwrite_uint32(st->data + 4, value, G_LITTLE_ENDIAN);
345	0	}
346		/**
347		* fu_struct_fmap_area_set_name: (skip):
348		**/
349		gboolean
350		fu_struct_fmap_area_set_name(FuStructFmapArea st, const gchar value, GError **error)
351	0	{
352	0	gsize len;
353	0	g_return_val_if_fail(st != NULL, FALSE);
354	0	g_return_val_if_fail(error == NULL \|\| *error == NULL, FALSE);
355	0	if (value == NULL) {
356	0	memset(st->data + 8, 0x0, 32);
357	0	return TRUE;
358	0	}
359	0	len = strlen(value);
360	0	if (len > 32) {
361	0	g_set_error(error,
362	0	FWUPD_ERROR,
363	0	FWUPD_ERROR_INVALID_DATA,
364	0	"string '%s' (0x%x bytes) does not fit in FuStructFmapArea.name (0x%x bytes)",
365	0	value, (guint) len, (guint) 32);
366	0	return FALSE;
367	0	}
368	0	return fu_memcpy_safe(st->data, st->len, 8, (const guint8 *)value, len, 0x0, len, error);
369	0	}
370		/**
371		* fu_struct_fmap_area_set_flags: (skip):
372		**/
373		void
374		fu_struct_fmap_area_set_flags(FuStructFmapArea *st, guint16 value)
375	0	{
376	0	g_return_if_fail(st != NULL);
377	0	fu_memwrite_uint16(st->data + 40, value, G_LITTLE_ENDIAN);
378	0	}
379		/**
380		* fu_struct_fmap_area_new: (skip):
381		**/
382		FuStructFmapArea *
383		fu_struct_fmap_area_new(void)
384	0	{
385	0	FuStructFmapArea *st = g_byte_array_sized_new(42);
386	0	fu_byte_array_set_size(st, 42, 0x0);
387	0	return st;
388	0	}
389		/**
390		* fu_struct_fmap_area_to_string: (skip):
391		**/
392		static gchar *
393		fu_struct_fmap_area_to_string(const FuStructFmapArea *st)
394	0	{
395	0	g_autoptr(GString) str = g_string_new("FuStructFmapArea:\n");
396	0	g_return_val_if_fail(st != NULL, NULL);
397	0	g_string_append_printf(str, " offset: 0x%x\n",
398	0	(guint) fu_struct_fmap_area_get_offset(st));
399	0	g_string_append_printf(str, " size: 0x%x\n",
400	0	(guint) fu_struct_fmap_area_get_size(st));
401	0	{
402	0	g_autofree gchar *tmp = fu_struct_fmap_area_get_name(st);
403	0	if (tmp != NULL)
404	0	g_string_append_printf(str, " name: %s\n", tmp);
405	0	}
406	0	g_string_append_printf(str, " flags: 0x%x\n",
407	0	(guint) fu_struct_fmap_area_get_flags(st));
408	0	if (str->len > 0)
409	0	g_string_set_size(str, str->len - 1);
410	0	return g_string_free(g_steal_pointer(&str), FALSE);
411	0	}
412		static gboolean
413		fu_struct_fmap_area_validate_internal(FuStructFmapArea st, GError *error)
414	4.02M	{
415	4.02M	g_return_val_if_fail(st != NULL, FALSE);
416	4.02M	return TRUE;
417	4.02M	}
418		static gboolean
419		fu_struct_fmap_area_parse_internal(FuStructFmapArea st, GError *error)
420	4.02M	{
421	4.02M	if (g_getenv("FWUPD_VERBOSE") != NULL) {
422	0	g_autofree gchar *str = fu_struct_fmap_area_to_string(st);
423	0	g_debug("%s", str);
424	0	}
425	4.02M	if (!fu_struct_fmap_area_validate_internal(st, error))
426	0	return FALSE;
427	4.02M	return TRUE;
428	4.02M	}
429		/**
430		* fu_struct_fmap_area_parse_stream: (skip):
431		**/
432		FuStructFmapArea *
433		fu_struct_fmap_area_parse_stream(GInputStream stream, gsize offset, GError *error)
434	4.02M	{
435	4.02M	g_autoptr(GByteArray) st = NULL;
436	4.02M	st = fu_input_stream_read_byte_array(stream, offset, 42, NULL, error);
437	4.02M	if (st == NULL) {
438	105	g_prefix_error(error, "FuStructFmapArea failed read of 0x%x: ", (guint) 42);
439	105	return NULL;
440	105	}
441	4.02M	if (st->len != 42) {
442	65	g_set_error(error,
443	65	FWUPD_ERROR,
444	65	FWUPD_ERROR_INVALID_DATA,
445	65	"FuStructFmapArea requested 0x%x and got 0x%x",
446	65	(guint) 42,
447	65	(guint) st->len);
448	65	return NULL;
449	65	}
450	4.02M	if (!fu_struct_fmap_area_parse_internal(st, error))
451	0	return NULL;
452	4.02M	return g_steal_pointer(&st);
453	4.02M	}