Coverage Report

Created: 2025-07-01 07:09

/work/fu-elf-struct.c
Line
Count
Source (jump to first uncovered line)
1
/* auto-generated, do not modify */
2
#include "config.h"
3
4
#include "fu-elf-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
14
static const gchar *
15
fu_elf_file_header_type_to_string(FuElfFileHeaderType val)
16
0
{
17
0
    if (val == FU_ELF_FILE_HEADER_TYPE_NONE)
18
0
        return "none";
19
0
    if (val == FU_ELF_FILE_HEADER_TYPE_REL)
20
0
        return "rel";
21
0
    if (val == FU_ELF_FILE_HEADER_TYPE_EXEC)
22
0
        return "exec";
23
0
    if (val == FU_ELF_FILE_HEADER_TYPE_DYN)
24
0
        return "dyn";
25
0
    if (val == FU_ELF_FILE_HEADER_TYPE_CORE)
26
0
        return "core";
27
0
    return NULL;
28
0
}
29
30
const gchar *
31
fu_elf_section_header_type_to_string(FuElfSectionHeaderType val)
32
136
{
33
136
    if (val == FU_ELF_SECTION_HEADER_TYPE_NULL)
34
5
        return "null";
35
131
    if (val == FU_ELF_SECTION_HEADER_TYPE_PROGBITS)
36
1
        return "progbits";
37
130
    if (val == FU_ELF_SECTION_HEADER_TYPE_SYMTAB)
38
1
        return "symtab";
39
129
    if (val == FU_ELF_SECTION_HEADER_TYPE_STRTAB)
40
0
        return "strtab";
41
129
    if (val == FU_ELF_SECTION_HEADER_TYPE_RELA)
42
1
        return "rela";
43
128
    if (val == FU_ELF_SECTION_HEADER_TYPE_HASH)
44
1
        return "hash";
45
127
    if (val == FU_ELF_SECTION_HEADER_TYPE_DYNAMIC)
46
1
        return "dynamic";
47
126
    if (val == FU_ELF_SECTION_HEADER_TYPE_NOTE)
48
1
        return "note";
49
125
    if (val == FU_ELF_SECTION_HEADER_TYPE_NOBITS)
50
1
        return "nobits";
51
124
    if (val == FU_ELF_SECTION_HEADER_TYPE_REL)
52
1
        return "rel";
53
123
    if (val == FU_ELF_SECTION_HEADER_TYPE_SHLIB)
54
1
        return "shlib";
55
122
    if (val == FU_ELF_SECTION_HEADER_TYPE_DYNSYM)
56
1
        return "dynsym";
57
121
    if (val == FU_ELF_SECTION_HEADER_TYPE_INIT_ARRAY)
58
1
        return "init-array";
59
120
    if (val == FU_ELF_SECTION_HEADER_TYPE_FINI_ARRAY)
60
1
        return "fini-array";
61
119
    if (val == FU_ELF_SECTION_HEADER_TYPE_PREINIT_ARRAY)
62
1
        return "preinit-array";
63
118
    if (val == FU_ELF_SECTION_HEADER_TYPE_GROUP)
64
1
        return "group";
65
117
    if (val == FU_ELF_SECTION_HEADER_TYPE_SYMTAB_SHNDX)
66
1
        return "symtab-shndx";
67
116
    if (val == FU_ELF_SECTION_HEADER_TYPE_NUM)
68
1
        return "num";
69
115
    return NULL;
70
116
}
71
/* getters */
72
/**
73
 * fu_struct_elf_file_header64le_get_ei_class: (skip):
74
 **/
75
static guint8
76
fu_struct_elf_file_header64le_get_ei_class(const FuStructElfFileHeader64le *st)
77
3.56k
{
78
3.56k
    g_return_val_if_fail(st != NULL, 0x0);
79
3.56k
    return st->data[4];
80
3.56k
}
81
/**
82
 * fu_struct_elf_file_header64le_get_ei_data: (skip):
83
 **/
84
static guint8
85
fu_struct_elf_file_header64le_get_ei_data(const FuStructElfFileHeader64le *st)
86
3.21k
{
87
3.21k
    g_return_val_if_fail(st != NULL, 0x0);
88
3.21k
    return st->data[5];
89
3.21k
}
90
/**
91
 * fu_struct_elf_file_header64le_get_ei_version: (skip):
92
 **/
93
static guint8
94
fu_struct_elf_file_header64le_get_ei_version(const FuStructElfFileHeader64le *st)
95
2.86k
{
96
2.86k
    g_return_val_if_fail(st != NULL, 0x0);
97
2.86k
    return st->data[6];
98
2.86k
}
99
/**
100
 * fu_struct_elf_file_header64le_get_ei_osabi: (skip):
101
 **/
102
guint8
103
fu_struct_elf_file_header64le_get_ei_osabi(const FuStructElfFileHeader64le *st)
104
0
{
105
0
    g_return_val_if_fail(st != NULL, 0x0);
106
0
    return st->data[7];
107
0
}
108
/**
109
 * fu_struct_elf_file_header64le_get_ei_abiversion: (skip):
110
 **/
111
guint8
112
fu_struct_elf_file_header64le_get_ei_abiversion(const FuStructElfFileHeader64le *st)
113
0
{
114
0
    g_return_val_if_fail(st != NULL, 0x0);
115
0
    return st->data[8];
116
0
}
117
/**
118
 * fu_struct_elf_file_header64le_get_type: (skip):
119
 **/
120
FuElfFileHeaderType
121
fu_struct_elf_file_header64le_get_type(const FuStructElfFileHeader64le *st)
122
0
{
123
0
    g_return_val_if_fail(st != NULL, 0x0);
124
0
    return fu_memread_uint16(st->data + 16, G_LITTLE_ENDIAN);
125
0
}
126
/**
127
 * fu_struct_elf_file_header64le_get_machine: (skip):
128
 **/
129
guint16
130
fu_struct_elf_file_header64le_get_machine(const FuStructElfFileHeader64le *st)
131
0
{
132
0
    g_return_val_if_fail(st != NULL, 0x0);
133
0
    return fu_memread_uint16(st->data + 18, G_LITTLE_ENDIAN);
134
0
}
135
/**
136
 * fu_struct_elf_file_header64le_get_version: (skip):
137
 **/
138
static guint32
139
fu_struct_elf_file_header64le_get_version(const FuStructElfFileHeader64le *st)
140
2.58k
{
141
2.58k
    g_return_val_if_fail(st != NULL, 0x0);
142
2.58k
    return fu_memread_uint32(st->data + 20, G_LITTLE_ENDIAN);
143
2.58k
}
144
/**
145
 * fu_struct_elf_file_header64le_get_entry: (skip):
146
 **/
147
guint64
148
fu_struct_elf_file_header64le_get_entry(const FuStructElfFileHeader64le *st)
149
0
{
150
0
    g_return_val_if_fail(st != NULL, 0x0);
151
0
    return fu_memread_uint64(st->data + 24, G_LITTLE_ENDIAN);
152
0
}
153
/**
154
 * fu_struct_elf_file_header64le_get_phoff: (skip):
155
 **/
156
guint64
157
fu_struct_elf_file_header64le_get_phoff(const FuStructElfFileHeader64le *st)
158
1.06k
{
159
1.06k
    g_return_val_if_fail(st != NULL, 0x0);
160
1.06k
    return fu_memread_uint64(st->data + 32, G_LITTLE_ENDIAN);
161
1.06k
}
162
/**
163
 * fu_struct_elf_file_header64le_get_shoff: (skip):
164
 **/
165
guint64
166
fu_struct_elf_file_header64le_get_shoff(const FuStructElfFileHeader64le *st)
167
903
{
168
903
    g_return_val_if_fail(st != NULL, 0x0);
169
903
    return fu_memread_uint64(st->data + 40, G_LITTLE_ENDIAN);
170
903
}
171
/**
172
 * fu_struct_elf_file_header64le_get_flags: (skip):
173
 **/
174
guint32
175
fu_struct_elf_file_header64le_get_flags(const FuStructElfFileHeader64le *st)
176
0
{
177
0
    g_return_val_if_fail(st != NULL, 0x0);
178
0
    return fu_memread_uint32(st->data + 48, G_LITTLE_ENDIAN);
179
0
}
180
/**
181
 * fu_struct_elf_file_header64le_get_ehsize: (skip):
182
 **/
183
guint16
184
fu_struct_elf_file_header64le_get_ehsize(const FuStructElfFileHeader64le *st)
185
0
{
186
0
    g_return_val_if_fail(st != NULL, 0x0);
187
0
    return fu_memread_uint16(st->data + 52, G_LITTLE_ENDIAN);
188
0
}
189
/**
190
 * fu_struct_elf_file_header64le_get_phentsize: (skip):
191
 **/
192
guint16
193
fu_struct_elf_file_header64le_get_phentsize(const FuStructElfFileHeader64le *st)
194
1.06k
{
195
1.06k
    g_return_val_if_fail(st != NULL, 0x0);
196
1.06k
    return fu_memread_uint16(st->data + 54, G_LITTLE_ENDIAN);
197
1.06k
}
198
/**
199
 * fu_struct_elf_file_header64le_get_phnum: (skip):
200
 **/
201
guint16
202
fu_struct_elf_file_header64le_get_phnum(const FuStructElfFileHeader64le *st)
203
1.06k
{
204
1.06k
    g_return_val_if_fail(st != NULL, 0x0);
205
1.06k
    return fu_memread_uint16(st->data + 56, G_LITTLE_ENDIAN);
206
1.06k
}
207
/**
208
 * fu_struct_elf_file_header64le_get_shentsize: (skip):
209
 **/
210
guint16
211
fu_struct_elf_file_header64le_get_shentsize(const FuStructElfFileHeader64le *st)
212
13.5M
{
213
13.5M
    g_return_val_if_fail(st != NULL, 0x0);
214
13.5M
    return fu_memread_uint16(st->data + 58, G_LITTLE_ENDIAN);
215
13.5M
}
216
/**
217
 * fu_struct_elf_file_header64le_get_shnum: (skip):
218
 **/
219
guint16
220
fu_struct_elf_file_header64le_get_shnum(const FuStructElfFileHeader64le *st)
221
903
{
222
903
    g_return_val_if_fail(st != NULL, 0x0);
223
903
    return fu_memread_uint16(st->data + 60, G_LITTLE_ENDIAN);
224
903
}
225
/**
226
 * fu_struct_elf_file_header64le_get_shstrndx: (skip):
227
 **/
228
guint16
229
fu_struct_elf_file_header64le_get_shstrndx(const FuStructElfFileHeader64le *st)
230
4.14M
{
231
4.14M
    g_return_val_if_fail(st != NULL, 0x0);
232
4.14M
    return fu_memread_uint16(st->data + 62, G_LITTLE_ENDIAN);
233
4.14M
}
234
235
/* setters */
236
/**
237
 * fu_struct_elf_file_header64le_set_ei_magic: (skip):
238
 **/
239
static gboolean
240
fu_struct_elf_file_header64le_set_ei_magic(FuStructElfFileHeader64le *st, const gchar *value, GError **error)
241
244
{
242
244
    gsize len;
243
244
    g_return_val_if_fail(st != NULL, FALSE);
244
244
    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
245
244
    if (value == NULL) {
246
0
        memset(st->data + 0, 0x0, 4);
247
0
        return TRUE;
248
0
    }
249
244
    len = strlen(value);
250
244
    if (len > 4) {
251
0
        g_set_error(error,
252
0
                    FWUPD_ERROR,
253
0
                    FWUPD_ERROR_INVALID_DATA,
254
0
                    "string '%s' (0x%x bytes) does not fit in FuStructElfFileHeader64le.ei_magic (0x%x bytes)",
255
0
                    value, (guint) len, (guint) 4);
256
0
        return FALSE;
257
0
    }
258
244
    return fu_memcpy_safe(st->data, st->len, 0, (const guint8 *)value, len, 0x0, len, error);
259
244
}
260
/**
261
 * fu_struct_elf_file_header64le_set_ei_class: (skip):
262
 **/
263
static void
264
fu_struct_elf_file_header64le_set_ei_class(FuStructElfFileHeader64le *st, guint8 value)
265
244
{
266
244
    g_return_if_fail(st != NULL);
267
244
    st->data[4] = value;
268
244
}
269
/**
270
 * fu_struct_elf_file_header64le_set_ei_data: (skip):
271
 **/
272
static void
273
fu_struct_elf_file_header64le_set_ei_data(FuStructElfFileHeader64le *st, guint8 value)
274
244
{
275
244
    g_return_if_fail(st != NULL);
276
244
    st->data[5] = value;
277
244
}
278
/**
279
 * fu_struct_elf_file_header64le_set_ei_version: (skip):
280
 **/
281
static void
282
fu_struct_elf_file_header64le_set_ei_version(FuStructElfFileHeader64le *st, guint8 value)
283
244
{
284
244
    g_return_if_fail(st != NULL);
285
244
    st->data[6] = value;
286
244
}
287
/**
288
 * fu_struct_elf_file_header64le_set_ei_osabi: (skip):
289
 **/
290
void
291
fu_struct_elf_file_header64le_set_ei_osabi(FuStructElfFileHeader64le *st, guint8 value)
292
244
{
293
244
    g_return_if_fail(st != NULL);
294
244
    st->data[7] = value;
295
244
}
296
/**
297
 * fu_struct_elf_file_header64le_set_ei_abiversion: (skip):
298
 **/
299
void
300
fu_struct_elf_file_header64le_set_ei_abiversion(FuStructElfFileHeader64le *st, guint8 value)
301
0
{
302
0
    g_return_if_fail(st != NULL);
303
0
    st->data[8] = value;
304
0
}
305
/**
306
 * fu_struct_elf_file_header64le_set_type: (skip):
307
 **/
308
void
309
fu_struct_elf_file_header64le_set_type(FuStructElfFileHeader64le *st, FuElfFileHeaderType value)
310
0
{
311
0
    g_return_if_fail(st != NULL);
312
0
    fu_memwrite_uint16(st->data + 16, value, G_LITTLE_ENDIAN);
313
0
}
314
/**
315
 * fu_struct_elf_file_header64le_set_machine: (skip):
316
 **/
317
void
318
fu_struct_elf_file_header64le_set_machine(FuStructElfFileHeader64le *st, guint16 value)
319
0
{
320
0
    g_return_if_fail(st != NULL);
321
0
    fu_memwrite_uint16(st->data + 18, value, G_LITTLE_ENDIAN);
322
0
}
323
/**
324
 * fu_struct_elf_file_header64le_set_version: (skip):
325
 **/
326
static void
327
fu_struct_elf_file_header64le_set_version(FuStructElfFileHeader64le *st, guint32 value)
328
244
{
329
244
    g_return_if_fail(st != NULL);
330
244
    fu_memwrite_uint32(st->data + 20, value, G_LITTLE_ENDIAN);
331
244
}
332
/**
333
 * fu_struct_elf_file_header64le_set_entry: (skip):
334
 **/
335
void
336
fu_struct_elf_file_header64le_set_entry(FuStructElfFileHeader64le *st, guint64 value)
337
139
{
338
139
    g_return_if_fail(st != NULL);
339
139
    fu_memwrite_uint64(st->data + 24, value, G_LITTLE_ENDIAN);
340
139
}
341
/**
342
 * fu_struct_elf_file_header64le_set_phoff: (skip):
343
 **/
344
void
345
fu_struct_elf_file_header64le_set_phoff(FuStructElfFileHeader64le *st, guint64 value)
346
244
{
347
244
    g_return_if_fail(st != NULL);
348
244
    fu_memwrite_uint64(st->data + 32, value, G_LITTLE_ENDIAN);
349
244
}
350
/**
351
 * fu_struct_elf_file_header64le_set_shoff: (skip):
352
 **/
353
void
354
fu_struct_elf_file_header64le_set_shoff(FuStructElfFileHeader64le *st, guint64 value)
355
139
{
356
139
    g_return_if_fail(st != NULL);
357
139
    fu_memwrite_uint64(st->data + 40, value, G_LITTLE_ENDIAN);
358
139
}
359
/**
360
 * fu_struct_elf_file_header64le_set_flags: (skip):
361
 **/
362
void
363
fu_struct_elf_file_header64le_set_flags(FuStructElfFileHeader64le *st, guint32 value)
364
0
{
365
0
    g_return_if_fail(st != NULL);
366
0
    fu_memwrite_uint32(st->data + 48, value, G_LITTLE_ENDIAN);
367
0
}
368
/**
369
 * fu_struct_elf_file_header64le_set_ehsize: (skip):
370
 **/
371
void
372
fu_struct_elf_file_header64le_set_ehsize(FuStructElfFileHeader64le *st, guint16 value)
373
244
{
374
244
    g_return_if_fail(st != NULL);
375
244
    fu_memwrite_uint16(st->data + 52, value, G_LITTLE_ENDIAN);
376
244
}
377
/**
378
 * fu_struct_elf_file_header64le_set_phentsize: (skip):
379
 **/
380
void
381
fu_struct_elf_file_header64le_set_phentsize(FuStructElfFileHeader64le *st, guint16 value)
382
139
{
383
139
    g_return_if_fail(st != NULL);
384
139
    fu_memwrite_uint16(st->data + 54, value, G_LITTLE_ENDIAN);
385
139
}
386
/**
387
 * fu_struct_elf_file_header64le_set_phnum: (skip):
388
 **/
389
void
390
fu_struct_elf_file_header64le_set_phnum(FuStructElfFileHeader64le *st, guint16 value)
391
139
{
392
139
    g_return_if_fail(st != NULL);
393
139
    fu_memwrite_uint16(st->data + 56, value, G_LITTLE_ENDIAN);
394
139
}
395
/**
396
 * fu_struct_elf_file_header64le_set_shentsize: (skip):
397
 **/
398
void
399
fu_struct_elf_file_header64le_set_shentsize(FuStructElfFileHeader64le *st, guint16 value)
400
139
{
401
139
    g_return_if_fail(st != NULL);
402
139
    fu_memwrite_uint16(st->data + 58, value, G_LITTLE_ENDIAN);
403
139
}
404
/**
405
 * fu_struct_elf_file_header64le_set_shnum: (skip):
406
 **/
407
void
408
fu_struct_elf_file_header64le_set_shnum(FuStructElfFileHeader64le *st, guint16 value)
409
139
{
410
139
    g_return_if_fail(st != NULL);
411
139
    fu_memwrite_uint16(st->data + 60, value, G_LITTLE_ENDIAN);
412
139
}
413
/**
414
 * fu_struct_elf_file_header64le_set_shstrndx: (skip):
415
 **/
416
void
417
fu_struct_elf_file_header64le_set_shstrndx(FuStructElfFileHeader64le *st, guint16 value)
418
139
{
419
139
    g_return_if_fail(st != NULL);
420
139
    fu_memwrite_uint16(st->data + 62, value, G_LITTLE_ENDIAN);
421
139
}
422
/**
423
 * fu_struct_elf_file_header64le_new: (skip):
424
 **/
425
FuStructElfFileHeader64le *
426
fu_struct_elf_file_header64le_new(void)
427
244
{
428
244
    FuStructElfFileHeader64le *st = g_byte_array_sized_new(64);
429
244
    fu_byte_array_set_size(st, 64, 0x0);
430
244
    fu_struct_elf_file_header64le_set_ei_magic(st, "\x7F\x45\x4C\x46", NULL);
431
244
    fu_struct_elf_file_header64le_set_ei_class(st, 0x2);
432
244
    fu_struct_elf_file_header64le_set_ei_data(st, 0x1);
433
244
    fu_struct_elf_file_header64le_set_ei_version(st, 0x1);
434
244
    fu_struct_elf_file_header64le_set_ei_osabi(st, 0x3);
435
244
    memcpy(st->data + 0x9, "\x00\x00\x00\x00\x00\x00\x00", 7); /* nocheck:blocked */
436
244
    fu_struct_elf_file_header64le_set_version(st, 0x1);
437
244
    fu_struct_elf_file_header64le_set_phoff(st, 64);
438
244
    fu_struct_elf_file_header64le_set_ehsize(st, 64);
439
244
    return st;
440
244
}
441
/**
442
 * fu_struct_elf_file_header64le_to_string: (skip):
443
 **/
444
static gchar *
445
fu_struct_elf_file_header64le_to_string(const FuStructElfFileHeader64le *st)
446
0
{
447
0
    g_autoptr(GString) str = g_string_new("FuStructElfFileHeader64le:\n");
448
0
    g_return_val_if_fail(st != NULL, NULL);
449
0
    g_string_append_printf(str, "  ei_osabi: 0x%x\n",
450
0
                           (guint) fu_struct_elf_file_header64le_get_ei_osabi(st));
451
0
    g_string_append_printf(str, "  ei_abiversion: 0x%x\n",
452
0
                           (guint) fu_struct_elf_file_header64le_get_ei_abiversion(st));
453
0
    {
454
0
        const gchar *tmp = fu_elf_file_header_type_to_string(fu_struct_elf_file_header64le_get_type(st));
455
0
        if (tmp != NULL) {
456
0
            g_string_append_printf(str, "  type: 0x%x [%s]\n", (guint) fu_struct_elf_file_header64le_get_type(st), tmp);
457
0
        } else {
458
0
            g_string_append_printf(str, "  type: 0x%x\n", (guint) fu_struct_elf_file_header64le_get_type(st));
459
0
        }
460
0
    }
461
0
    g_string_append_printf(str, "  machine: 0x%x\n",
462
0
                           (guint) fu_struct_elf_file_header64le_get_machine(st));
463
0
    g_string_append_printf(str, "  entry: 0x%x\n",
464
0
                           (guint) fu_struct_elf_file_header64le_get_entry(st));
465
0
    g_string_append_printf(str, "  phoff: 0x%x\n",
466
0
                           (guint) fu_struct_elf_file_header64le_get_phoff(st));
467
0
    g_string_append_printf(str, "  shoff: 0x%x\n",
468
0
                           (guint) fu_struct_elf_file_header64le_get_shoff(st));
469
0
    g_string_append_printf(str, "  flags: 0x%x\n",
470
0
                           (guint) fu_struct_elf_file_header64le_get_flags(st));
471
0
    g_string_append_printf(str, "  ehsize: 0x%x\n",
472
0
                           (guint) fu_struct_elf_file_header64le_get_ehsize(st));
473
0
    g_string_append_printf(str, "  phentsize: 0x%x\n",
474
0
                           (guint) fu_struct_elf_file_header64le_get_phentsize(st));
475
0
    g_string_append_printf(str, "  phnum: 0x%x\n",
476
0
                           (guint) fu_struct_elf_file_header64le_get_phnum(st));
477
0
    g_string_append_printf(str, "  shentsize: 0x%x\n",
478
0
                           (guint) fu_struct_elf_file_header64le_get_shentsize(st));
479
0
    g_string_append_printf(str, "  shnum: 0x%x\n",
480
0
                           (guint) fu_struct_elf_file_header64le_get_shnum(st));
481
0
    g_string_append_printf(str, "  shstrndx: 0x%x\n",
482
0
                           (guint) fu_struct_elf_file_header64le_get_shstrndx(st));
483
0
    if (str->len > 0)
484
0
        g_string_set_size(str, str->len - 1);
485
0
    return g_string_free(g_steal_pointer(&str), FALSE);
486
0
}
487
static gboolean
488
fu_struct_elf_file_header64le_validate_internal(FuStructElfFileHeader64le *st, GError **error)
489
8.54M
{
490
8.54M
    g_return_val_if_fail(st != NULL, FALSE);
491
8.54M
    if (strncmp((const gchar *) (st->data + 0), "\x7F\x45\x4C\x46", 4) != 0) {
492
8.54M
        g_set_error_literal(error,
493
8.54M
                            FWUPD_ERROR,
494
8.54M
                            FWUPD_ERROR_INVALID_DATA,
495
8.54M
                            "constant FuStructElfFileHeader64le.ei_magic was not valid");
496
8.54M
        return FALSE;
497
8.54M
    }
498
3.56k
    if (fu_struct_elf_file_header64le_get_ei_class(st) != 0x2) {
499
345
        g_set_error_literal(error,
500
345
                            FWUPD_ERROR,
501
345
                            FWUPD_ERROR_INVALID_DATA,
502
345
                            "constant FuStructElfFileHeader64le.ei_class was not valid");
503
345
        return FALSE;
504
345
    }
505
3.21k
    if (fu_struct_elf_file_header64le_get_ei_data(st) != 0x1) {
506
348
        g_set_error_literal(error,
507
348
                            FWUPD_ERROR,
508
348
                            FWUPD_ERROR_INVALID_DATA,
509
348
                            "constant FuStructElfFileHeader64le.ei_data was not valid");
510
348
        return FALSE;
511
348
    }
512
2.86k
    if (fu_struct_elf_file_header64le_get_ei_version(st) != 0x1) {
513
287
        g_set_error_literal(error,
514
287
                            FWUPD_ERROR,
515
287
                            FWUPD_ERROR_INVALID_DATA,
516
287
                            "constant FuStructElfFileHeader64le.ei_version was not valid");
517
287
        return FALSE;
518
287
    }
519
2.58k
    if (fu_struct_elf_file_header64le_get_version(st) != 0x1) {
520
443
        g_set_error_literal(error,
521
443
                            FWUPD_ERROR,
522
443
                            FWUPD_ERROR_INVALID_DATA,
523
443
                            "constant FuStructElfFileHeader64le.version was not valid");
524
443
        return FALSE;
525
443
    }
526
2.13k
    return TRUE;
527
2.58k
}
528
/**
529
 * fu_struct_elf_file_header64le_validate_stream: (skip):
530
 **/
531
gboolean
532
fu_struct_elf_file_header64le_validate_stream(GInputStream *stream, gsize offset, GError **error)
533
8.55M
{
534
8.55M
    g_autoptr(GByteArray) st = NULL;
535
8.55M
    g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE);
536
8.55M
    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
537
8.55M
    st = fu_input_stream_read_byte_array(stream, offset, 64, NULL, error);
538
8.55M
    if (st == NULL) {
539
0
        g_prefix_error(error, "FuStructElfFileHeader64le failed read of 0x%x: ", (guint) 64);
540
0
        return FALSE;
541
0
    }
542
8.55M
    if (st->len != 64) {
543
11.3k
        g_set_error(error,
544
11.3k
                    FWUPD_ERROR,
545
11.3k
                    FWUPD_ERROR_INVALID_DATA,
546
11.3k
                    "FuStructElfFileHeader64le requested 0x%x and got 0x%x",
547
11.3k
                    (guint) 64,
548
11.3k
                    (guint) st->len);
549
11.3k
        return FALSE;
550
11.3k
    }
551
8.54M
    return fu_struct_elf_file_header64le_validate_internal(st, error);
552
8.55M
}
553
static gboolean
554
fu_struct_elf_file_header64le_parse_internal(FuStructElfFileHeader64le *st, GError **error)
555
1.06k
{
556
1.06k
    if (!fu_struct_elf_file_header64le_validate_internal(st, error))
557
0
        return FALSE;
558
1.06k
    if (g_getenv("FWUPD_VERBOSE") != NULL) {
559
0
        g_autofree gchar *str = fu_struct_elf_file_header64le_to_string(st);
560
0
        g_debug("%s", str);
561
0
    }
562
1.06k
    return TRUE;
563
1.06k
}
564
/**
565
 * fu_struct_elf_file_header64le_parse_stream: (skip):
566
 **/
567
FuStructElfFileHeader64le *
568
fu_struct_elf_file_header64le_parse_stream(GInputStream *stream, gsize offset, GError **error)
569
1.06k
{
570
1.06k
    g_autoptr(GByteArray) st = NULL;
571
1.06k
    st = fu_input_stream_read_byte_array(stream, offset, 64, NULL, error);
572
1.06k
    if (st == NULL) {
573
0
        g_prefix_error(error, "FuStructElfFileHeader64le failed read of 0x%x: ", (guint) 64);
574
0
        return NULL;
575
0
    }
576
1.06k
    if (st->len != 64) {
577
0
        g_set_error(error,
578
0
                    FWUPD_ERROR,
579
0
                    FWUPD_ERROR_INVALID_DATA,
580
0
                    "FuStructElfFileHeader64le requested 0x%x and got 0x%x",
581
0
                    (guint) 64,
582
0
                    (guint) st->len);
583
0
        return NULL;
584
0
    }
585
1.06k
    if (!fu_struct_elf_file_header64le_parse_internal(st, error))
586
0
        return NULL;
587
1.06k
    return g_steal_pointer(&st);
588
1.06k
}
589
/* getters */
590
/**
591
 * fu_struct_elf_program_header64le_get_flags: (skip):
592
 **/
593
guint32
594
fu_struct_elf_program_header64le_get_flags(const FuStructElfProgramHeader64le *st)
595
0
{
596
0
    g_return_val_if_fail(st != NULL, 0x0);
597
0
    return fu_memread_uint32(st->data + 0, G_LITTLE_ENDIAN);
598
0
}
599
/**
600
 * fu_struct_elf_program_header64le_get_offset: (skip):
601
 **/
602
guint64
603
fu_struct_elf_program_header64le_get_offset(const FuStructElfProgramHeader64le *st)
604
0
{
605
0
    g_return_val_if_fail(st != NULL, 0x0);
606
0
    return fu_memread_uint64(st->data + 4, G_LITTLE_ENDIAN);
607
0
}
608
/**
609
 * fu_struct_elf_program_header64le_get_vaddr: (skip):
610
 **/
611
guint64
612
fu_struct_elf_program_header64le_get_vaddr(const FuStructElfProgramHeader64le *st)
613
0
{
614
0
    g_return_val_if_fail(st != NULL, 0x0);
615
0
    return fu_memread_uint64(st->data + 12, G_LITTLE_ENDIAN);
616
0
}
617
/**
618
 * fu_struct_elf_program_header64le_get_paddr: (skip):
619
 **/
620
guint64
621
fu_struct_elf_program_header64le_get_paddr(const FuStructElfProgramHeader64le *st)
622
0
{
623
0
    g_return_val_if_fail(st != NULL, 0x0);
624
0
    return fu_memread_uint64(st->data + 20, G_LITTLE_ENDIAN);
625
0
}
626
/**
627
 * fu_struct_elf_program_header64le_get_filesz: (skip):
628
 **/
629
guint64
630
fu_struct_elf_program_header64le_get_filesz(const FuStructElfProgramHeader64le *st)
631
0
{
632
0
    g_return_val_if_fail(st != NULL, 0x0);
633
0
    return fu_memread_uint64(st->data + 28, G_LITTLE_ENDIAN);
634
0
}
635
/**
636
 * fu_struct_elf_program_header64le_get_memsz: (skip):
637
 **/
638
guint64
639
fu_struct_elf_program_header64le_get_memsz(const FuStructElfProgramHeader64le *st)
640
0
{
641
0
    g_return_val_if_fail(st != NULL, 0x0);
642
0
    return fu_memread_uint64(st->data + 36, G_LITTLE_ENDIAN);
643
0
}
644
/**
645
 * fu_struct_elf_program_header64le_get_flags2: (skip):
646
 **/
647
guint32
648
fu_struct_elf_program_header64le_get_flags2(const FuStructElfProgramHeader64le *st)
649
0
{
650
0
    g_return_val_if_fail(st != NULL, 0x0);
651
0
    return fu_memread_uint32(st->data + 44, G_LITTLE_ENDIAN);
652
0
}
653
/**
654
 * fu_struct_elf_program_header64le_get_align: (skip):
655
 **/
656
guint64
657
fu_struct_elf_program_header64le_get_align(const FuStructElfProgramHeader64le *st)
658
0
{
659
0
    g_return_val_if_fail(st != NULL, 0x0);
660
0
    return fu_memread_uint64(st->data + 48, G_LITTLE_ENDIAN);
661
0
}
662
663
/* setters */
664
/**
665
 * fu_struct_elf_program_header64le_set_flags: (skip):
666
 **/
667
void
668
fu_struct_elf_program_header64le_set_flags(FuStructElfProgramHeader64le *st, guint32 value)
669
0
{
670
0
    g_return_if_fail(st != NULL);
671
0
    fu_memwrite_uint32(st->data + 0, value, G_LITTLE_ENDIAN);
672
0
}
673
/**
674
 * fu_struct_elf_program_header64le_set_offset: (skip):
675
 **/
676
void
677
fu_struct_elf_program_header64le_set_offset(FuStructElfProgramHeader64le *st, guint64 value)
678
0
{
679
0
    g_return_if_fail(st != NULL);
680
0
    fu_memwrite_uint64(st->data + 4, value, G_LITTLE_ENDIAN);
681
0
}
682
/**
683
 * fu_struct_elf_program_header64le_set_vaddr: (skip):
684
 **/
685
void
686
fu_struct_elf_program_header64le_set_vaddr(FuStructElfProgramHeader64le *st, guint64 value)
687
139
{
688
139
    g_return_if_fail(st != NULL);
689
139
    fu_memwrite_uint64(st->data + 12, value, G_LITTLE_ENDIAN);
690
139
}
691
/**
692
 * fu_struct_elf_program_header64le_set_paddr: (skip):
693
 **/
694
void
695
fu_struct_elf_program_header64le_set_paddr(FuStructElfProgramHeader64le *st, guint64 value)
696
139
{
697
139
    g_return_if_fail(st != NULL);
698
139
    fu_memwrite_uint64(st->data + 20, value, G_LITTLE_ENDIAN);
699
139
}
700
/**
701
 * fu_struct_elf_program_header64le_set_filesz: (skip):
702
 **/
703
void
704
fu_struct_elf_program_header64le_set_filesz(FuStructElfProgramHeader64le *st, guint64 value)
705
139
{
706
139
    g_return_if_fail(st != NULL);
707
139
    fu_memwrite_uint64(st->data + 28, value, G_LITTLE_ENDIAN);
708
139
}
709
/**
710
 * fu_struct_elf_program_header64le_set_memsz: (skip):
711
 **/
712
void
713
fu_struct_elf_program_header64le_set_memsz(FuStructElfProgramHeader64le *st, guint64 value)
714
139
{
715
139
    g_return_if_fail(st != NULL);
716
139
    fu_memwrite_uint64(st->data + 36, value, G_LITTLE_ENDIAN);
717
139
}
718
/**
719
 * fu_struct_elf_program_header64le_set_flags2: (skip):
720
 **/
721
void
722
fu_struct_elf_program_header64le_set_flags2(FuStructElfProgramHeader64le *st, guint32 value)
723
0
{
724
0
    g_return_if_fail(st != NULL);
725
0
    fu_memwrite_uint32(st->data + 44, value, G_LITTLE_ENDIAN);
726
0
}
727
/**
728
 * fu_struct_elf_program_header64le_set_align: (skip):
729
 **/
730
void
731
fu_struct_elf_program_header64le_set_align(FuStructElfProgramHeader64le *st, guint64 value)
732
0
{
733
0
    g_return_if_fail(st != NULL);
734
0
    fu_memwrite_uint64(st->data + 48, value, G_LITTLE_ENDIAN);
735
0
}
736
/**
737
 * fu_struct_elf_program_header64le_new: (skip):
738
 **/
739
FuStructElfProgramHeader64le *
740
fu_struct_elf_program_header64le_new(void)
741
244
{
742
244
    FuStructElfProgramHeader64le *st = g_byte_array_sized_new(56);
743
244
    fu_byte_array_set_size(st, 56, 0x0);
744
244
    return st;
745
244
}
746
/**
747
 * fu_struct_elf_program_header64le_to_string: (skip):
748
 **/
749
static gchar *
750
fu_struct_elf_program_header64le_to_string(const FuStructElfProgramHeader64le *st)
751
0
{
752
0
    g_autoptr(GString) str = g_string_new("FuStructElfProgramHeader64le:\n");
753
0
    g_return_val_if_fail(st != NULL, NULL);
754
0
    g_string_append_printf(str, "  flags: 0x%x\n",
755
0
                           (guint) fu_struct_elf_program_header64le_get_flags(st));
756
0
    g_string_append_printf(str, "  offset: 0x%x\n",
757
0
                           (guint) fu_struct_elf_program_header64le_get_offset(st));
758
0
    g_string_append_printf(str, "  vaddr: 0x%x\n",
759
0
                           (guint) fu_struct_elf_program_header64le_get_vaddr(st));
760
0
    g_string_append_printf(str, "  paddr: 0x%x\n",
761
0
                           (guint) fu_struct_elf_program_header64le_get_paddr(st));
762
0
    g_string_append_printf(str, "  filesz: 0x%x\n",
763
0
                           (guint) fu_struct_elf_program_header64le_get_filesz(st));
764
0
    g_string_append_printf(str, "  memsz: 0x%x\n",
765
0
                           (guint) fu_struct_elf_program_header64le_get_memsz(st));
766
0
    g_string_append_printf(str, "  flags2: 0x%x\n",
767
0
                           (guint) fu_struct_elf_program_header64le_get_flags2(st));
768
0
    g_string_append_printf(str, "  align: 0x%x\n",
769
0
                           (guint) fu_struct_elf_program_header64le_get_align(st));
770
0
    if (str->len > 0)
771
0
        g_string_set_size(str, str->len - 1);
772
0
    return g_string_free(g_steal_pointer(&str), FALSE);
773
0
}
774
static gboolean
775
fu_struct_elf_program_header64le_validate_internal(FuStructElfProgramHeader64le *st, GError **error)
776
2.40M
{
777
2.40M
    g_return_val_if_fail(st != NULL, FALSE);
778
2.40M
    return TRUE;
779
2.40M
}
780
static gboolean
781
fu_struct_elf_program_header64le_parse_internal(FuStructElfProgramHeader64le *st, GError **error)
782
2.40M
{
783
2.40M
    if (!fu_struct_elf_program_header64le_validate_internal(st, error))
784
0
        return FALSE;
785
2.40M
    if (g_getenv("FWUPD_VERBOSE") != NULL) {
786
0
        g_autofree gchar *str = fu_struct_elf_program_header64le_to_string(st);
787
0
        g_debug("%s", str);
788
0
    }
789
2.40M
    return TRUE;
790
2.40M
}
791
/**
792
 * fu_struct_elf_program_header64le_parse_stream: (skip):
793
 **/
794
FuStructElfProgramHeader64le *
795
fu_struct_elf_program_header64le_parse_stream(GInputStream *stream, gsize offset, GError **error)
796
2.40M
{
797
2.40M
    g_autoptr(GByteArray) st = NULL;
798
2.40M
    st = fu_input_stream_read_byte_array(stream, offset, 56, NULL, error);
799
2.40M
    if (st == NULL) {
800
146
        g_prefix_error(error, "FuStructElfProgramHeader64le failed read of 0x%x: ", (guint) 56);
801
146
        return NULL;
802
146
    }
803
2.40M
    if (st->len != 56) {
804
20
        g_set_error(error,
805
20
                    FWUPD_ERROR,
806
20
                    FWUPD_ERROR_INVALID_DATA,
807
20
                    "FuStructElfProgramHeader64le requested 0x%x and got 0x%x",
808
20
                    (guint) 56,
809
20
                    (guint) st->len);
810
20
        return NULL;
811
20
    }
812
2.40M
    if (!fu_struct_elf_program_header64le_parse_internal(st, error))
813
0
        return NULL;
814
2.40M
    return g_steal_pointer(&st);
815
2.40M
}
816
/* getters */
817
/**
818
 * fu_struct_elf_section_header64le_get_name: (skip):
819
 **/
820
guint32
821
fu_struct_elf_section_header64le_get_name(const FuStructElfSectionHeader64le *st)
822
3.93M
{
823
3.93M
    g_return_val_if_fail(st != NULL, 0x0);
824
3.93M
    return fu_memread_uint32(st->data + 0, G_LITTLE_ENDIAN);
825
3.93M
}
826
/**
827
 * fu_struct_elf_section_header64le_get_type: (skip):
828
 **/
829
FuElfSectionHeaderType
830
fu_struct_elf_section_header64le_get_type(const FuStructElfSectionHeader64le *st)
831
16.0M
{
832
16.0M
    g_return_val_if_fail(st != NULL, 0x0);
833
16.0M
    return fu_memread_uint32(st->data + 4, G_LITTLE_ENDIAN);
834
16.0M
}
835
/**
836
 * fu_struct_elf_section_header64le_get_flags: (skip):
837
 **/
838
guint64
839
fu_struct_elf_section_header64le_get_flags(const FuStructElfSectionHeader64le *st)
840
0
{
841
0
    g_return_val_if_fail(st != NULL, 0x0);
842
0
    return fu_memread_uint64(st->data + 8, G_LITTLE_ENDIAN);
843
0
}
844
/**
845
 * fu_struct_elf_section_header64le_get_addr: (skip):
846
 **/
847
guint64
848
fu_struct_elf_section_header64le_get_addr(const FuStructElfSectionHeader64le *st)
849
0
{
850
0
    g_return_val_if_fail(st != NULL, 0x0);
851
0
    return fu_memread_uint64(st->data + 16, G_LITTLE_ENDIAN);
852
0
}
853
/**
854
 * fu_struct_elf_section_header64le_get_offset: (skip):
855
 **/
856
guint64
857
fu_struct_elf_section_header64le_get_offset(const FuStructElfSectionHeader64le *st)
858
4.14M
{
859
4.14M
    g_return_val_if_fail(st != NULL, 0x0);
860
4.14M
    return fu_memread_uint64(st->data + 24, G_LITTLE_ENDIAN);
861
4.14M
}
862
/**
863
 * fu_struct_elf_section_header64le_get_size: (skip):
864
 **/
865
guint64
866
fu_struct_elf_section_header64le_get_size(const FuStructElfSectionHeader64le *st)
867
4.14M
{
868
4.14M
    g_return_val_if_fail(st != NULL, 0x0);
869
4.14M
    return fu_memread_uint64(st->data + 32, G_LITTLE_ENDIAN);
870
4.14M
}
871
/**
872
 * fu_struct_elf_section_header64le_get_link: (skip):
873
 **/
874
guint32
875
fu_struct_elf_section_header64le_get_link(const FuStructElfSectionHeader64le *st)
876
0
{
877
0
    g_return_val_if_fail(st != NULL, 0x0);
878
0
    return fu_memread_uint32(st->data + 40, G_LITTLE_ENDIAN);
879
0
}
880
/**
881
 * fu_struct_elf_section_header64le_get_info: (skip):
882
 **/
883
guint32
884
fu_struct_elf_section_header64le_get_info(const FuStructElfSectionHeader64le *st)
885
0
{
886
0
    g_return_val_if_fail(st != NULL, 0x0);
887
0
    return fu_memread_uint32(st->data + 44, G_LITTLE_ENDIAN);
888
0
}
889
/**
890
 * fu_struct_elf_section_header64le_get_addralign: (skip):
891
 **/
892
guint64
893
fu_struct_elf_section_header64le_get_addralign(const FuStructElfSectionHeader64le *st)
894
0
{
895
0
    g_return_val_if_fail(st != NULL, 0x0);
896
0
    return fu_memread_uint64(st->data + 48, G_LITTLE_ENDIAN);
897
0
}
898
/**
899
 * fu_struct_elf_section_header64le_get_entsize: (skip):
900
 **/
901
guint64
902
fu_struct_elf_section_header64le_get_entsize(const FuStructElfSectionHeader64le *st)
903
0
{
904
0
    g_return_val_if_fail(st != NULL, 0x0);
905
0
    return fu_memread_uint64(st->data + 56, G_LITTLE_ENDIAN);
906
0
}
907
908
/* setters */
909
/**
910
 * fu_struct_elf_section_header64le_set_name: (skip):
911
 **/
912
void
913
fu_struct_elf_section_header64le_set_name(FuStructElfSectionHeader64le *st, guint32 value)
914
139
{
915
139
    g_return_if_fail(st != NULL);
916
139
    fu_memwrite_uint32(st->data + 0, value, G_LITTLE_ENDIAN);
917
139
}
918
/**
919
 * fu_struct_elf_section_header64le_set_type: (skip):
920
 **/
921
void
922
fu_struct_elf_section_header64le_set_type(FuStructElfSectionHeader64le *st, FuElfSectionHeaderType value)
923
139
{
924
139
    g_return_if_fail(st != NULL);
925
139
    fu_memwrite_uint32(st->data + 4, value, G_LITTLE_ENDIAN);
926
139
}
927
/**
928
 * fu_struct_elf_section_header64le_set_flags: (skip):
929
 **/
930
void
931
fu_struct_elf_section_header64le_set_flags(FuStructElfSectionHeader64le *st, guint64 value)
932
0
{
933
0
    g_return_if_fail(st != NULL);
934
0
    fu_memwrite_uint64(st->data + 8, value, G_LITTLE_ENDIAN);
935
0
}
936
/**
937
 * fu_struct_elf_section_header64le_set_addr: (skip):
938
 **/
939
void
940
fu_struct_elf_section_header64le_set_addr(FuStructElfSectionHeader64le *st, guint64 value)
941
0
{
942
0
    g_return_if_fail(st != NULL);
943
0
    fu_memwrite_uint64(st->data + 16, value, G_LITTLE_ENDIAN);
944
0
}
945
/**
946
 * fu_struct_elf_section_header64le_set_offset: (skip):
947
 **/
948
void
949
fu_struct_elf_section_header64le_set_offset(FuStructElfSectionHeader64le *st, guint64 value)
950
139
{
951
139
    g_return_if_fail(st != NULL);
952
139
    fu_memwrite_uint64(st->data + 24, value, G_LITTLE_ENDIAN);
953
139
}
954
/**
955
 * fu_struct_elf_section_header64le_set_size: (skip):
956
 **/
957
void
958
fu_struct_elf_section_header64le_set_size(FuStructElfSectionHeader64le *st, guint64 value)
959
139
{
960
139
    g_return_if_fail(st != NULL);
961
139
    fu_memwrite_uint64(st->data + 32, value, G_LITTLE_ENDIAN);
962
139
}
963
/**
964
 * fu_struct_elf_section_header64le_set_link: (skip):
965
 **/
966
void
967
fu_struct_elf_section_header64le_set_link(FuStructElfSectionHeader64le *st, guint32 value)
968
0
{
969
0
    g_return_if_fail(st != NULL);
970
0
    fu_memwrite_uint32(st->data + 40, value, G_LITTLE_ENDIAN);
971
0
}
972
/**
973
 * fu_struct_elf_section_header64le_set_info: (skip):
974
 **/
975
void
976
fu_struct_elf_section_header64le_set_info(FuStructElfSectionHeader64le *st, guint32 value)
977
0
{
978
0
    g_return_if_fail(st != NULL);
979
0
    fu_memwrite_uint32(st->data + 44, value, G_LITTLE_ENDIAN);
980
0
}
981
/**
982
 * fu_struct_elf_section_header64le_set_addralign: (skip):
983
 **/
984
void
985
fu_struct_elf_section_header64le_set_addralign(FuStructElfSectionHeader64le *st, guint64 value)
986
0
{
987
0
    g_return_if_fail(st != NULL);
988
0
    fu_memwrite_uint64(st->data + 48, value, G_LITTLE_ENDIAN);
989
0
}
990
/**
991
 * fu_struct_elf_section_header64le_set_entsize: (skip):
992
 **/
993
void
994
fu_struct_elf_section_header64le_set_entsize(FuStructElfSectionHeader64le *st, guint64 value)
995
0
{
996
0
    g_return_if_fail(st != NULL);
997
0
    fu_memwrite_uint64(st->data + 56, value, G_LITTLE_ENDIAN);
998
0
}
999
/**
1000
 * fu_struct_elf_section_header64le_new: (skip):
1001
 **/
1002
FuStructElfSectionHeader64le *
1003
fu_struct_elf_section_header64le_new(void)
1004
139
{
1005
139
    FuStructElfSectionHeader64le *st = g_byte_array_sized_new(64);
1006
139
    fu_byte_array_set_size(st, 64, 0x0);
1007
139
    return st;
1008
139
}
1009
/**
1010
 * fu_struct_elf_section_header64le_to_string: (skip):
1011
 **/
1012
static gchar *
1013
fu_struct_elf_section_header64le_to_string(const FuStructElfSectionHeader64le *st)
1014
0
{
1015
0
    g_autoptr(GString) str = g_string_new("FuStructElfSectionHeader64le:\n");
1016
0
    g_return_val_if_fail(st != NULL, NULL);
1017
0
    g_string_append_printf(str, "  name: 0x%x\n",
1018
0
                           (guint) fu_struct_elf_section_header64le_get_name(st));
1019
0
    {
1020
0
        const gchar *tmp = fu_elf_section_header_type_to_string(fu_struct_elf_section_header64le_get_type(st));
1021
0
        if (tmp != NULL) {
1022
0
            g_string_append_printf(str, "  type: 0x%x [%s]\n", (guint) fu_struct_elf_section_header64le_get_type(st), tmp);
1023
0
        } else {
1024
0
            g_string_append_printf(str, "  type: 0x%x\n", (guint) fu_struct_elf_section_header64le_get_type(st));
1025
0
        }
1026
0
    }
1027
0
    g_string_append_printf(str, "  flags: 0x%x\n",
1028
0
                           (guint) fu_struct_elf_section_header64le_get_flags(st));
1029
0
    g_string_append_printf(str, "  addr: 0x%x\n",
1030
0
                           (guint) fu_struct_elf_section_header64le_get_addr(st));
1031
0
    g_string_append_printf(str, "  offset: 0x%x\n",
1032
0
                           (guint) fu_struct_elf_section_header64le_get_offset(st));
1033
0
    g_string_append_printf(str, "  size: 0x%x\n",
1034
0
                           (guint) fu_struct_elf_section_header64le_get_size(st));
1035
0
    g_string_append_printf(str, "  link: 0x%x\n",
1036
0
                           (guint) fu_struct_elf_section_header64le_get_link(st));
1037
0
    g_string_append_printf(str, "  info: 0x%x\n",
1038
0
                           (guint) fu_struct_elf_section_header64le_get_info(st));
1039
0
    g_string_append_printf(str, "  addralign: 0x%x\n",
1040
0
                           (guint) fu_struct_elf_section_header64le_get_addralign(st));
1041
0
    g_string_append_printf(str, "  entsize: 0x%x\n",
1042
0
                           (guint) fu_struct_elf_section_header64le_get_entsize(st));
1043
0
    if (str->len > 0)
1044
0
        g_string_set_size(str, str->len - 1);
1045
0
    return g_string_free(g_steal_pointer(&str), FALSE);
1046
0
}
1047
static gboolean
1048
fu_struct_elf_section_header64le_validate_internal(FuStructElfSectionHeader64le *st, GError **error)
1049
13.5M
{
1050
13.5M
    g_return_val_if_fail(st != NULL, FALSE);
1051
13.5M
    return TRUE;
1052
13.5M
}
1053
static gboolean
1054
fu_struct_elf_section_header64le_parse_internal(FuStructElfSectionHeader64le *st, GError **error)
1055
13.5M
{
1056
13.5M
    if (!fu_struct_elf_section_header64le_validate_internal(st, error))
1057
0
        return FALSE;
1058
13.5M
    if (g_getenv("FWUPD_VERBOSE") != NULL) {
1059
0
        g_autofree gchar *str = fu_struct_elf_section_header64le_to_string(st);
1060
0
        g_debug("%s", str);
1061
0
    }
1062
13.5M
    return TRUE;
1063
13.5M
}
1064
/**
1065
 * fu_struct_elf_section_header64le_parse_stream: (skip):
1066
 **/
1067
FuStructElfSectionHeader64le *
1068
fu_struct_elf_section_header64le_parse_stream(GInputStream *stream, gsize offset, GError **error)
1069
13.5M
{
1070
13.5M
    g_autoptr(GByteArray) st = NULL;
1071
13.5M
    st = fu_input_stream_read_byte_array(stream, offset, 64, NULL, error);
1072
13.5M
    if (st == NULL) {
1073
69
        g_prefix_error(error, "FuStructElfSectionHeader64le failed read of 0x%x: ", (guint) 64);
1074
69
        return NULL;
1075
69
    }
1076
13.5M
    if (st->len != 64) {
1077
24
        g_set_error(error,
1078
24
                    FWUPD_ERROR,
1079
24
                    FWUPD_ERROR_INVALID_DATA,
1080
24
                    "FuStructElfSectionHeader64le requested 0x%x and got 0x%x",
1081
24
                    (guint) 64,
1082
24
                    (guint) st->len);
1083
24
        return NULL;
1084
24
    }
1085
13.5M
    if (!fu_struct_elf_section_header64le_parse_internal(st, error))
1086
0
        return NULL;
1087
13.5M
    return g_steal_pointer(&st);
1088
13.5M
}