11278434459

Committed 10 Oct 2024 04:47PM UTC coverage: 49.138% (+0.08%) from 49.06%

Build # 11278434459

Build Type

push

github

Committed by

superm1

Commit Message

trivial: Never allow the zlib stream to point to an invalid buffer

Mostly ignorable the way we use the helper now, but discovered by PVS-Studio.

Run Details

19507 of 35492 branches covered (54.96%)

Branch coverage included in aggregate %.

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

305 existing lines in 7 files now uncovered.

58606 of 123476 relevant lines covered (47.46%)

20160.05 hits per line

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

82.86

/libfwupdplugin/fu-partial-input-stream.c

/*
 * Copyright 2023 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#define G_LOG_DOMAIN "FuPartialInputStream"

#include "config.h"

#include "fwupd-codec.h"
#include "fwupd-common-private.h"

#include "fu-input-stream.h"
#include "fu-partial-input-stream-private.h"

/**
 * FuPartialInputStream:
 *
 * A input stream that is a slice of another input stream.
 *
 *       off    sz
 *    [xxxxxxxxxxxx]
 *       |  0x6  |
 *        \      \
 *         \      \
 *          \      |
 *           |     |
 *          [xxxxxx]
 *
 * xxx offset: 2, sz: 6
 */

struct _FuPartialInputStream {
        GInputStream parent_instance;
        GInputStream *base_stream;
        gsize offset;
        gsize size;
};

static void
fu_partial_input_stream_seekable_iface_init(GSeekableIface *iface);
static void
fu_partial_input_stream_codec_iface_init(FwupdCodecInterface *iface);

G_DEFINE_TYPE_WITH_CODE(FuPartialInputStream,
                        fu_partial_input_stream,
                        G_TYPE_INPUT_STREAM,
                        G_IMPLEMENT_INTERFACE(G_TYPE_SEEKABLE,
                                              fu_partial_input_stream_seekable_iface_init)
                            G_IMPLEMENT_INTERFACE(FWUPD_TYPE_CODEC,
                                                  fu_partial_input_stream_codec_iface_init))

static void
fu_partial_input_stream_add_string(FwupdCodec *codec, guint idt, GString *str)
{
        FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(codec);
        fwupd_codec_string_append_hex(str, idt, "Offset", self->offset);
        fwupd_codec_string_append_hex(str, idt, "Size", self->size);
}

static void
fu_partial_input_stream_codec_iface_init(FwupdCodecInterface *iface)
{
        iface->add_string = fu_partial_input_stream_add_string;
}

static goffset
fu_partial_input_stream_tell(GSeekable *seekable)
{
        FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(seekable);
        return g_seekable_tell(G_SEEKABLE(self->base_stream)) - self->offset;
}

static gboolean
fu_partial_input_stream_can_seek(GSeekable *seekable)
{
        FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(seekable);
        return g_seekable_can_seek(G_SEEKABLE(self->base_stream));
}

static gboolean
fu_partial_input_stream_seek(GSeekable *seekable,
                             goffset offset,
                             GSeekType type,
                             GCancellable *cancellable,
                             GError **error)
{
        FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(seekable);

        g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), FALSE);
        g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

        if (type == G_SEEK_CUR) {
                goffset pos = g_seekable_tell(G_SEEKABLE(self->base_stream));
                return g_seekable_seek(G_SEEKABLE(self->base_stream),
                                       self->offset + pos + offset,
                                       G_SEEK_SET,
                                       cancellable,
                                       error);
        }
        if (type == G_SEEK_END) {
                return g_seekable_seek(G_SEEKABLE(self->base_stream),
                                       self->offset + self->size + offset,
                                       G_SEEK_SET,
                                       cancellable,
                                       error);
        }
        return g_seekable_seek(G_SEEKABLE(self->base_stream),
                               self->offset + offset,
                               G_SEEK_SET,
                               cancellable,
                               error);
}

static gboolean
fu_partial_input_stream_can_truncate(GSeekable *seekable)
{
        return FALSE;
}

static gboolean
fu_partial_input_stream_truncate(GSeekable *seekable,
                                 goffset offset,
                                 GCancellable *cancellable,
                                 GError **error)
{
        g_set_error_literal(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_NOT_SUPPORTED,
                            "cannot truncate FuPartialInputStream");
        return FALSE;
}

static void
fu_partial_input_stream_seekable_iface_init(GSeekableIface *iface)
{
        iface->tell = fu_partial_input_stream_tell;
        iface->can_seek = fu_partial_input_stream_can_seek;
        iface->seek = fu_partial_input_stream_seek;
        iface->can_truncate = fu_partial_input_stream_can_truncate;
        iface->truncate_fn = fu_partial_input_stream_truncate;
}

/**
 * fu_partial_input_stream_new:
 * @stream: a base #GInputStream
 * @offset: offset into @stream
 * @size: size of @stream in bytes, or %G_MAXSIZE for the "rest" of the stream
 * @error: (nullable): optional return location for an error
 *
 * Creates a partial input stream where content is read from the donor stream.
 *
 * Returns: (transfer full): a #FuPartialInputStream, or %NULL on error
 *
 * Since: 2.0.0
 **/
GInputStream *
fu_partial_input_stream_new(GInputStream *stream, gsize offset, gsize size, GError **error)
{
        gsize base_sz = 0;
        g_autoptr(FuPartialInputStream) self = g_object_new(FU_TYPE_PARTIAL_INPUT_STREAM, NULL);

        g_return_val_if_fail(G_IS_INPUT_STREAM(stream), NULL);
        g_return_val_if_fail(error == NULL || *error == NULL, NULL);

        self->base_stream = g_object_ref(stream);
        self->offset = offset;

        /* sanity check */
        if (!fu_input_stream_size(stream, &base_sz, error)) {
                g_prefix_error(error, "failed to get size: ");
                return NULL;
        }
        if (size == G_MAXSIZE) {
                if (offset > base_sz) {
                        g_set_error(error,
                                    FWUPD_ERROR,
                                    FWUPD_ERROR_INVALID_DATA,
                                    "base stream was 0x%x bytes in size "
                                    "and tried to create partial stream @0x%x",
                                    (guint)base_sz,
                                    (guint)offset);
                        return NULL;
                }
                self->size = base_sz - offset;
        } else {
                if (offset + size > base_sz) {
                        g_set_error(error,
                                    FWUPD_ERROR,
                                    FWUPD_ERROR_INVALID_DATA,
                                    "base stream was 0x%x bytes in size, and tried to create "
                                    "partial stream @0x%x of 0x%x bytes",
                                    (guint)base_sz,
                                    (guint)offset,
                                    (guint)size);
                        return NULL;
                }
                self->size = size;
        }

        /* success */
        return G_INPUT_STREAM(g_steal_pointer(&self));
}

/**
 * fu_partial_input_stream_get_offset:
 * @self: a #FuPartialInputStream
 *
 * Gets the offset of the stream.
 *
 * Returns: integer
 *
 * Since: 2.0.0
 **/
gsize
fu_partial_input_stream_get_offset(FuPartialInputStream *self)
{
        g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), G_MAXSIZE);
        return self->offset;
}

/**
 * fu_partial_input_stream_get_size:
 * @self: a #FuPartialInputStream
 *
 * Gets the offset of the stream.
 *
 * Returns: integer
 *
 * Since: 2.0.0
 **/
gsize
fu_partial_input_stream_get_size(FuPartialInputStream *self)
{
        g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), G_MAXSIZE);
        return self->size;
}

static gssize
fu_partial_input_stream_read(GInputStream *stream,
                             void *buffer,
                             gsize count,
                             GCancellable *cancellable,
                             GError **error)
{
        FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(stream);
        g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), -1);
        g_return_val_if_fail(error == NULL || *error == NULL, -1);
        if (self->size < (gsize)g_seekable_tell(G_SEEKABLE(stream))) {
                g_warning("base stream is outside seekable range");
                return 0;
        }
        count = MIN(count, self->size - g_seekable_tell(G_SEEKABLE(stream)));
        return g_input_stream_read(self->base_stream, buffer, count, cancellable, error);
}

static void
fu_partial_input_stream_finalize(GObject *object)
{
        FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(object);
        if (self->base_stream != NULL)
                g_object_unref(self->base_stream);
        G_OBJECT_CLASS(fu_partial_input_stream_parent_class)->finalize(object);
}

static void
fu_partial_input_stream_class_init(FuPartialInputStreamClass *klass)
{
        GObjectClass *object_class = G_OBJECT_CLASS(klass);
        GInputStreamClass *istream_class = G_INPUT_STREAM_CLASS(klass);
        istream_class->read_fn = fu_partial_input_stream_read;
        object_class->finalize = fu_partial_input_stream_finalize;
}

static void
fu_partial_input_stream_init(FuPartialInputStream *self)
{
}

1	/*
2	* Copyright 2023 Richard Hughes <richard@hughsie.com>
3	*
4	* SPDX-License-Identifier: LGPL-2.1-or-later
5	*/
6
7	#define G_LOG_DOMAIN "FuPartialInputStream"
8
9	#include "config.h"
10
11	#include "fwupd-codec.h"
12	#include "fwupd-common-private.h"
13
14	#include "fu-input-stream.h"
15	#include "fu-partial-input-stream-private.h"
16
17	/**
18	* FuPartialInputStream:
19	*
20	* A input stream that is a slice of another input stream.
21	*
22	* off sz
23	* [xxxxxxxxxxxx]
24	* \| 0x6 \|
25	* \ \
26	* \ \
27	* \ \|
28	* \| \|
29	* [xxxxxx]
30	*
31	* xxx offset: 2, sz: 6
32	*/
33
34	struct _FuPartialInputStream {
35	GInputStream parent_instance;
36	GInputStream *base_stream;
37	gsize offset;
38	gsize size;
39	};
40
41	static void
42	fu_partial_input_stream_seekable_iface_init(GSeekableIface *iface);
43	static void
44	fu_partial_input_stream_codec_iface_init(FwupdCodecInterface *iface);
45
46	G_DEFINE_TYPE_WITH_CODE(FuPartialInputStream,	34,791,640✔
47	fu_partial_input_stream,
48	G_TYPE_INPUT_STREAM,
49	G_IMPLEMENT_INTERFACE(G_TYPE_SEEKABLE,
50	fu_partial_input_stream_seekable_iface_init)
51	G_IMPLEMENT_INTERFACE(FWUPD_TYPE_CODEC,
52	fu_partial_input_stream_codec_iface_init))
53
54	static void
55	fu_partial_input_stream_add_string(FwupdCodec codec, guint idt, GString str)	12✔
56	{
57	FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(codec);	12✔
58	fwupd_codec_string_append_hex(str, idt, "Offset", self->offset);	12✔
59	fwupd_codec_string_append_hex(str, idt, "Size", self->size);	12✔
60	}	12✔
61
62	static void
63	fu_partial_input_stream_codec_iface_init(FwupdCodecInterface *iface)	20✔
64	{
65	iface->add_string = fu_partial_input_stream_add_string;	20✔
66	}	20✔
67
68	static goffset
69	fu_partial_input_stream_tell(GSeekable *seekable)	3,442,400✔
70	{
71	FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(seekable);	3,442,400✔
72	return g_seekable_tell(G_SEEKABLE(self->base_stream)) - self->offset;	3,442,400✔
73	}
74
75	static gboolean
76	fu_partial_input_stream_can_seek(GSeekable *seekable)	846,372✔
77	{
78	FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(seekable);	846,372✔
79	return g_seekable_can_seek(G_SEEKABLE(self->base_stream));	846,372✔
80	}
81
82	static gboolean
83	fu_partial_input_stream_seek(GSeekable *seekable,	1,616,712✔
84	goffset offset,
85	GSeekType type,
86	GCancellable *cancellable,
87	GError **error)
88	{
89	FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(seekable);	1,616,712✔
90
91	g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), FALSE);	1,616,712✔
92	g_return_val_if_fail(error == NULL \|\| *error == NULL, FALSE);	1,616,712✔
93
94	if (type == G_SEEK_CUR) {	1,616,712✔
95	goffset pos = g_seekable_tell(G_SEEKABLE(self->base_stream));	×
96	return g_seekable_seek(G_SEEKABLE(self->base_stream),	×
97	self->offset + pos + offset,	×
98	G_SEEK_SET,
99	cancellable,
100	error);
101	}
102	if (type == G_SEEK_END) {	1,616,712✔
103	return g_seekable_seek(G_SEEKABLE(self->base_stream),	9,390✔
104	self->offset + self->size + offset,	9,390✔
105	G_SEEK_SET,
106	cancellable,
107	error);
108	}
109	return g_seekable_seek(G_SEEKABLE(self->base_stream),	1,607,322✔
110	self->offset + offset,	1,607,322✔
111	G_SEEK_SET,
112	cancellable,
113	error);
114	}
115
116	static gboolean
117	fu_partial_input_stream_can_truncate(GSeekable *seekable)	×
118	{
119	return FALSE;	×
120	}
121
122	static gboolean
123	fu_partial_input_stream_truncate(GSeekable *seekable,	×
124	goffset offset,
125	GCancellable *cancellable,
126	GError **error)
127	{
128	g_set_error_literal(error,	×
129	FWUPD_ERROR,
130	FWUPD_ERROR_NOT_SUPPORTED,
131	"cannot truncate FuPartialInputStream");
132	return FALSE;	×
133	}
134
135	static void
136	fu_partial_input_stream_seekable_iface_init(GSeekableIface *iface)	20✔
137	{
138	iface->tell = fu_partial_input_stream_tell;	20✔
139	iface->can_seek = fu_partial_input_stream_can_seek;	20✔
140	iface->seek = fu_partial_input_stream_seek;	20✔
141	iface->can_truncate = fu_partial_input_stream_can_truncate;	20✔
142	iface->truncate_fn = fu_partial_input_stream_truncate;	20✔
143	}	20✔
144
145	/**
146	* fu_partial_input_stream_new:
147	* @stream: a base #GInputStream
148	* @offset: offset into @stream
149	* @size: size of @stream in bytes, or %G_MAXSIZE for the "rest" of the stream
150	* @error: (nullable): optional return location for an error
151	*
152	* Creates a partial input stream where content is read from the donor stream.
153	*
154	* Returns: (transfer full): a #FuPartialInputStream, or %NULL on error
155	*
156	* Since: 2.0.0
157	**/
158	GInputStream *
159	fu_partial_input_stream_new(GInputStream stream, gsize offset, gsize size, GError *error)	10,108✔
160	{
161	gsize base_sz = 0;	10,108✔
162	g_autoptr(FuPartialInputStream) self = g_object_new(FU_TYPE_PARTIAL_INPUT_STREAM, NULL);	10,108✔
163
164	g_return_val_if_fail(G_IS_INPUT_STREAM(stream), NULL);	10,108✔
165	g_return_val_if_fail(error == NULL \|\| *error == NULL, NULL);	10,108✔
166
167	self->base_stream = g_object_ref(stream);	10,108✔
168	self->offset = offset;	10,108✔
169
170	/* sanity check */
171	if (!fu_input_stream_size(stream, &base_sz, error)) {	10,108✔
UNCOV 172	g_prefix_error(error, "failed to get size: ");	×
173	return NULL;	×
174	}
175	if (size == G_MAXSIZE) {	10,108✔
176	if (offset > base_sz) {	4✔
UNCOV 177	g_set_error(error,	×
178	FWUPD_ERROR,
179	FWUPD_ERROR_INVALID_DATA,
180	"base stream was 0x%x bytes in size "
181	"and tried to create partial stream @0x%x",
182	(guint)base_sz,
183	(guint)offset);
UNCOV 184	return NULL;	×
185	}
186	self->size = base_sz - offset;	4✔
187	} else {
188	if (offset + size > base_sz) {	10,104✔
189	g_set_error(error,	4✔
190	FWUPD_ERROR,
191	FWUPD_ERROR_INVALID_DATA,
192	"base stream was 0x%x bytes in size, and tried to create "
193	"partial stream @0x%x of 0x%x bytes",
194	(guint)base_sz,
195	(guint)offset,
196	(guint)size);
197	return NULL;	4✔
198	}
199	self->size = size;	10,100✔
200	}
201
202	/* success */
203	return G_INPUT_STREAM(g_steal_pointer(&self));
204	}
205
206	/**
207	* fu_partial_input_stream_get_offset:
208	* @self: a #FuPartialInputStream
209	*
210	* Gets the offset of the stream.
211	*
212	* Returns: integer
213	*
214	* Since: 2.0.0
215	**/
216	gsize
UNCOV 217	fu_partial_input_stream_get_offset(FuPartialInputStream *self)	×
218	{
UNCOV 219	g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), G_MAXSIZE);	×
UNCOV 220	return self->offset;	×
221	}
222
223	/**
224	* fu_partial_input_stream_get_size:
225	* @self: a #FuPartialInputStream
226	*
227	* Gets the offset of the stream.
228	*
229	* Returns: integer
230	*
231	* Since: 2.0.0
232	**/
233	gsize
234	fu_partial_input_stream_get_size(FuPartialInputStream *self)	14,144,214✔
235	{
236	g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), G_MAXSIZE);	14,144,214✔
237	return self->size;	14,144,214✔
238	}
239
240	static gssize
241	fu_partial_input_stream_read(GInputStream *stream,	1,618,954✔
242	void *buffer,
243	gsize count,
244	GCancellable *cancellable,
245	GError **error)
246	{
247	FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(stream);	1,618,954✔
248	g_return_val_if_fail(FU_IS_PARTIAL_INPUT_STREAM(self), -1);	1,618,954✔
249	g_return_val_if_fail(error == NULL \|\| *error == NULL, -1);	1,618,954✔
250	if (self->size < (gsize)g_seekable_tell(G_SEEKABLE(stream))) {	1,618,954✔
UNCOV 251	g_warning("base stream is outside seekable range");	×
UNCOV 252	return 0;	×
253	}
254	count = MIN(count, self->size - g_seekable_tell(G_SEEKABLE(stream)));	1,618,954✔
255	return g_input_stream_read(self->base_stream, buffer, count, cancellable, error);	1,618,954✔
256	}
257
258	static void
259	fu_partial_input_stream_finalize(GObject *object)	10,096✔
260	{
261	FuPartialInputStream *self = FU_PARTIAL_INPUT_STREAM(object);	10,096✔
262	if (self->base_stream != NULL)	10,096✔
263	g_object_unref(self->base_stream);	10,096✔
264	G_OBJECT_CLASS(fu_partial_input_stream_parent_class)->finalize(object);	10,096✔
265	}	10,096✔
266
267	static void
268	fu_partial_input_stream_class_init(FuPartialInputStreamClass *klass)	20✔
269	{
270	GObjectClass *object_class = G_OBJECT_CLASS(klass);	20✔
271	GInputStreamClass *istream_class = G_INPUT_STREAM_CLASS(klass);	20✔
272	istream_class->read_fn = fu_partial_input_stream_read;	20✔
273	object_class->finalize = fu_partial_input_stream_finalize;	20✔
274	}
275
276	static void
277	fu_partial_input_stream_init(FuPartialInputStream *self)	10,108✔
278	{
279	}	10,108✔

fwupd / fwupd / 11278434459

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