23966986054

Committed 03 Apr 2026 09:22PM UTC coverage: 72.107% (-0.3%) from 72.362%

Build # 23966986054

Build Type

push

github

Committed by

daandemeyer

Commit Message

fd-util: Add missing assert()

Coverage Stats

1 of 1 new or added line in 1 file covered. (100.0%)

7891 existing lines in 120 files now uncovered.

318256 of 441368 relevant lines covered (72.11%)

1186882.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/shared/kernel-image.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "alloc-util.h"
#include "env-file.h"
#include "fd-util.h"
#include "fs-util.h"
#include "kernel-image.h"
#include "log.h"
#include "pe-binary.h"
#include "string-table.h"
#include "string-util.h"

#define PE_SECTION_READ_MAX (16U*1024U)

static const char * const kernel_image_type_table[_KERNEL_IMAGE_TYPE_MAX] = {
        [KERNEL_IMAGE_TYPE_UNKNOWN] = "unknown",
        [KERNEL_IMAGE_TYPE_UKI]     = "uki",
        [KERNEL_IMAGE_TYPE_ADDON]   = "addon",
        [KERNEL_IMAGE_TYPE_PE]      = "pe",
};

DEFINE_STRING_TABLE_LOOKUP_TO_STRING(kernel_image_type, KernelImageType);

static int uki_read_pretty_name(
                int fd,
                const PeHeader *pe_header,
                const IMAGE_SECTION_HEADER *sections,
                char **ret) {

        _cleanup_free_ char *pname = NULL, *name = NULL;
        _cleanup_free_ void *osrel = NULL;
        size_t osrel_size;
        int r;

        assert(fd >= 0);
        assert(pe_header);
        assert(sections || le16toh(pe_header->pe.NumberOfSections) == 0);
        assert(ret);

        r = pe_read_section_data_by_name(
                        fd,
                        pe_header,
                        sections,
                        ".osrel",
                        /* max_size= */ PE_SECTION_READ_MAX,
                        &osrel,
                        &osrel_size);
        if (r == -ENXIO) { /* Section not found */
                *ret = NULL;
                return 0;
        }

        r = parse_env_data(
                        osrel, osrel_size, ".osrel",
                        "PRETTY_NAME", &pname,
                        "NAME",        &name);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse embedded os-release file: %m");

        /* follow the same logic as os_release_pretty_name() */
        if (!isempty(pname))
                *ret = TAKE_PTR(pname);
        else if (!isempty(name))
                *ret = TAKE_PTR(name);
        else {
                char *n = strdup("Linux");
                if (!n)
                        return -ENOMEM;

                *ret = n;
        }

        return 0;
}

static int inspect_uki(
                int fd,
                const PeHeader *pe_header,
                const IMAGE_SECTION_HEADER *sections,
                char **ret_cmdline,
                char **ret_uname,
                char **ret_pretty_name) {

        _cleanup_free_ char *cmdline = NULL, *uname = NULL, *pname = NULL;
        int r;

        assert(fd >= 0);
        assert(sections || le16toh(pe_header->pe.NumberOfSections) == 0);

        if (ret_cmdline) {
                r = pe_read_section_data_by_name(fd, pe_header, sections, ".cmdline", PE_SECTION_READ_MAX, (void**) &cmdline, NULL);
                if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */
                        return r;
        }

        if (ret_uname) {
                r = pe_read_section_data_by_name(fd, pe_header, sections, ".uname", PE_SECTION_READ_MAX, (void**) &uname, NULL);
                if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */
                        return r;
        }

        if (ret_pretty_name) {
                r = uki_read_pretty_name(fd, pe_header, sections, &pname);
                if (r < 0)
                        return r;
        }

        if (ret_cmdline)
                *ret_cmdline = TAKE_PTR(cmdline);
        if (ret_uname)
                *ret_uname = TAKE_PTR(uname);
        if (ret_pretty_name)
                *ret_pretty_name = TAKE_PTR(pname);

        return 0;
}

int inspect_kernel_full(
                int dir_fd,
                const char *filename,
                KernelImageType *ret_type,
                char **ret_cmdline,
                char **ret_uname,
                char **ret_pretty_name) {

        _cleanup_free_ IMAGE_SECTION_HEADER *sections = NULL;
        _cleanup_free_ IMAGE_DOS_HEADER *dos_header = NULL;
        KernelImageType t = KERNEL_IMAGE_TYPE_UNKNOWN;
        _cleanup_free_ PeHeader *pe_header = NULL;
        _cleanup_close_ int fd = -EBADF;
        int r;

        assert(dir_fd >= 0 || IN_SET(dir_fd, AT_FDCWD, XAT_FDROOT));

        fd = xopenat(dir_fd, filename, O_RDONLY|O_CLOEXEC);
        if (fd < 0)
                return log_debug_errno(fd, "Failed to open kernel image file '%s': %m", strna(filename));

        r = pe_load_headers(fd, &dos_header, &pe_header);
        if (r == -EBADMSG) /* not a valid PE file */
                goto not_uki;
        if (r < 0)
                return log_debug_errno(r, "Failed to parse kernel image file '%s': %m", strna(filename));

        r = pe_load_sections(fd, dos_header, pe_header, &sections);
        if (r == -EBADMSG) /* not a valid PE file */
                goto not_uki;
        if (r < 0)
                return log_debug_errno(r, "Failed to load PE sections from kernel image file '%s': %m", strna(filename));

        if (pe_is_uki(pe_header, sections)) {
                r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, ret_pretty_name);
                if (r < 0)
                        return r;

                t = KERNEL_IMAGE_TYPE_UKI;
                goto done;
        } else if (pe_is_addon(pe_header, sections)) {
                r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, /* ret_pretty_name= */ NULL);
                if (r < 0)
                        return r;

                if (ret_pretty_name)
                        *ret_pretty_name = NULL;

                t = KERNEL_IMAGE_TYPE_ADDON;
                goto done;
        } else
                t = KERNEL_IMAGE_TYPE_PE;

not_uki:
        if (ret_cmdline)
                *ret_cmdline = NULL;
        if (ret_uname)
                *ret_uname = NULL;
        if (ret_pretty_name)
                *ret_pretty_name = NULL;

done:
        if (ret_type)
                *ret_type = t;

        return 0;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "alloc-util.h"
4	#include "env-file.h"
5	#include "fd-util.h"
6	#include "fs-util.h"
7	#include "kernel-image.h"
8	#include "log.h"
9	#include "pe-binary.h"
10	#include "string-table.h"
11	#include "string-util.h"
12
13	#define PE_SECTION_READ_MAX (16U*1024U)
14
15	static const char * const kernel_image_type_table[_KERNEL_IMAGE_TYPE_MAX] = {
16	[KERNEL_IMAGE_TYPE_UNKNOWN] = "unknown",
17	[KERNEL_IMAGE_TYPE_UKI] = "uki",
18	[KERNEL_IMAGE_TYPE_ADDON] = "addon",
19	[KERNEL_IMAGE_TYPE_PE] = "pe",
20	};
21
22	DEFINE_STRING_TABLE_LOOKUP_TO_STRING(kernel_image_type, KernelImageType);	×
23
24	static int uki_read_pretty_name(	×
25	int fd,
26	const PeHeader *pe_header,
27	const IMAGE_SECTION_HEADER *sections,
28	char **ret) {
29
30	_cleanup_free_ char pname = NULL, name = NULL;	×
31	_cleanup_free_ void *osrel = NULL;	×
32	size_t osrel_size;	×
33	int r;	×
34
35	assert(fd >= 0);	×
36	assert(pe_header);	×
37	assert(sections \|\| le16toh(pe_header->pe.NumberOfSections) == 0);	×
38	assert(ret);	×
39
40	r = pe_read_section_data_by_name(	×
41	fd,
42	pe_header,
43	sections,
44	".osrel",
45	/* max_size= */ PE_SECTION_READ_MAX,
46	&osrel,
47	&osrel_size);
48	if (r == -ENXIO) { /* Section not found */	×
49	*ret = NULL;	×
50	return 0;	×
51	}
52
53	r = parse_env_data(	×
54	osrel, osrel_size, ".osrel",
55	"PRETTY_NAME", &pname,
56	"NAME", &name);
57	if (r < 0)	×
58	return log_debug_errno(r, "Failed to parse embedded os-release file: %m");	×
59
60	/* follow the same logic as os_release_pretty_name() */
61	if (!isempty(pname))	×
62	*ret = TAKE_PTR(pname);	×
63	else if (!isempty(name))	×
64	*ret = TAKE_PTR(name);	×
65	else {
66	char *n = strdup("Linux");	×
67	if (!n)	×
68	return -ENOMEM;
69
70	*ret = n;	×
71	}
72
73	return 0;
74	}
75
76	static int inspect_uki(	×
77	int fd,
78	const PeHeader *pe_header,
79	const IMAGE_SECTION_HEADER *sections,
80	char **ret_cmdline,
81	char **ret_uname,
82	char **ret_pretty_name) {
83
84	_cleanup_free_ char cmdline = NULL, uname = NULL, *pname = NULL;	×
85	int r;	×
86
87	assert(fd >= 0);	×
88	assert(sections \|\| le16toh(pe_header->pe.NumberOfSections) == 0);	×
89
90	if (ret_cmdline) {	×
91	r = pe_read_section_data_by_name(fd, pe_header, sections, ".cmdline", PE_SECTION_READ_MAX, (void**) &cmdline, NULL);	×
92	if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */	×
93	return r;
94	}
95
96	if (ret_uname) {	×
97	r = pe_read_section_data_by_name(fd, pe_header, sections, ".uname", PE_SECTION_READ_MAX, (void**) &uname, NULL);	×
98	if (r < 0 && r != -ENXIO) /* If the section doesn't exist, that's fine */	×
99	return r;
100	}
101
102	if (ret_pretty_name) {	×
103	r = uki_read_pretty_name(fd, pe_header, sections, &pname);	×
104	if (r < 0)	×
105	return r;
106	}
107
108	if (ret_cmdline)	×
109	*ret_cmdline = TAKE_PTR(cmdline);	×
110	if (ret_uname)	×
111	*ret_uname = TAKE_PTR(uname);	×
112	if (ret_pretty_name)	×
113	*ret_pretty_name = TAKE_PTR(pname);	×
114
115	return 0;
116	}
117
118	int inspect_kernel_full(	×
119	int dir_fd,
120	const char *filename,
121	KernelImageType *ret_type,
122	char **ret_cmdline,
123	char **ret_uname,
124	char **ret_pretty_name) {
125
126	_cleanup_free_ IMAGE_SECTION_HEADER *sections = NULL;	×
127	_cleanup_free_ IMAGE_DOS_HEADER *dos_header = NULL;	×
128	KernelImageType t = KERNEL_IMAGE_TYPE_UNKNOWN;	×
129	_cleanup_free_ PeHeader *pe_header = NULL;	×
130	_cleanup_close_ int fd = -EBADF;	×
131	int r;	×
132
133	assert(dir_fd >= 0 \|\| IN_SET(dir_fd, AT_FDCWD, XAT_FDROOT));	×
134
UNCOV 135	fd = xopenat(dir_fd, filename, O_RDONLY\|O_CLOEXEC);	×
136	if (fd < 0)	×
137	return log_debug_errno(fd, "Failed to open kernel image file '%s': %m", strna(filename));	×
138
UNCOV 139	r = pe_load_headers(fd, &dos_header, &pe_header);	×
140	if (r == -EBADMSG) /* not a valid PE file */	×
141	goto not_uki;	×
142	if (r < 0)	×
143	return log_debug_errno(r, "Failed to parse kernel image file '%s': %m", strna(filename));	×
144
UNCOV 145	r = pe_load_sections(fd, dos_header, pe_header, &sections);	×
146	if (r == -EBADMSG) /* not a valid PE file */	×
147	goto not_uki;	×
148	if (r < 0)	×
149	return log_debug_errno(r, "Failed to load PE sections from kernel image file '%s': %m", strna(filename));	×
150
UNCOV 151	if (pe_is_uki(pe_header, sections)) {	×
152	r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, ret_pretty_name);	×
153	if (r < 0)	×
154	return r;
155
UNCOV 156	t = KERNEL_IMAGE_TYPE_UKI;	×
157	goto done;	×
158	} else if (pe_is_addon(pe_header, sections)) {	×
159	r = inspect_uki(fd, pe_header, sections, ret_cmdline, ret_uname, /* ret_pretty_name= */ NULL);	×
160	if (r < 0)	×
161	return r;
162
UNCOV 163	if (ret_pretty_name)	×
164	*ret_pretty_name = NULL;	×
165
UNCOV 166	t = KERNEL_IMAGE_TYPE_ADDON;	×
167	goto done;	×
168	} else
169	t = KERNEL_IMAGE_TYPE_PE;
170
UNCOV 171	not_uki:	×
172	if (ret_cmdline)	×
173	*ret_cmdline = NULL;	×
174	if (ret_uname)	×
175	*ret_uname = NULL;	×
176	if (ret_pretty_name)	×
177	*ret_pretty_name = NULL;	×
178
UNCOV 179	done:	×
180	if (ret_type)	×
181	*ret_type = t;	×
182
183	return 0;
184	}

systemd / systemd / 23966986054

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous