Debian Codegraph @

src/qmi-firmware-update/qfu-image-cwe.c

raw
1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * qmi-firmware-update -- Command line tool to update firmware in QMI devices
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 *
18 * Copyright (C) 2016 Bjørn Mork <[email protected]>
19 * Copyright (C) 2016 Zodiac Inflight Innovations
20 * Copyright (C) 2016-2017 Aleksander Morgado <[email protected]>
21 */
22
23 #include <string.h>
24
25 #include "qfu-image-cwe.h"
26 #include "qfu-utils.h"
27
28 static GInitableIface *iface_initable_parent;
29 static void initable_iface_init (GInitableIface *iface);
30
31 G_DEFINE_TYPE_EXTENDED (QfuImageCwe, qfu_image_cwe, QFU_TYPE_IMAGE, 0,
32 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init))
33
34 /* Sierra Wireless CWE file header
35 * Note: 32bit numbers are big endian
36 */
37 typedef struct _QfuCweFileHeader QfuCweFileHeader;
38 struct _QfuCweFileHeader {
39 gchar reserved1[256];
40 guint32 crc; /* 32bit CRC of "reserved1" field */
41 guint32 rev; /* header revision */
42 guint32 val; /* CRC validity indicator */
43 gchar type[4]; /* ASCII - not null terminated */
44 gchar product[4]; /* ASCII - not null terminated */
45 guint32 imgsize; /* image size */
46 guint32 imgcrc; /* 32bit CRC of the image */
47 gchar version[84]; /* ASCII - null terminated */
48 gchar date[8]; /* ASCII - null terminated */
49 guint32 compat; /* backward compatibility */
50 gchar reserved2[20];
51 } __attribute__ ((packed));
52
53 typedef struct {
54 guint parent_image_index;
55 QfuCweFileHeader hdr;
56 gchar *type;
57 gchar *product;
58 } ImageInfo;
59
60 struct _QfuImageCwePrivate {
61 GArray *images;
62
63 /* Parsed */
64 gchar *firmware_version;
65 gchar *config_version;
66 gchar *carrier;
67 };
68
69 /******************************************************************************/
70
71 guint
72 qfu_image_cwe_get_n_embedded_headers (QfuImageCwe *self)
73 {
74 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), 0);
75
76 return (self->priv->images ? self->priv->images->len : 0);
77 }
78
79 gint
80 qfu_image_cwe_embedded_header_get_parent_index (QfuImageCwe *self,
81 guint embedded_i)
82 {
83 ImageInfo *info;
84
85 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), -1);
86 g_return_val_if_fail (self->priv->images, -1);
87 g_return_val_if_fail (embedded_i < self->priv->images->len, -1);
88
89 info = &g_array_index (self->priv->images, ImageInfo, embedded_i);
90 return info->parent_image_index;
91 }
92
93 const gchar *
94 qfu_image_cwe_embedded_header_get_type (QfuImageCwe *self,
95 guint embedded_i)
96 {
97 ImageInfo *info;
98
99 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), NULL);
100 g_return_val_if_fail (self->priv->images, NULL);
101 g_return_val_if_fail (embedded_i < self->priv->images->len, NULL);
102
103 info = &g_array_index (self->priv->images, ImageInfo, embedded_i);
104 return info->type;
105 }
106
107 const gchar *
108 qfu_image_cwe_embedded_header_get_product (QfuImageCwe *self,
109 guint embedded_i)
110 {
111 ImageInfo *info;
112
113 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), NULL);
114 g_return_val_if_fail (self->priv->images, NULL);
115 g_return_val_if_fail (embedded_i < self->priv->images->len, NULL);
116
117 info = &g_array_index (self->priv->images, ImageInfo, embedded_i);
118 return info->product;
119 }
120
121 const gchar *
122 qfu_image_cwe_embedded_header_get_version (QfuImageCwe *self,
123 guint embedded_i)
124 {
125 ImageInfo *info;
126
127 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), NULL);
128 g_return_val_if_fail (self->priv->images, NULL);
129 g_return_val_if_fail (embedded_i < self->priv->images->len, NULL);
130
131 info = &g_array_index (self->priv->images, ImageInfo, embedded_i);
132 return info->hdr.version;
133 }
134
135 const gchar *
136 qfu_image_cwe_embedded_header_get_date (QfuImageCwe *self,
137 guint embedded_i)
138 {
139 ImageInfo *info;
140
141 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), NULL);
142 g_return_val_if_fail (self->priv->images, NULL);
143 g_return_val_if_fail (embedded_i < self->priv->images->len, NULL);
144
145 info = &g_array_index (self->priv->images, ImageInfo, embedded_i);
146 return info->hdr.date;
147 }
148
149 guint32
150 qfu_image_cwe_embedded_header_get_image_size (QfuImageCwe *self,
151 guint embedded_i)
152 {
153 ImageInfo *info;
154
155 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), 0);
156 g_return_val_if_fail (self->priv->images, 0);
157 g_return_val_if_fail (embedded_i < self->priv->images->len, 0);
158
159 info = &g_array_index (self->priv->images, ImageInfo, embedded_i);
160 return GUINT32_FROM_BE (info->hdr.imgsize);
161 }
162
163 /******************************************************************************/
164 /* The 'main' header is the one at index 0 of the array, always */
165
166 const gchar *
167 qfu_image_cwe_header_get_type (QfuImageCwe *self)
168 {
169 return qfu_image_cwe_embedded_header_get_type (self, 0);
170 }
171
172 const gchar *
173 qfu_image_cwe_header_get_product (QfuImageCwe *self)
174 {
175 return qfu_image_cwe_embedded_header_get_product (self, 0);
176 }
177
178 const gchar *
179 qfu_image_cwe_header_get_version (QfuImageCwe *self)
180 {
181 return qfu_image_cwe_embedded_header_get_version (self, 0);
182 }
183
184 const gchar *
185 qfu_image_cwe_header_get_date (QfuImageCwe *self)
186 {
187 return qfu_image_cwe_embedded_header_get_date (self, 0);
188 }
189
190 guint32
191 qfu_image_cwe_header_get_image_size (QfuImageCwe *self)
192 {
193 return qfu_image_cwe_embedded_header_get_image_size (self, 0);
194 }
195
196 /******************************************************************************/
197
198 static void
199 parse_firmware_config_carrier (QfuImageCwe *self)
200 {
201 GError *inner_error = NULL;
202 guint i;
203
204 g_assert (!self->priv->firmware_version);
205 g_assert (!self->priv->config_version);
206 g_assert (!self->priv->carrier);
207
208 /* Try using the internal version first */
209 if (!qfu_utils_parse_cwe_version_string (
210 qfu_image_cwe_header_get_version (self),
211 &self->priv->firmware_version,
212 &self->priv->config_version,
213 &self->priv->carrier,
214 &inner_error)) {
215 /* Just log the error message */
216 g_debug ("[qfu-image-cwe] couldn't parse internal version string '%s': %s",
217 qfu_image_cwe_header_get_version (self),
218 inner_error->message);
219 g_clear_error (&inner_error);
220 }
221
222 /* If all retrieved with the internal version string, we're done */
223 if (self->priv->firmware_version && self->priv->config_version && self->priv->carrier)
224 goto done;
225
226 /* Try using the filename to gather more info */
227 if (!qfu_utils_parse_cwe_version_string (
228 qfu_image_get_display_name (QFU_IMAGE (self)),
229 self->priv->firmware_version ? NULL : &self->priv->firmware_version,
230 self->priv->config_version ? NULL : &self->priv->config_version,
231 self->priv->carrier ? NULL : &self->priv->carrier,
232 &inner_error)) {
233 /* Just log the error message */
234 g_debug ("[qfu-image-cwe] couldn't parse filename '%s': %s",
235 qfu_image_get_display_name (QFU_IMAGE (self)),
236 inner_error->message);
237 g_clear_error (&inner_error);
238 }
239
240 /* If all retrieved with the filename, we're done */
241 if (self->priv->firmware_version && self->priv->config_version && self->priv->carrier)
242 goto done;
243
244 /* Try with embedded images of type BOOT or NVU */
245 for (i = 0; i < self->priv->images->len; i++) {
246 ImageInfo *info;
247
248 info = &g_array_index (self->priv->images, ImageInfo, i);
249
250 /* BOOT partition in system images won't likely contain anything else
251 * than firmware version */
252 if (!g_strcmp0 (info->type, "BOOT") && !self->priv->firmware_version) {
253 if (!qfu_utils_parse_cwe_version_string (
254 info->hdr.version,
255 &self->priv->firmware_version,
256 NULL,
257 NULL,
258 &inner_error)) {
259 /* Just log the error message */
260 g_debug ("[qfu-image-cwe] couldn't parse BOOT version '%s': %s",
261 qfu_image_get_display_name (QFU_IMAGE (self)),
262 inner_error->message);
263 g_clear_error (&inner_error);
264 }
265 }
266
267 /* NVUP partition in nvu images are usually carrier-specific */
268 if (!g_strcmp0 (info->type, "NVUP")) {
269 if (!qfu_utils_parse_cwe_version_string (
270 info->hdr.version,
271 self->priv->firmware_version ? NULL : &self->priv->firmware_version,
272 self->priv->config_version ? NULL : &self->priv->config_version,
273 self->priv->carrier ? NULL : &self->priv->carrier,
274 &inner_error)) {
275 /* Just log the error message */
276 g_debug ("[qfu-image-cwe] couldn't parse NVUP version '%s': %s",
277 qfu_image_get_display_name (QFU_IMAGE (self)),
278 inner_error->message);
279 g_clear_error (&inner_error);
280 }
281 }
282
283 /* As soon as all retrieved, we're done */
284 if (self->priv->firmware_version && self->priv->config_version && self->priv->carrier)
285 goto done;
286 }
287
288 done:
289 g_debug ("[qfu-image-cwe] firmware version: %s", self->priv->firmware_version ? self->priv->firmware_version : "unknown");
290 g_debug ("[qfu-image-cwe] config version: %s", self->priv->config_version ? self->priv->config_version : "unknown");
291 g_debug ("[qfu-image-cwe] carrier: %s", self->priv->carrier ? self->priv->carrier : "unknown");
292 }
293
294 const gchar *
295 qfu_image_cwe_get_parsed_firmware_version (QfuImageCwe *self)
296 {
297 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), NULL);
298
299 return self->priv->firmware_version;
300 }
301
302 const gchar *
303 qfu_image_cwe_get_parsed_config_version (QfuImageCwe *self)
304 {
305 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), NULL);
306
307 return self->priv->config_version;
308 }
309
310 const gchar *
311 qfu_image_cwe_get_parsed_carrier (QfuImageCwe *self)
312 {
313 g_return_val_if_fail (QFU_IS_IMAGE_CWE (self), NULL);
314
315 return self->priv->carrier;
316 }
317
318 /******************************************************************************/
319
320 static goffset
321 get_header_size (QfuImage *self)
322 {
323 return (goffset) sizeof (QfuCweFileHeader);
324 }
325
326 static goffset
327 get_data_size (QfuImage *self)
328 {
329 return qfu_image_get_size (self) - sizeof (QfuCweFileHeader);
330 }
331
332 static gssize
333 read_header (QfuImage *_self,
334 guint8 *out_buffer,
335 gsize out_buffer_size,
336 GCancellable *cancellable,
337 GError **error)
338 {
339 QfuImageCwe *self = QFU_IMAGE_CWE (_self);
340 ImageInfo *info;
341
342 if (out_buffer_size < sizeof (QfuCweFileHeader)) {
343 g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
344 "buffer too small to read header");
345 return -1;
346 }
347
348 info = &g_array_index (self->priv->images, ImageInfo, 0);
349 memcpy (out_buffer, &(info->hdr), sizeof (QfuCweFileHeader));
350 return sizeof (QfuCweFileHeader);
351 }
352
353 /******************************************************************************/
354
355 static void
356 clear_image_info (ImageInfo *info)
357 {
358 g_free (info->type);
359 g_free (info->product);
360 }
361
362 static gboolean
363 is_ascii_str (const gchar *str,
364 guint str_len)
365 {
366 guint i;
367 guint real_len = 0;
368
369 for (i = 0; (str[i] != '\0') && (i < str_len); i++)
370 real_len++;
371
372 /* All valid characters need to be printable */
373 for (i = 0; i < real_len; i++) {
374 if (!g_ascii_isprint (str[i]))
375 return FALSE;
376 }
377
378 /* All remaining characters need to be zero */
379 for (i = real_len; i < str_len; i++) {
380 if (str[i] != '\0')
381 return FALSE;
382 }
383
384 return TRUE;
385 }
386
387 static gboolean
388 load_image_info (QfuImageCwe *self,
389 GInputStream *input_stream,
390 const gchar *parent_prefix,
391 gint parent_image_index,
392 goffset parent_image_end_offset,
393 GCancellable *cancellable,
394 GError **error)
395 {
396 ImageInfo info;
397 gssize n_read;
398 gchar *image_prefix;
399 guint image_index;
400 goffset image_start_offset;
401 goffset image_end_offset;
402 goffset walker;
403
404 /* Store image start offset */
405 image_start_offset = g_seekable_tell (G_SEEKABLE (input_stream));
406
407 memset (&info, 0, sizeof (info));
408
409 /* Store parent image index */
410 info.parent_image_index = parent_image_index;
411
412 /* Read header from file */
413 n_read = g_input_stream_read (input_stream, &(info.hdr), sizeof (QfuCweFileHeader), cancellable, error);
414 if (n_read < 0) {
415 g_prefix_error (error, "couldn't read file header: ");
416 return FALSE;
417 }
418 if (n_read != sizeof (QfuCweFileHeader)) {
419 g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
420 "CWE firmware image file is too short: full header not available");
421 return FALSE;
422 }
423
424 /* No image size reported */
425 if (!info.hdr.imgsize) {
426 g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "invalid image size");
427 return FALSE;
428 }
429
430 /* Check limits of the current image */
431 image_end_offset = image_start_offset + GUINT32_FROM_BE (info.hdr.imgsize) + sizeof (QfuCweFileHeader);
432 if (parent_image_end_offset > 0 && parent_image_end_offset < image_end_offset) {
433 g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "embedded image out of parent image bounds");
434 return FALSE;
435 }
436
437 /* Validate strings */
438 if (!is_ascii_str (info.hdr.type, sizeof (info.hdr.type)) ||
439 !is_ascii_str (info.hdr.product, sizeof (info.hdr.product)) ||
440 !is_ascii_str (info.hdr.version, sizeof (info.hdr.version)) ||
441 !is_ascii_str (info.hdr.date, sizeof (info.hdr.date))) {
442 g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "invalid strings given in image");
443 return FALSE;
444 }
445
446 /* Preload non-NUL terminated strings */
447 info.type = g_strndup (info.hdr.type, sizeof (info.hdr.type));
448 info.product = g_strndup (info.hdr.product, sizeof (info.hdr.product));
449
450 /* Valid image! We'll append to the array */
451 image_index = self->priv->images->len;
452 g_array_insert_val (self->priv->images, image_index, info);
453
454 g_debug ("[qfu-image-cwe] %simage offset range: [%" G_GOFFSET_FORMAT ",%" G_GOFFSET_FORMAT "]",
455 parent_prefix, image_start_offset, image_end_offset);
456
457 /* And check if it has embedded images */
458 image_prefix = g_strdup_printf ("%s ", parent_prefix);
459 walker = image_start_offset;
460 while (walker < image_end_offset) {
461 goffset tested_offset;
462 /* Read embedded image */
463 tested_offset = g_seekable_tell (G_SEEKABLE (input_stream));
464 if (!load_image_info (self, input_stream, image_prefix, image_index, image_end_offset, cancellable, NULL))
465 break;
466 g_debug ("[qfu-image-cwe] %simage at offset %" G_GOFFSET_FORMAT " is valid", parent_prefix, tested_offset);
467 walker = g_seekable_tell (G_SEEKABLE (input_stream));
468 }
469 g_free (image_prefix);
470
471 /* Finally, seek to just after this image */
472 if (!g_seekable_seek (G_SEEKABLE (input_stream), image_end_offset, G_SEEK_SET, cancellable, error)) {
473 g_prefix_error (error, "couldn't seek after image: ");
474 return FALSE;
475 }
476
477 return TRUE;
478 }
479
480 static gboolean
481 initable_init (GInitable *initable,
482 GCancellable *cancellable,
483 GError **error)
484 {
485 QfuImageCwe *self;
486 GInputStream *input_stream = NULL;
487 gboolean result = FALSE;
488
489 self = QFU_IMAGE_CWE (initable);
490
491 /* Run parent initable */
492 if (!iface_initable_parent->init (initable, cancellable, error))
493 return FALSE;
494
495 g_object_get (self, "input-stream", &input_stream, NULL);
496 g_assert (G_IS_FILE_INPUT_STREAM (input_stream));
497
498 g_debug ("[qfu-image-cwe] reading image headers...");
499 if (!g_seekable_seek (G_SEEKABLE (input_stream), 0, G_SEEK_SET, cancellable, error)) {
500 g_prefix_error (error, "couldn't seek input stream: ");
501 goto out;
502 }
503 if (!load_image_info (self, input_stream, "", -1, (goffset) -1, cancellable, error)) {
504 g_prefix_error (error, "couldn't read file header: ");
505 goto out;
506 }
507
508 g_debug ("[qfu-image-cwe] validating data size...");
509 if (qfu_image_get_data_size (QFU_IMAGE (self)) != qfu_image_cwe_header_get_image_size (self)) {
510 g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
511 "CWE image file size mismatch (expected size: %" G_GUINT32_FORMAT " bytes, real size: %" G_GOFFSET_FORMAT " bytes)",
512 qfu_image_cwe_header_get_image_size (self), qfu_image_get_data_size (QFU_IMAGE (self)));
513 goto out;
514 }
515
516 g_debug ("[qfu-image-cwe] preloading firmware/config/carrier...");
517 parse_firmware_config_carrier (self);
518
519 /* Success! */
520 result = TRUE;
521
522 out:
523 g_object_unref (input_stream);
524 return result;
525 }
526
527 /******************************************************************************/
528
529 QfuImage *
530 qfu_image_cwe_new (GFile *file,
531 GCancellable *cancellable,
532 GError **error)
533 {
534 g_return_val_if_fail (G_IS_FILE (file), NULL);
535
536 return QFU_IMAGE (g_initable_new (QFU_TYPE_IMAGE_CWE,
537 cancellable,
538 error,
539 "file", file,
540 "image-type", QFU_IMAGE_TYPE_CWE,
541 NULL));
542 }
543
544 static void
545 qfu_image_cwe_init (QfuImageCwe *self)
546 {
547 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, QFU_TYPE_IMAGE_CWE, QfuImageCwePrivate);
548
549 self->priv->images = g_array_new (FALSE, FALSE, sizeof (ImageInfo));
550 g_array_set_clear_func (self->priv->images, (GDestroyNotify) clear_image_info);
551 }
552
553 static void
554 finalize (GObject *object)
555 {
556 QfuImageCwe *self = QFU_IMAGE_CWE (object);
557
558 g_free (self->priv->firmware_version);
559 g_free (self->priv->config_version);
560 g_free (self->priv->carrier);
561 g_array_unref (self->priv->images);
562
563 G_OBJECT_CLASS (qfu_image_cwe_parent_class)->finalize (object);
564 }
565
566 static void
567 initable_iface_init (GInitableIface *iface)
568 {
569 iface_initable_parent = g_type_interface_peek_parent (iface);
570 iface->init = initable_init;
571 }
572
573 static void
574 qfu_image_cwe_class_init (QfuImageCweClass *klass)
575 {
576 GObjectClass *object_class = G_OBJECT_CLASS (klass);
577 QfuImageClass *image_class = QFU_IMAGE_CLASS (klass);
578
579 g_type_class_add_private (object_class, sizeof (QfuImageCwePrivate));
580
581 object_class->finalize = finalize;
582
583 image_class->get_header_size = get_header_size;
584 image_class->get_data_size = get_data_size;
585 image_class->read_header = read_header;
586
587 }