proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-05-16 13:54:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c6afb51e32
fwupd/libdfu/dfu-self-test.c
Richard Hughes cef8042edc libdfu: Add DfuPatch 
This allows us to binary patch firmware images.

The diff generation is implemented with a forwards-only algorithm; this allows
a vendor to remove non-free code without shipping a "reversed" version of the
non-redistributable code.
2017-07-31 11:58:21 +01:00

991 lines
32 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2015 Richard Hughes <richard@hughsie.com>
*
* Licensed under the GNU General Public License Version 2
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <fnmatch.h>
#include "dfu-common.h"
#include "dfu-context.h"
#include "dfu-device.h"
#include "dfu-error.h"
#include "dfu-firmware.h"
#include "dfu-patch.h"
#include "dfu-sector-private.h"
#include "dfu-target-private.h"
static gchar *
dfu_test_get_filename (const gchar *filename)
{
gchar *tmp;
char full_tmp[PATH_MAX];
g_autofree gchar *path = NULL;
path = g_build_filename (TESTDATADIR, filename, NULL);
tmp = realpath (path, full_tmp);
if (tmp == NULL)
return NULL;
return g_strdup (full_tmp);
}
static gboolean
dfu_test_compare_lines (const gchar *txt1, const gchar *txt2, GError **error)
{
g_autofree gchar *output = NULL;
/* exactly the same */
if (g_strcmp0 (txt1, txt2) == 0)
return TRUE;
/* matches a pattern */
if (fnmatch (txt2, txt1, FNM_NOESCAPE) == 0)
return TRUE;
/* save temp files and diff them */
if (!g_file_set_contents ("/tmp/a", txt1, -1, error))
return FALSE;
if (!g_file_set_contents ("/tmp/b", txt2, -1, error))
return FALSE;
if (!g_spawn_command_line_sync ("diff -urNp /tmp/b /tmp/a",
&output, NULL, NULL, error))
return FALSE;
/* just output the diff */
g_set_error_literal (error, 1, 0, output);
return FALSE;
}
static gchar *
_g_bytes_compare_verbose (GBytes *bytes1, GBytes *bytes2)
{
const guint8 *data1;
const guint8 *data2;
gsize length1;
gsize length2;
guint i;
data1 = g_bytes_get_data (bytes1, &length1);
data2 = g_bytes_get_data (bytes2, &length2);
/* not the same length */
if (length1 != length2) {
return g_strdup_printf ("got %" G_GSIZE_FORMAT " bytes, "
"expected %" G_GSIZE_FORMAT,
length1, length2);
}
/* return 00 01 02 03 */
for (i = 0; i < length1; i++) {
if (data1[i] != data2[i]) {
return g_strdup_printf ("got 0x%02x, expected 0x%02x @ 0x%04x",
data1[i], data2[i], i);
}
}
return NULL;
}
static void
dfu_firmware_xdfu_func (void)
{
gboolean ret;
g_autofree gchar *fn = NULL;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GFile) file = NULL;
fn = dfu_test_get_filename ("example.xdfu");
g_assert (fn != NULL);
firmware = dfu_firmware_new ();
file = g_file_new_for_path (fn);
ret = dfu_firmware_parse_file (firmware, file,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_cipher_kind (firmware), ==, DFU_CIPHER_KIND_XTEA);
}
static void
dfu_enums_func (void)
{
guint i;
for (i = 0; i < DFU_STATE_LAST; i++)
g_assert_cmpstr (dfu_state_to_string (i), !=, NULL);
for (i = 0; i < DFU_STATUS_LAST; i++)
g_assert_cmpstr (dfu_status_to_string (i), !=, NULL);
}
static GBytes *
dfu_self_test_get_bytes_for_file (GFile *file, GError **error)
{
gchar *contents = NULL;
gsize length = 0;
if (!g_file_load_contents (file, NULL, &contents, &length, NULL, error))
return NULL;
return g_bytes_new_take (contents, length);
}
static void
dfu_firmware_raw_func (void)
{
DfuElement *element;
DfuImage *image_tmp;
GBytes *no_suffix_contents;
gchar buf[256];
guint i;
gboolean ret;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GBytes) fw = NULL;
g_autoptr(GBytes) roundtrip_orig = NULL;
g_autoptr(GBytes) roundtrip = NULL;
g_autoptr(GError) error = NULL;
/* set up some dummy data */
for (i = 0; i < 256; i++)
buf[i] = (gchar) i;
fw = g_bytes_new_static (buf, 256);
/* load a non DFU firmware */
firmware = dfu_firmware_new ();
ret = dfu_firmware_parse_data (firmware, fw, DFU_FIRMWARE_PARSE_FLAG_NONE, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_vid (firmware), ==, 0xffff);
g_assert_cmpint (dfu_firmware_get_pid (firmware), ==, 0xffff);
g_assert_cmpint (dfu_firmware_get_release (firmware), ==, 0xffff);
g_assert_cmpint (dfu_firmware_get_format (firmware), ==, DFU_FIRMWARE_FORMAT_RAW);
g_assert_cmpint (dfu_firmware_get_cipher_kind (firmware), ==, DFU_CIPHER_KIND_NONE);
image_tmp = dfu_firmware_get_image (firmware, 0xfe);
g_assert (image_tmp == NULL);
image_tmp = dfu_firmware_get_image (firmware, 0);
g_assert (image_tmp != NULL);
g_assert_cmpint (dfu_image_get_size (image_tmp), ==, 256);
element = dfu_image_get_element (image_tmp, 0);
g_assert (element != NULL);
no_suffix_contents = dfu_element_get_contents (element);
g_assert (no_suffix_contents != NULL);
g_assert_cmpint (g_bytes_compare (no_suffix_contents, fw), ==, 0);
/* can we roundtrip without adding data */
roundtrip = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (roundtrip != NULL);
g_assert_cmpstr (_g_bytes_compare_verbose (roundtrip, fw), ==, NULL);
}
static void
dfu_firmware_dfu_func (void)
{
gchar buf[256];
guint i;
gboolean ret;
g_autofree gchar *filename = NULL;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(DfuImage) image = NULL;
g_autoptr(DfuElement) element = NULL;
g_autoptr(GBytes) data = NULL;
g_autoptr(GBytes) fw = NULL;
g_autoptr(GBytes) roundtrip_orig = NULL;
g_autoptr(GBytes) roundtrip = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GFile) file = NULL;
/* set up some dummy data */
for (i = 0; i < 256; i++)
buf[i] = (gchar) i;
fw = g_bytes_new_static (buf, 256);
/* write DFU format */
firmware = dfu_firmware_new ();
dfu_firmware_set_format (firmware, DFU_FIRMWARE_FORMAT_DFU);
dfu_firmware_set_vid (firmware, 0x1234);
dfu_firmware_set_pid (firmware, 0x5678);
dfu_firmware_set_release (firmware, 0xfedc);
image = dfu_image_new ();
element = dfu_element_new ();
dfu_element_set_contents (element, fw);
dfu_image_add_element (image, element);
dfu_firmware_add_image (firmware, image);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 256);
data = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (data != NULL);
/* can we load it again? */
g_ptr_array_set_size (dfu_firmware_get_images (firmware), 0);
ret = dfu_firmware_parse_data (firmware, data, DFU_FIRMWARE_PARSE_FLAG_NONE, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_vid (firmware), ==, 0x1234);
g_assert_cmpint (dfu_firmware_get_pid (firmware), ==, 0x5678);
g_assert_cmpint (dfu_firmware_get_release (firmware), ==, 0xfedc);
g_assert_cmpint (dfu_firmware_get_format (firmware), ==, DFU_FIRMWARE_FORMAT_DFU);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 256);
/* load a real firmware */
filename = dfu_test_get_filename ("kiibohd.dfu.bin");
g_assert (filename != NULL);
file = g_file_new_for_path (filename);
g_ptr_array_set_size (dfu_firmware_get_images (firmware), 0);
ret = dfu_firmware_parse_file (firmware, file,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_vid (firmware), ==, 0x1c11);
g_assert_cmpint (dfu_firmware_get_pid (firmware), ==, 0xb007);
g_assert_cmpint (dfu_firmware_get_release (firmware), ==, 0xffff);
g_assert_cmpint (dfu_firmware_get_format (firmware), ==, DFU_FIRMWARE_FORMAT_DFU);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 0x8eB4);
g_assert_cmpint (dfu_firmware_get_cipher_kind (firmware), ==, DFU_CIPHER_KIND_NONE);
/* can we roundtrip without loosing data */
roundtrip_orig = dfu_self_test_get_bytes_for_file (file, &error);
g_assert_no_error (error);
g_assert (roundtrip_orig != NULL);
roundtrip = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (roundtrip != NULL);
g_assert_cmpstr (_g_bytes_compare_verbose (roundtrip, roundtrip_orig), ==, NULL);
}
static void
dfu_firmware_dfuse_func (void)
{
gboolean ret;
g_autofree gchar *filename = NULL;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GBytes) roundtrip_orig = NULL;
g_autoptr(GBytes) roundtrip = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GFile) file = NULL;
/* load a DeFUse firmware */
g_setenv ("DFU_SELF_TEST_IMAGE_MEMCPY_NAME", "", FALSE);
filename = dfu_test_get_filename ("dev_VRBRAIN.dfu");
g_assert (filename != NULL);
file = g_file_new_for_path (filename);
firmware = dfu_firmware_new ();
ret = dfu_firmware_parse_file (firmware, file,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_vid (firmware), ==, 0x0483);
g_assert_cmpint (dfu_firmware_get_pid (firmware), ==, 0x0000);
g_assert_cmpint (dfu_firmware_get_release (firmware), ==, 0x0000);
g_assert_cmpint (dfu_firmware_get_format (firmware), ==, DFU_FIRMWARE_FORMAT_DFUSE);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 0x168d5);
g_assert_cmpint (dfu_firmware_get_cipher_kind (firmware), ==, DFU_CIPHER_KIND_NONE);
/* can we roundtrip without loosing data */
roundtrip_orig = dfu_self_test_get_bytes_for_file (file, &error);
g_assert_no_error (error);
g_assert (roundtrip_orig != NULL);
roundtrip = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (roundtrip != NULL);
// g_file_set_contents ("/tmp/1.bin",
// g_bytes_get_data (roundtrip, NULL),
// g_bytes_get_size (roundtrip), NULL);
g_assert_cmpstr (_g_bytes_compare_verbose (roundtrip, roundtrip_orig), ==, NULL);
/* use usual image name copying */
g_unsetenv ("DFU_SELF_TEST_IMAGE_MEMCPY_NAME");
}
static void
dfu_firmware_metadata_func (void)
{
gboolean ret;
g_autofree gchar *filename = NULL;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GBytes) roundtrip_orig = NULL;
g_autoptr(GBytes) roundtrip = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GFile) file = NULL;
/* load a DFU firmware with a metadata table */
filename = dfu_test_get_filename ("metadata.dfu");
g_assert (filename != NULL);
file = g_file_new_for_path (filename);
firmware = dfu_firmware_new ();
ret = dfu_firmware_parse_file (firmware, file,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 6);
g_assert_cmpstr (dfu_firmware_get_metadata (firmware, "key"), ==, "value");
g_assert_cmpstr (dfu_firmware_get_metadata (firmware, "???"), ==, NULL);
/* can we roundtrip without loosing data */
roundtrip_orig = dfu_self_test_get_bytes_for_file (file, &error);
g_assert_no_error (error);
g_assert (roundtrip_orig != NULL);
roundtrip = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (roundtrip != NULL);
g_assert_cmpstr (_g_bytes_compare_verbose (roundtrip, roundtrip_orig), ==, NULL);
}
static void
dfu_firmware_elf_func (void)
{
DfuElement *element;
DfuImage *image;
GBytes *contents;
const gchar *data;
gboolean ret;
g_autofree gchar *filename = NULL;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GBytes) roundtrip_orig = NULL;
g_autoptr(GBytes) roundtrip = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GFile) file = NULL;
#ifndef HAVE_LIBELF
g_test_skip ("compiled without libelf support");
return;
#endif
/* load a ELF firmware */
filename = dfu_test_get_filename ("example.elf");
g_assert (filename != NULL);
file = g_file_new_for_path (filename);
firmware = dfu_firmware_new ();
ret = dfu_firmware_parse_file (firmware, file,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_vid (firmware), ==, 0xffff);
g_assert_cmpint (dfu_firmware_get_pid (firmware), ==, 0xffff);
g_assert_cmpint (dfu_firmware_get_release (firmware), ==, 0xffff);
g_assert_cmpint (dfu_firmware_get_format (firmware), ==, DFU_FIRMWARE_FORMAT_ELF);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 0x0c);
g_assert_cmpint (dfu_firmware_get_cipher_kind (firmware), ==, DFU_CIPHER_KIND_NONE);
/* check the data */
image = dfu_firmware_get_image_default (firmware);
g_assert (image != NULL);
element = dfu_image_get_element_default (image);
g_assert (element != NULL);
contents = dfu_element_get_contents (element);
g_assert (contents != NULL);
g_assert_cmpint (g_bytes_get_size (contents), ==, 12);
data = g_bytes_get_data (contents, NULL);
g_assert (data != NULL);
g_assert (memcmp (data, "hello world\n", 12) == 0);
/* can we roundtrip without loosing data */
roundtrip_orig = dfu_self_test_get_bytes_for_file (file, &error);
g_assert_no_error (error);
g_assert (roundtrip_orig != NULL);
roundtrip = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (roundtrip != NULL);
g_assert_cmpstr (_g_bytes_compare_verbose (roundtrip, roundtrip_orig), ==, NULL);
}
static void
dfu_firmware_intel_hex_func (void)
{
const guint8 *data;
gboolean ret;
gsize len;
g_autofree gchar *filename_hex = NULL;
g_autofree gchar *filename_ref = NULL;
g_autofree gchar *str = NULL;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GBytes) data_bin2 = NULL;
g_autoptr(GBytes) data_bin = NULL;
g_autoptr(GBytes) data_hex = NULL;
g_autoptr(GBytes) data_ref = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GFile) file_bin = NULL;
g_autoptr(GFile) file_hex = NULL;
/* load a Intel hex32 file */
filename_hex = dfu_test_get_filename ("firmware.hex");
g_assert (filename_hex != NULL);
file_hex = g_file_new_for_path (filename_hex);
firmware = dfu_firmware_new ();
ret = dfu_firmware_parse_file (firmware, file_hex,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 136);
dfu_firmware_set_format (firmware, DFU_FIRMWARE_FORMAT_RAW);
data_bin = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (data_bin != NULL);
/* did we match the reference file? */
filename_ref = dfu_test_get_filename ("firmware.bin");
g_assert (filename_ref != NULL);
file_bin = g_file_new_for_path (filename_ref);
data_ref = dfu_self_test_get_bytes_for_file (file_bin, &error);
g_assert_no_error (error);
g_assert (data_ref != NULL);
g_assert_cmpstr (_g_bytes_compare_verbose (data_bin, data_ref), ==, NULL);
/* export a ihex file (which will be slightly different due to
* non-continous regions being expanded */
dfu_firmware_set_format (firmware, DFU_FIRMWARE_FORMAT_INTEL_HEX);
data_hex = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (data_hex != NULL);
data = g_bytes_get_data (data_hex, &len);
str = g_strndup ((const gchar *) data, len);
g_assert_cmpstr (str, ==,
":104000003DEF20F000000000FACF01F0FBCF02F0AF\n"
":10401000E9CF03F0EACF04F0E1CF05F0E2CF06F005\n"
":10402000D9CF07F0DACF08F0F3CF09F0F4CF0AF021\n"
":10403000F6CF0BF0F7CF0CF0F8CF0DF0F5CF0EF044\n"
":104040000EC0F5FF0DC0F8FF0CC0F7FF0BC0F6FF45\n"
":104050000AC0F4FF09C0F3FF08C0DAFF07C0D9FF24\n"
":1040600006C0E2FF05C0E1FF04C0EAFF03C0E9FF0A\n"
":1040700002C0FBFF01C0FAFF11003FEF20F00001BB\n"
":0840800042EF20F03DEF20F037\n"
":00000001FF\n");
/* do we match the binary file again */
dfu_firmware_set_format (firmware, DFU_FIRMWARE_FORMAT_RAW);
data_bin2 = dfu_firmware_write_data (firmware, &error);
g_assert_no_error (error);
g_assert (data_bin2 != NULL);
g_assert_cmpstr (_g_bytes_compare_verbose (data_bin, data_bin2), ==, NULL);
}
static void
dfu_firmware_intel_hex_signed_func (void)
{
DfuElement *element;
DfuImage *image;
GBytes *data_sig;
const guint8 *data;
gboolean ret;
gsize len;
g_autofree gchar *filename_hex = NULL;
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GFile) file_hex = NULL;
/* load a Intel hex32 file */
filename_hex = dfu_test_get_filename ("firmware.shex");
g_assert (filename_hex != NULL);
file_hex = g_file_new_for_path (filename_hex);
firmware = dfu_firmware_new ();
ret = dfu_firmware_parse_file (firmware, file_hex,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_firmware_get_size (firmware), ==, 144);
/* get the signed image element */
image = dfu_firmware_get_image_by_name (firmware, "signature");
g_assert (image != NULL);
element = dfu_image_get_element_default (image);
data_sig = dfu_element_get_contents (element);
g_assert (data_sig != NULL);
data = g_bytes_get_data (data_sig, &len);
g_assert_cmpint (len, ==, 8);
g_assert (data != NULL);
}
static void
dfu_device_func (void)
{
GPtrArray *targets;
gboolean ret;
g_autoptr(DfuDevice) device = NULL;
g_autoptr(DfuTarget) target1 = NULL;
g_autoptr(DfuTarget) target2 = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GUsbContext) usb_ctx = NULL;
g_autoptr(GUsbDevice) usb_device = NULL;
/* find any DFU in appIDLE mode */
usb_ctx = g_usb_context_new (&error);
g_assert_no_error (error);
g_assert (usb_ctx != NULL);
g_usb_context_enumerate (usb_ctx);
usb_device = g_usb_context_find_by_vid_pid (usb_ctx,
0x273f,
0x1005,
&error);
if (usb_device == NULL)
return;
g_assert_no_error (error);
g_assert (usb_device != NULL);
/* check it's DFU-capable */
device = dfu_device_new (usb_device);
g_assert (device != NULL);
/* get targets */
targets = dfu_device_get_targets (device);
g_assert_cmpint (targets->len, ==, 2);
/* get by ID */
target1 = dfu_device_get_target_by_alt_setting (device, 1, &error);
g_assert_no_error (error);
g_assert (target1 != NULL);
/* ensure open */
ret = dfu_device_open (device, DFU_DEVICE_OPEN_FLAG_NONE, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
/* get by name */
target2 = dfu_device_get_target_by_alt_name (device, "sram", &error);
g_assert_no_error (error);
g_assert (target2 != NULL);
/* close */
ret = dfu_device_close (device, &error);
g_assert_no_error (error);
g_assert (ret);
}
static void
dfu_colorhug_plus_func (void)
{
GPtrArray *elements;
gboolean ret;
gboolean seen_app_idle = FALSE;
g_autoptr(DfuContext) context = NULL;
g_autoptr(DfuDevice) device = NULL;
g_autoptr(DfuDevice) device2 = NULL;
g_autoptr(DfuTarget) target = NULL;
g_autoptr(DfuImage) image = NULL;
g_autoptr(GError) error = NULL;
/* create context */
context = dfu_context_new ();
ret = dfu_context_enumerate (context, &error);
g_assert_no_error (error);
g_assert (ret);
/* push appIDLE into dfuIDLE */
device2 = dfu_context_get_device_by_vid_pid (context,
0x273f,
0x1002,
NULL);
if (device2 != NULL) {
ret = dfu_device_open (device2, DFU_DEVICE_OPEN_FLAG_NONE, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
ret = dfu_device_detach (device2, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
/* wait for it to come back as 273f:1005 */
ret = dfu_device_wait_for_replug (device2, 5000, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
/* close it */
ret = dfu_device_close (device2, &error);
g_assert_no_error (error);
g_assert (ret);
}
/* find any DFU in dfuIDLE mode */
device = dfu_context_get_device_by_vid_pid (context,
0x273f,
0x1003,
NULL);
if (device == NULL)
return;
/* we don't know this unless we went from appIDLE -> dfuIDLE */
if (device2 == NULL) {
g_assert_cmpint (dfu_device_get_runtime_vid (device), ==, 0xffff);
g_assert_cmpint (dfu_device_get_runtime_pid (device), ==, 0xffff);
}
/* open it */
ret = dfu_device_open (device, DFU_DEVICE_OPEN_FLAG_NONE, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
/* is in dfuIDLE mode */
g_assert_cmpstr (dfu_state_to_string (dfu_device_get_state (device)), ==, "dfuIDLE");
/* lets try and flash something inappropriate */
if (seen_app_idle) {
g_autoptr(DfuFirmware) firmware = NULL;
g_autoptr(GFile) file = NULL;
g_autofree gchar *filename = NULL;
filename = dfu_test_get_filename ("kiibohd.dfu.bin");
g_assert (filename != NULL);
file = g_file_new_for_path (filename);
firmware = dfu_firmware_new ();
ret = dfu_firmware_parse_file (firmware, file,
DFU_FIRMWARE_PARSE_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
ret = dfu_device_download (device, firmware,
DFU_TARGET_TRANSFER_FLAG_DETACH |
DFU_TARGET_TRANSFER_FLAG_WAIT_RUNTIME,
NULL, &error);
g_assert_error (error,
DFU_ERROR,
DFU_ERROR_INTERNAL);
g_assert (ret);
g_clear_error (&error);
}
/* get a dump of the existing firmware */
target = dfu_device_get_target_by_alt_setting (device, 0, &error);
g_assert_no_error (error);
g_assert (target != NULL);
image = dfu_target_upload (target, DFU_TARGET_TRANSFER_FLAG_NONE,
NULL, &error);
g_assert_no_error (error);
g_assert (DFU_IS_IMAGE (image));
elements = dfu_image_get_elements (image);
g_assert (elements != NULL);
g_assert_cmpint (elements->len, ==, 1);
/* download a new firmware */
ret = dfu_target_download (target, image,
DFU_TARGET_TRANSFER_FLAG_VERIFY |
DFU_TARGET_TRANSFER_FLAG_ATTACH,
NULL, &error);
g_assert_no_error (error);
g_assert (ret);
/* wait for it to come back as 273f:1004 */
ret = dfu_device_wait_for_replug (device, 5000, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
/* we should know now */
g_assert_cmpint (dfu_device_get_runtime_vid (device), ==, 0x273f);
g_assert_cmpint (dfu_device_get_runtime_pid (device), ==, 0x1002);
}
static gchar *
dfu_target_sectors_to_string (DfuTarget *target)
{
DfuSector *sector;
GPtrArray *sectors;
GString *str;
guint i;
str = g_string_new ("");
sectors = dfu_target_get_sectors (target);
for (i = 0; i < sectors->len; i++) {
g_autofree gchar *tmp = NULL;
sector = g_ptr_array_index (sectors, i);
tmp = dfu_sector_to_string (sector);
g_string_append_printf (str, "%s\n", tmp);
}
if (str->len > 0)
g_string_truncate (str, str->len - 1);
return g_string_free (str, FALSE);
}
static void
dfu_target_dfuse_func (void)
{
gboolean ret;
gchar *tmp;
g_autoptr(DfuTarget) target = NULL;
g_autoptr(GError) error = NULL;
/* NULL */
target = g_object_new (DFU_TYPE_TARGET, NULL);
ret = dfu_target_parse_sectors (target, NULL, &error);
g_assert_no_error (error);
g_assert (ret);
tmp = dfu_target_sectors_to_string (target);
g_assert_cmpstr (tmp, ==, "");
g_free (tmp);
/* no addresses */
ret = dfu_target_parse_sectors (target, "@Flash3", &error);
g_assert_no_error (error);
g_assert (ret);
tmp = dfu_target_sectors_to_string (target);
g_assert_cmpstr (tmp, ==, "");
g_free (tmp);
/* one sector, no space */
ret = dfu_target_parse_sectors (target, "@Internal Flash /0x08000000/2*001Ka", &error);
g_assert_no_error (error);
g_assert (ret);
tmp = dfu_target_sectors_to_string (target);
ret = dfu_test_compare_lines (tmp,
"Zone:0, Sec#:0, Addr:0x08000000, Size:0x0400, Caps:0x1 [R]\n"
"Zone:0, Sec#:0, Addr:0x08000400, Size:0x0400, Caps:0x1 [R]",
&error);
g_assert_no_error (error);
g_assert (ret);
g_free (tmp);
/* multiple sectors */
ret = dfu_target_parse_sectors (target, "@Flash1 /0x08000000/2*001Ka,4*001Kg", &error);
g_assert_no_error (error);
g_assert (ret);
tmp = dfu_target_sectors_to_string (target);
ret = dfu_test_compare_lines (tmp,
"Zone:0, Sec#:0, Addr:0x08000000, Size:0x0400, Caps:0x1 [R]\n"
"Zone:0, Sec#:0, Addr:0x08000400, Size:0x0400, Caps:0x1 [R]\n"
"Zone:0, Sec#:1, Addr:0x08000800, Size:0x0400, Caps:0x7 [REW]\n"
"Zone:0, Sec#:1, Addr:0x08000c00, Size:0x0400, Caps:0x7 [REW]\n"
"Zone:0, Sec#:1, Addr:0x08001000, Size:0x0400, Caps:0x7 [REW]\n"
"Zone:0, Sec#:1, Addr:0x08001400, Size:0x0400, Caps:0x7 [REW]",
&error);
g_assert_no_error (error);
g_assert (ret);
g_free (tmp);
/* non-contiguous */
ret = dfu_target_parse_sectors (target, "@Flash2 /0xF000/4*100Ba/0xE000/3*8Kg/0x80000/2*24Kg", &error);
g_assert_no_error (error);
g_assert (ret);
tmp = dfu_target_sectors_to_string (target);
ret = dfu_test_compare_lines (tmp,
"Zone:0, Sec#:0, Addr:0x0000f000, Size:0x0064, Caps:0x1 [R]\n"
"Zone:0, Sec#:0, Addr:0x0000f064, Size:0x0064, Caps:0x1 [R]\n"
"Zone:0, Sec#:0, Addr:0x0000f0c8, Size:0x0064, Caps:0x1 [R]\n"
"Zone:0, Sec#:0, Addr:0x0000f12c, Size:0x0064, Caps:0x1 [R]\n"
"Zone:1, Sec#:0, Addr:0x0000e000, Size:0x2000, Caps:0x7 [REW]\n"
"Zone:1, Sec#:0, Addr:0x00010000, Size:0x2000, Caps:0x7 [REW]\n"
"Zone:1, Sec#:0, Addr:0x00012000, Size:0x2000, Caps:0x7 [REW]\n"
"Zone:2, Sec#:0, Addr:0x00080000, Size:0x6000, Caps:0x7 [REW]\n"
"Zone:2, Sec#:0, Addr:0x00086000, Size:0x6000, Caps:0x7 [REW]",
&error);
g_assert_no_error (error);
g_assert (ret);
g_free (tmp);
/* invalid */
ret = dfu_target_parse_sectors (target, "Flash", NULL);
g_assert (ret);
ret = dfu_target_parse_sectors (target, "@Internal Flash /0x08000000", NULL);
g_assert (!ret);
ret = dfu_target_parse_sectors (target, "@Internal Flash /0x08000000/12*001a", NULL);
g_assert (!ret);
/* indicate a cipher being used */
g_assert_cmpint (dfu_target_get_cipher_kind (target), ==, DFU_CIPHER_KIND_NONE);
ret = dfu_target_parse_sectors (target, "@Flash|XTEA", &error);
g_assert_no_error (error);
g_assert (ret);
g_assert_cmpint (dfu_target_get_cipher_kind (target), ==, DFU_CIPHER_KIND_XTEA);
}
static gboolean
dfu_patch_create_from_strings (DfuPatch *patch,
const gchar *dold,
const gchar *dnew,
GError **error)
{
guint32 sz1 = strlen (dold);
guint32 sz2 = strlen (dnew);
g_autoptr(GBytes) blob1 = g_bytes_new (dold, sz1);
g_autoptr(GBytes) blob2 = g_bytes_new (dnew, sz2);
g_debug ("compare:\n%s\n%s", dold, dnew);
return dfu_patch_create (patch, blob1, blob2, error);
}
static void
dfu_patch_merges_func (void)
{
const guint8 *data;
gboolean ret;
gsize sz;
g_autoptr(DfuPatch) patch = dfu_patch_new ();
g_autoptr(GBytes) blob = NULL;
g_autoptr(GError) error = NULL;
/* check merges happen */
ret = dfu_patch_create_from_strings (patch, "XXX", "YXY", &error);
g_assert_no_error (error);
g_assert (ret);
blob = dfu_patch_export (patch, &error);
g_assert_no_error (error);
g_assert (ret);
data = g_bytes_get_data (blob, &sz);
g_assert_cmpint (data[0x00], ==, 'D');
g_assert_cmpint (data[0x01], ==, 'f');
g_assert_cmpint (data[0x02], ==, 'u');
g_assert_cmpint (data[0x03], ==, 'P');
g_assert_cmpint (data[0x04], ==, 0x00); /* reserved */
g_assert_cmpint (data[0x05], ==, 0x00);
g_assert_cmpint (data[0x06], ==, 0x00);
g_assert_cmpint (data[0x07], ==, 0x00);
g_assert_cmpint (data[0x08 + 0x28], ==, 0x00); /* chunk1, offset */
g_assert_cmpint (data[0x09 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0a + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0b + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0c + 0x28], ==, 0x03); /* chunk1, size */
g_assert_cmpint (data[0x0d + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0e + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0f + 0x28], ==, 0x00);
g_assert_cmpint (data[0x10 + 0x28], ==, 0x00); /* reserved */
g_assert_cmpint (data[0x11 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x12 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x13 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x14 + 0x28], ==, 'Y');
g_assert_cmpint (data[0x15 + 0x28], ==, 'X');
g_assert_cmpint (data[0x16 + 0x28], ==, 'Y');
g_assert_cmpint (sz, ==, 48 /* hdr */ + 12 /* chunk */ + 3 /* data */);
}
static void
dfu_patch_apply_func (void)
{
gboolean ret;
g_autoptr(DfuPatch) patch = dfu_patch_new ();
g_autoptr(GBytes) blob_new2 = NULL;
g_autoptr(GBytes) blob_new3 = NULL;
g_autoptr(GBytes) blob_new4 = NULL;
g_autoptr(GBytes) blob_new = NULL;
g_autoptr(GBytes) blob_old = NULL;
g_autoptr(GBytes) blob_wrong = NULL;
g_autoptr(GError) error = NULL;
/* create a patch */
blob_old = g_bytes_new_static ("helloworldhelloworldhelloworldhelloworld", 40);
blob_new = g_bytes_new_static ("XelloXorldhelloworldhelloworldhelloworlXXX", 42);
ret = dfu_patch_create (patch, blob_old, blob_new, &error);
g_assert_no_error (error);
g_assert (ret);
/* apply the patch */
blob_new2 = dfu_patch_apply (patch, blob_old, DFU_PATCH_APPLY_FLAG_NONE, &error);
g_assert_no_error (error);
g_assert (blob_new2 != NULL);
g_assert_cmpint (g_bytes_compare (blob_new, blob_new2), ==, 0);
/* check we force the patch to an unrelated blob */
blob_wrong = g_bytes_new_static ("wrongwrongwrongwrongwrongwrongwrongwrong", 40);
blob_new3 = dfu_patch_apply (patch, blob_wrong, DFU_PATCH_APPLY_FLAG_IGNORE_CHECKSUM, &error);
g_assert_no_error (error);
g_assert (blob_new3 != NULL);
/* check we can't apply the patch to an unrelated blob */
blob_new4 = dfu_patch_apply (patch, blob_wrong, DFU_PATCH_APPLY_FLAG_NONE, &error);
g_assert_error (error, DFU_ERROR, DFU_ERROR_INVALID_DEVICE);
g_assert (blob_new4 == NULL);
}
static void
dfu_patch_func (void)
{
const guint8 *data;
gboolean ret;
gsize sz;
g_autoptr(DfuPatch) patch = dfu_patch_new ();
g_autoptr(DfuPatch) patch2 = dfu_patch_new ();
g_autoptr(GBytes) blob = NULL;
g_autoptr(GError) error = NULL;
g_autofree gchar *serialized_str = NULL;
/* create binary diff */
ret = dfu_patch_create_from_strings (patch, "XXX", "XYY", &error);
g_assert_no_error (error);
g_assert (ret);
/* check we can serialize this object to a blob */
blob = dfu_patch_export (patch, &error);
g_assert_no_error (error);
g_assert (ret);
data = g_bytes_get_data (blob, &sz);
g_assert_cmpint (data[0x00], ==, 'D');
g_assert_cmpint (data[0x01], ==, 'f');
g_assert_cmpint (data[0x02], ==, 'u');
g_assert_cmpint (data[0x03], ==, 'P');
g_assert_cmpint (data[0x04], ==, 0x00); /* reserved */
g_assert_cmpint (data[0x05], ==, 0x00);
g_assert_cmpint (data[0x06], ==, 0x00);
g_assert_cmpint (data[0x07], ==, 0x00);
g_assert_cmpint (data[0x08 + 0x28], ==, 0x01); /* chunk1, offset */
g_assert_cmpint (data[0x09 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0a + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0b + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0c + 0x28], ==, 0x02); /* chunk1, size */
g_assert_cmpint (data[0x0d + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0e + 0x28], ==, 0x00);
g_assert_cmpint (data[0x0f + 0x28], ==, 0x00);
g_assert_cmpint (data[0x10 + 0x28], ==, 0x00); /* reserved */
g_assert_cmpint (data[0x11 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x12 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x13 + 0x28], ==, 0x00);
g_assert_cmpint (data[0x14 + 0x28], ==, 'Y');
g_assert_cmpint (data[0x15 + 0x28], ==, 'Y');
g_assert_cmpint (sz, ==, 48 /* hdr */ + 12 /* chunk */ + 2 /* data */);
/* try to load it from the serialized blob */
ret = dfu_patch_import (patch2, blob, &error);
g_assert_no_error (error);
g_assert (ret);
serialized_str = dfu_patch_to_string (patch2);
g_debug ("serialized blob %s", serialized_str);
}
int
main (int argc, char **argv)
{
g_test_init (&argc, &argv, NULL);
/* only critical and error are fatal */
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
/* log everything */
g_setenv ("G_MESSAGES_DEBUG", "all", FALSE);
/* tests go here */
g_test_add_func ("/libdfu/patch", dfu_patch_func);
g_test_add_func ("/libdfu/patch{merges}", dfu_patch_merges_func);
g_test_add_func ("/libdfu/patch{apply}", dfu_patch_apply_func);
g_test_add_func ("/libdfu/enums", dfu_enums_func);
g_test_add_func ("/libdfu/target(DfuSe}", dfu_target_dfuse_func);
g_test_add_func ("/libdfu/firmware{raw}", dfu_firmware_raw_func);
g_test_add_func ("/libdfu/firmware{dfu}", dfu_firmware_dfu_func);
g_test_add_func ("/libdfu/firmware{dfuse}", dfu_firmware_dfuse_func);
g_test_add_func ("/libdfu/firmware{xdfu}", dfu_firmware_xdfu_func);
g_test_add_func ("/libdfu/firmware{metadata}", dfu_firmware_metadata_func);
g_test_add_func ("/libdfu/firmware{intel-hex}", dfu_firmware_intel_hex_func);
g_test_add_func ("/libdfu/firmware{intel-hex-signed}", dfu_firmware_intel_hex_signed_func);
g_test_add_func ("/libdfu/firmware{elf}", dfu_firmware_elf_func);
g_test_add_func ("/libdfu/device", dfu_device_func);
g_test_add_func ("/libdfu/colorhug+", dfu_colorhug_plus_func);
return g_test_run ();
}
Reference in New Issue View Git Blame Copy Permalink