/src/fwupd/plugins/wacom-usb/fu-wacom-usb-firmware.c

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

#include "config.h"

#include <string.h>

#include "fu-wacom-usb-firmware.h"
#include "fu-wacom-usb-struct.h"

struct _FuWacomUsbFirmware {
  FuFirmware parent_instance;
};

G_DEFINE_TYPE(FuWacomUsbFirmware, fu_wacom_usb_firmware, FU_TYPE_FIRMWARE)

#define FU_WACOM_USB_FIRMWARE_TOKENS_MAX   100000 /* lines */
#define FU_WACOM_USB_FIRMWARE_SECTIONS_MAX 10

typedef struct {
  guint32 addr;
  guint32 sz;
  guint32 prog_start_addr;
} FuFirmwareWacHeaderRecord;

typedef struct {
  FuFirmware *firmware;
  FuFirmwareParseFlags flags;
  GPtrArray *header_infos;
  GString *image_buffer;
  guint8 images_cnt;
} FuWacomUsbFirmwareTokenHelper;

static gboolean
fu_wacom_usb_firmware_tokenize_cb(GString *token,
          guint token_idx,
          gpointer user_data,
          GError **error)
{
  FuWacomUsbFirmwareTokenHelper *helper = (FuWacomUsbFirmwareTokenHelper *)user_data;
  g_autofree gchar *cmd = NULL;

  /* sanity check */
  if (token_idx > FU_WACOM_USB_FIRMWARE_TOKENS_MAX) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INVALID_DATA,
            "file has too many lines");
    return FALSE;
  }

  /* remove WIN32 line endings */
  g_strdelimit(token->str, "\r\x1a", '\0');
  token->len = strlen(token->str);

  /* ignore blank lines */
  cmd = g_strndup(token->str, 2);
  if (g_strcmp0(cmd, "") == 0)
    return TRUE;

  /* custom metadata */
  if (g_strcmp0(cmd, "WA") == 0) {
    /* header info record */
    if (token->len > 3 && memcmp(token->str + 2, "COM", 3) == 0) {
      guint8 header_image_cnt = 0;
      if (token->len != 40) {
        g_set_error(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INTERNAL,
              "invalid header, got %" G_GSIZE_FORMAT " bytes",
              token->len);
        return FALSE;
      }

      /* sanity check */
      if (helper->header_infos->len > FU_WACOM_USB_FIRMWARE_SECTIONS_MAX) {
        g_set_error(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INTERNAL,
              "too many metadata sections: %u",
              helper->header_infos->len);
        return FALSE;
      }
      if (!fu_firmware_strparse_uint4_safe(token->str,
                   token->len,
                   5,
                   &header_image_cnt,
                   error))
        return FALSE;
      for (guint j = 0; j < header_image_cnt; j++) {
        g_autofree FuFirmwareWacHeaderRecord *hdr = NULL;
        hdr = g_new0(FuFirmwareWacHeaderRecord, 1);
        if (!fu_firmware_strparse_uint32_safe(token->str,
                      token->len,
                      (j * 16) + 6,
                      &hdr->addr,
                      error))
          return FALSE;
        if (!fu_firmware_strparse_uint32_safe(token->str,
                      token->len,
                      (j * 16) + 14,
                      &hdr->sz,
                      error))
          return FALSE;
        g_debug("header_fw%u_addr: 0x%x", j, hdr->addr);
        g_debug("header_fw%u_sz:   0x%x", j, hdr->sz);
        g_ptr_array_add(helper->header_infos, g_steal_pointer(&hdr));
      }
      return TRUE;
    }

    /* firmware headline record */
    if (token->len == 13) {
      FuFirmwareWacHeaderRecord *hdr;
      guint8 idx = 0;
      if (!fu_firmware_strparse_uint4_safe(token->str,
                   token->len,
                   2,
                   &idx,
                   error))
        return FALSE;
      if (idx == 0) {
        g_set_error(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INTERNAL,
              "headline %u invalid",
              idx);
        return FALSE;
      }
      if (idx > helper->header_infos->len) {
        g_set_error(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INTERNAL,
              "headline %u exceeds header count %u",
              idx,
              helper->header_infos->len);
        return FALSE;
      }
      if (idx - 1 != helper->images_cnt) {
        g_set_error(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INTERNAL,
              "headline %u is not in sorted order",
              idx);
        return FALSE;
      }
      hdr = g_ptr_array_index(helper->header_infos, idx - 1);
      if (!fu_firmware_strparse_uint32_safe(token->str,
                    token->len,
                    3,
                    &hdr->prog_start_addr,
                    error))
        return FALSE;
      if (hdr->prog_start_addr != hdr->addr) {
        g_set_error(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INTERNAL,
              "programming address 0x%x != "
              "base address 0x%0x for idx %u",
              hdr->prog_start_addr,
              hdr->addr,
              idx);
        return FALSE;
      }
      g_debug("programing-start-address: 0x%x", hdr->prog_start_addr);
      return TRUE;
    }

    g_debug("unknown Wacom-specific metadata");
    return TRUE;
  }

  /* start */
  if (g_strcmp0(cmd, "S0") == 0) {
    if (helper->image_buffer->len > 0) {
      g_set_error_literal(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INTERNAL,
              "duplicate S0 without S7");
      return FALSE;
    }
    g_string_append_printf(helper->image_buffer, "%s\n", token->str);
    return TRUE;
  }

  /* these are things we want to include in the image */
  if (g_strcmp0(cmd, "S1") == 0 || g_strcmp0(cmd, "S2") == 0 || g_strcmp0(cmd, "S3") == 0 ||
      g_strcmp0(cmd, "S5") == 0 || g_strcmp0(cmd, "S7") == 0 || g_strcmp0(cmd, "S8") == 0 ||
      g_strcmp0(cmd, "S9") == 0) {
    if (helper->image_buffer->len == 0) {
      g_set_error(error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "%s without S0", cmd);
      return FALSE;
    }
    g_string_append_printf(helper->image_buffer, "%s\n", token->str);
  } else {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INTERNAL,
          "invalid SREC command on line %u: %s",
          token_idx + 1,
          cmd);
    return FALSE;
  }

  /* end */
  if (g_strcmp0(cmd, "S7") == 0) {
    g_autoptr(GBytes) blob = NULL;
    g_autoptr(GBytes) fw_srec = NULL;
    g_autoptr(FuFirmware) firmware_srec = fu_srec_firmware_new();
    g_autoptr(FuFirmware) img = fu_firmware_new();
    FuFirmwareWacHeaderRecord *hdr;

    /* get the correct relocated start address */
    if (helper->images_cnt >= helper->header_infos->len) {
      g_set_error(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INTERNAL,
            "%s without header",
            cmd);
      return FALSE;
    }
    hdr = g_ptr_array_index(helper->header_infos, helper->images_cnt);

    if (helper->image_buffer->len == 0) {
      g_set_error(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INTERNAL,
            "%s with missing image buffer",
            cmd);
      return FALSE;
    }

    /* parse SREC file and add as image */
    blob = g_bytes_new(helper->image_buffer->str, helper->image_buffer->len);
    fu_srec_firmware_set_addr_min(FU_SREC_FIRMWARE(firmware_srec), hdr->addr);
    if (!fu_firmware_parse_bytes(firmware_srec,
               blob,
               0x0,
               helper->flags | FU_FIRMWARE_PARSE_FLAG_NO_SEARCH,
               error))
      return FALSE;
    fw_srec = fu_firmware_get_bytes(firmware_srec, error);
    if (fw_srec == NULL)
      return FALSE;
    fu_firmware_set_bytes(img, fw_srec);
    fu_firmware_set_addr(img, fu_firmware_get_addr(firmware_srec));
    fu_firmware_set_idx(img, helper->images_cnt);
    if (!fu_firmware_add_image(helper->firmware, img, error))
      return FALSE;
    helper->images_cnt++;

    /* clear the image buffer */
    g_string_set_size(helper->image_buffer, 0);
  }

  /* success */
  return TRUE;
}

static gboolean
fu_wacom_usb_firmware_validate(FuFirmware *firmware,
             GInputStream *stream,
             gsize offset,
             GError **error)
{
  return fu_struct_wacom_usb_firmware_hdr_validate_stream(stream, offset, error);
}

static gboolean
fu_wacom_usb_firmware_parse(FuFirmware *firmware,
          GInputStream *stream,
          FuFirmwareParseFlags flags,
          GError **error)
{
  g_autoptr(GPtrArray) header_infos = g_ptr_array_new_with_free_func(g_free);
  g_autoptr(GString) image_buffer = g_string_new(NULL);
  FuWacomUsbFirmwareTokenHelper helper = {.firmware = firmware,
            .flags = flags,
            .header_infos = header_infos,
            .image_buffer = image_buffer,
            .images_cnt = 0};

  /* tokenize */
  if (!fu_strsplit_stream(stream,
        0x0,
        "\n",
        fu_wacom_usb_firmware_tokenize_cb,
        &helper,
        error))
    return FALSE;

  /* verify data is complete */
  if (helper.image_buffer->len > 0) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INTERNAL,
            "truncated data: no S7");
    return FALSE;
  }

  /* ensure this matched the header */
  if (helper.header_infos->len != helper.images_cnt) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INTERNAL,
          "not enough images %u for header count %u",
          helper.images_cnt,
          header_infos->len);
    return FALSE;
  }

  /* success */
  return TRUE;
}

static guint8
fu_wacom_usb_firmware_calc_checksum(GByteArray *buf)
{
  return fu_sum8(buf->data, buf->len) ^ 0xFF;
}

static GByteArray *
fu_wacom_usb_firmware_write(FuFirmware *firmware, GError **error)
{
  g_autoptr(GPtrArray) images = fu_firmware_get_images(firmware);
  g_autoptr(GString) str = g_string_new(NULL);
  g_autoptr(GByteArray) buf = g_byte_array_new();
  g_autoptr(GByteArray) buf_hdr = g_byte_array_new();

  /* fw header */
  if (images->len == 0) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_NOT_SUPPORTED,
            "no firmware images found");
    return NULL;
  }
  for (guint i = 0; i < images->len; i++) {
    FuFirmware *img = g_ptr_array_index(images, i);
    fu_byte_array_append_uint32(buf_hdr, fu_firmware_get_addr(img), G_BIG_ENDIAN);
    fu_byte_array_append_uint32(buf_hdr, fu_firmware_get_size(img), G_BIG_ENDIAN);
  }
  g_string_append_printf(str, "WACOM%u", images->len);
  for (guint i = 0; i < buf_hdr->len; i++)
    g_string_append_printf(str, "%02X", buf_hdr->data[i]);
  g_string_append_printf(str, "%02X\n", fu_wacom_usb_firmware_calc_checksum(buf_hdr));

  /* payload */
  for (guint i = 0; i < images->len; i++) {
    FuFirmware *img = g_ptr_array_index(images, i);
    g_autoptr(GBytes) img_blob = NULL;
    g_autoptr(GByteArray) buf_img = g_byte_array_new();

    /* img header */
    g_string_append_printf(str, "WA%u", (guint)fu_firmware_get_idx(img) + 1);
    fu_byte_array_append_uint32(buf_img, fu_firmware_get_addr(img), G_BIG_ENDIAN);
    for (guint j = 0; j < buf_img->len; j++)
      g_string_append_printf(str, "%02X", buf_img->data[j]);
    g_string_append_printf(str, "%02X\n", fu_wacom_usb_firmware_calc_checksum(buf_img));

    /* srec */
    img_blob = fu_firmware_write(img, error);
    if (img_blob == NULL)
      return NULL;
    g_string_append_len(str,
            (const gchar *)g_bytes_get_data(img_blob, NULL),
            g_bytes_get_size(img_blob));
  }

  /* success */
  g_byte_array_append(buf, (const guint8 *)str->str, str->len);
  return g_steal_pointer(&buf);
}

static void
fu_wacom_usb_firmware_init(FuWacomUsbFirmware *self)
{
  fu_firmware_set_images_max(FU_FIRMWARE(self), 1024);
  fu_firmware_add_image_gtype(FU_FIRMWARE(self), FU_TYPE_FIRMWARE);
  fu_firmware_add_image_gtype(FU_FIRMWARE(self), FU_TYPE_SREC_FIRMWARE);
}

static void
fu_wacom_usb_firmware_class_init(FuWacomUsbFirmwareClass *klass)
{
  FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
  firmware_class->validate = fu_wacom_usb_firmware_validate;
  firmware_class->parse = fu_wacom_usb_firmware_parse;
  firmware_class->write = fu_wacom_usb_firmware_write;
}

FuFirmware *
fu_wacom_usb_firmware_new(void)
{
  return FU_FIRMWARE(g_object_new(FU_TYPE_WACOM_USB_FIRMWARE, NULL));
}

Coverage Report

Created: 2026-01-25 06:22

Line	Count	Source
1		/*
2		* Copyright 2018 Richard Hughes <richard@hughsie.com>
3		*
4		* SPDX-License-Identifier: LGPL-2.1-or-later
5		*/
6
7		#include "config.h"
8
9		#include <string.h>
10
11		#include "fu-wacom-usb-firmware.h"
12		#include "fu-wacom-usb-struct.h"
13
14		struct _FuWacomUsbFirmware {
15		FuFirmware parent_instance;
16		};
17
18	1.88k	G_DEFINE_TYPE(FuWacomUsbFirmware, fu_wacom_usb_firmware, FU_TYPE_FIRMWARE)
19	1.88k
20	1.18M	#define FU_WACOM_USB_FIRMWARE_TOKENS_MAX 100000 /* lines */
21	1.70k	#define FU_WACOM_USB_FIRMWARE_SECTIONS_MAX 10
22
23		typedef struct {
24		guint32 addr;
25		guint32 sz;
26		guint32 prog_start_addr;
27		} FuFirmwareWacHeaderRecord;
28
29		typedef struct {
30		FuFirmware *firmware;
31		FuFirmwareParseFlags flags;
32		GPtrArray *header_infos;
33		GString *image_buffer;
34		guint8 images_cnt;
35		} FuWacomUsbFirmwareTokenHelper;
36
37		static gboolean
38		fu_wacom_usb_firmware_tokenize_cb(GString *token,
39		guint token_idx,
40		gpointer user_data,
41		GError **error)
42	1.18M	{
43	1.18M	FuWacomUsbFirmwareTokenHelper helper = (FuWacomUsbFirmwareTokenHelper )user_data;
44	1.18M	g_autofree gchar *cmd = NULL;
45
46		/* sanity check */
47	1.18M	if (token_idx > FU_WACOM_USB_FIRMWARE_TOKENS_MAX) {
48	1	g_set_error_literal(error,
49	1	FWUPD_ERROR,
50	1	FWUPD_ERROR_INVALID_DATA,
51	1	"file has too many lines");
52	1	return FALSE;
53	1	}
54
55		/* remove WIN32 line endings */
56	1.18M	g_strdelimit(token->str, "\r\x1a", '\0');
57	1.18M	token->len = strlen(token->str);
58
59		/* ignore blank lines */
60	1.18M	cmd = g_strndup(token->str, 2);
61	1.18M	if (g_strcmp0(cmd, "") == 0)
62	248k	return TRUE;
63
64		/* custom metadata */
65	935k	if (g_strcmp0(cmd, "WA") == 0) {
66		/* header info record */
67	5.04k	if (token->len > 3 && memcmp(token->str + 2, "COM", 3) == 0) {
68	1.77k	guint8 header_image_cnt = 0;
69	1.77k	if (token->len != 40) {
70	64	g_set_error(error,
71	64	FWUPD_ERROR,
72	64	FWUPD_ERROR_INTERNAL,
73	64	"invalid header, got %" G_GSIZE_FORMAT " bytes",
74	64	token->len);
75	64	return FALSE;
76	64	}
77
78		/* sanity check */
79	1.70k	if (helper->header_infos->len > FU_WACOM_USB_FIRMWARE_SECTIONS_MAX) {
80	2	g_set_error(error,
81	2	FWUPD_ERROR,
82	2	FWUPD_ERROR_INTERNAL,
83	2	"too many metadata sections: %u",
84	2	helper->header_infos->len);
85	2	return FALSE;
86	2	}
87	1.70k	if (!fu_firmware_strparse_uint4_safe(token->str,
88	1.70k	token->len,
89	1.70k	5,
90	1.70k	&header_image_cnt,
91	1.70k	error))
92	1	return FALSE;
93	4.08k	for (guint j = 0; j < header_image_cnt; j++) {
94	2.43k	g_autofree FuFirmwareWacHeaderRecord *hdr = NULL;
95	2.43k	hdr = g_new0(FuFirmwareWacHeaderRecord, 1);
96	2.43k	if (!fu_firmware_strparse_uint32_safe(token->str,
97	2.43k	token->len,
98	2.43k	(j * 16) + 6,
99	2.43k	&hdr->addr,
100	2.43k	error))
101	32	return FALSE;
102	2.40k	if (!fu_firmware_strparse_uint32_safe(token->str,
103	2.40k	token->len,
104	2.40k	(j * 16) + 14,
105	2.40k	&hdr->sz,
106	2.40k	error))
107	26	return FALSE;
108	2.37k	g_debug("header_fw%u_addr: 0x%x", j, hdr->addr);
109	2.37k	g_debug("header_fw%u_sz: 0x%x", j, hdr->sz);
110	2.37k	g_ptr_array_add(helper->header_infos, g_steal_pointer(&hdr));
111	2.37k	}
112	1.64k	return TRUE;
113	1.70k	}
114
115		/* firmware headline record */
116	3.27k	if (token->len == 13) {
117	570	FuFirmwareWacHeaderRecord *hdr;
118	570	guint8 idx = 0;
119	570	if (!fu_firmware_strparse_uint4_safe(token->str,
120	570	token->len,
121	570	2,
122	570	&idx,
123	570	error))
124	8	return FALSE;
125	562	if (idx == 0) {
126	1	g_set_error(error,
127	1	FWUPD_ERROR,
128	1	FWUPD_ERROR_INTERNAL,
129	1	"headline %u invalid",
130	1	idx);
131	1	return FALSE;
132	1	}
133	561	if (idx > helper->header_infos->len) {
134	4	g_set_error(error,
135	4	FWUPD_ERROR,
136	4	FWUPD_ERROR_INTERNAL,
137	4	"headline %u exceeds header count %u",
138	4	idx,
139	4	helper->header_infos->len);
140	4	return FALSE;
141	4	}
142	557	if (idx - 1 != helper->images_cnt) {
143	6	g_set_error(error,
144	6	FWUPD_ERROR,
145	6	FWUPD_ERROR_INTERNAL,
146	6	"headline %u is not in sorted order",
147	6	idx);
148	6	return FALSE;
149	6	}
150	551	hdr = g_ptr_array_index(helper->header_infos, idx - 1);
151	551	if (!fu_firmware_strparse_uint32_safe(token->str,
152	551	token->len,
153	551	3,
154	551	&hdr->prog_start_addr,
155	551	error))
156	1	return FALSE;
157	550	if (hdr->prog_start_addr != hdr->addr) {
158	47	g_set_error(error,
159	47	FWUPD_ERROR,
160	47	FWUPD_ERROR_INTERNAL,
161	47	"programming address 0x%x != "
162	47	"base address 0x%0x for idx %u",
163	47	hdr->prog_start_addr,
164	47	hdr->addr,
165	47	idx);
166	47	return FALSE;
167	47	}
168	503	g_debug("programing-start-address: 0x%x", hdr->prog_start_addr);
169	503	return TRUE;
170	550	}
171
172	2.70k	g_debug("unknown Wacom-specific metadata");
173	2.70k	return TRUE;
174	3.27k	}
175
176		/* start */
177	929k	if (g_strcmp0(cmd, "S0") == 0) {
178	2.16k	if (helper->image_buffer->len > 0) {
179	21	g_set_error_literal(error,
180	21	FWUPD_ERROR,
181	21	FWUPD_ERROR_INTERNAL,
182	21	"duplicate S0 without S7");
183	21	return FALSE;
184	21	}
185	2.14k	g_string_append_printf(helper->image_buffer, "%s\n", token->str);
186	2.14k	return TRUE;
187	2.16k	}
188
189		/* these are things we want to include in the image */
190	927k	if (g_strcmp0(cmd, "S1") == 0 \|\| g_strcmp0(cmd, "S2") == 0 \|\| g_strcmp0(cmd, "S3") == 0 \|\|
191	9.46k	g_strcmp0(cmd, "S5") == 0 \|\| g_strcmp0(cmd, "S7") == 0 \|\| g_strcmp0(cmd, "S8") == 0 \|\|
192	927k	g_strcmp0(cmd, "S9") == 0) {
193	927k	if (helper->image_buffer->len == 0) {
194	31	g_set_error(error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "%s without S0", cmd);
195	31	return FALSE;
196	31	}
197	927k	g_string_append_printf(helper->image_buffer, "%s\n", token->str);
198	927k	} else {
199	143	g_set_error(error,
200	143	FWUPD_ERROR,
201	143	FWUPD_ERROR_INTERNAL,
202	143	"invalid SREC command on line %u: %s",
203	143	token_idx + 1,
204	143	cmd);
205	143	return FALSE;
206	143	}
207
208		/* end */
209	927k	if (g_strcmp0(cmd, "S7") == 0) {
210	1.89k	g_autoptr(GBytes) blob = NULL;
211	1.89k	g_autoptr(GBytes) fw_srec = NULL;
212	1.89k	g_autoptr(FuFirmware) firmware_srec = fu_srec_firmware_new();
213	1.89k	g_autoptr(FuFirmware) img = fu_firmware_new();
214	1.89k	FuFirmwareWacHeaderRecord *hdr;
215
216		/* get the correct relocated start address */
217	1.89k	if (helper->images_cnt >= helper->header_infos->len) {
218	20	g_set_error(error,
219	20	FWUPD_ERROR,
220	20	FWUPD_ERROR_INTERNAL,
221	20	"%s without header",
222	20	cmd);
223	20	return FALSE;
224	20	}
225	1.87k	hdr = g_ptr_array_index(helper->header_infos, helper->images_cnt);
226
227	1.87k	if (helper->image_buffer->len == 0) {
228	0	g_set_error(error,
229	0	FWUPD_ERROR,
230	0	FWUPD_ERROR_INTERNAL,
231	0	"%s with missing image buffer",
232	0	cmd);
233	0	return FALSE;
234	0	}
235
236		/* parse SREC file and add as image */
237	1.87k	blob = g_bytes_new(helper->image_buffer->str, helper->image_buffer->len);
238	1.87k	fu_srec_firmware_set_addr_min(FU_SREC_FIRMWARE(firmware_srec), hdr->addr);
239	1.87k	if (!fu_firmware_parse_bytes(firmware_srec,
240	1.87k	blob,
241	1.87k	0x0,
242	1.87k	helper->flags \| FU_FIRMWARE_PARSE_FLAG_NO_SEARCH,
243	1.87k	error))
244	354	return FALSE;
245	1.51k	fw_srec = fu_firmware_get_bytes(firmware_srec, error);
246	1.51k	if (fw_srec == NULL)
247	0	return FALSE;
248	1.51k	fu_firmware_set_bytes(img, fw_srec);
249	1.51k	fu_firmware_set_addr(img, fu_firmware_get_addr(firmware_srec));
250	1.51k	fu_firmware_set_idx(img, helper->images_cnt);
251	1.51k	if (!fu_firmware_add_image(helper->firmware, img, error))
252	0	return FALSE;
253	1.51k	helper->images_cnt++;
254
255		/* clear the image buffer */
256	1.51k	g_string_set_size(helper->image_buffer, 0);
257	1.51k	}
258
259		/* success */
260	927k	return TRUE;
261	927k	}
262
263		static gboolean
264		fu_wacom_usb_firmware_validate(FuFirmware *firmware,
265		GInputStream *stream,
266		gsize offset,
267		GError **error)
268	1.88k	{
269	1.88k	return fu_struct_wacom_usb_firmware_hdr_validate_stream(stream, offset, error);
270	1.88k	}
271
272		static gboolean
273		fu_wacom_usb_firmware_parse(FuFirmware *firmware,
274		GInputStream *stream,
275		FuFirmwareParseFlags flags,
276		GError **error)
277	1.81k	{
278	1.81k	g_autoptr(GPtrArray) header_infos = g_ptr_array_new_with_free_func(g_free);
279	1.81k	g_autoptr(GString) image_buffer = g_string_new(NULL);
280	1.81k	FuWacomUsbFirmwareTokenHelper helper = {.firmware = firmware,
281	1.81k	.flags = flags,
282	1.81k	.header_infos = header_infos,
283	1.81k	.image_buffer = image_buffer,
284	1.81k	.images_cnt = 0};
285
286		/* tokenize */
287	1.81k	if (!fu_strsplit_stream(stream,
288	1.81k	0x0,
289	1.81k	"\n",
290	1.81k	fu_wacom_usb_firmware_tokenize_cb,
291	1.81k	&helper,
292	1.81k	error))
293	762	return FALSE;
294
295		/* verify data is complete */
296	1.04k	if (helper.image_buffer->len > 0) {
297	206	g_set_error_literal(error,
298	206	FWUPD_ERROR,
299	206	FWUPD_ERROR_INTERNAL,
300	206	"truncated data: no S7");
301	206	return FALSE;
302	206	}
303
304		/* ensure this matched the header */
305	842	if (helper.header_infos->len != helper.images_cnt) {
306	65	g_set_error(error,
307	65	FWUPD_ERROR,
308	65	FWUPD_ERROR_INTERNAL,
309	65	"not enough images %u for header count %u",
310	65	helper.images_cnt,
311	65	header_infos->len);
312	65	return FALSE;
313	65	}
314
315		/* success */
316	777	return TRUE;
317	842	}
318
319		static guint8
320		fu_wacom_usb_firmware_calc_checksum(GByteArray *buf)
321	878	{
322	878	return fu_sum8(buf->data, buf->len) ^ 0xFF;
323	878	}
324
325		static GByteArray *
326		fu_wacom_usb_firmware_write(FuFirmware firmware, GError *error)
327	777	{
328	777	g_autoptr(GPtrArray) images = fu_firmware_get_images(firmware);
329	777	g_autoptr(GString) str = g_string_new(NULL);
330	777	g_autoptr(GByteArray) buf = g_byte_array_new();
331	777	g_autoptr(GByteArray) buf_hdr = g_byte_array_new();
332
333		/* fw header */
334	777	if (images->len == 0) {
335	504	g_set_error_literal(error,
336	504	FWUPD_ERROR,
337	504	FWUPD_ERROR_NOT_SUPPORTED,
338	504	"no firmware images found");
339	504	return NULL;
340	504	}
341	878	for (guint i = 0; i < images->len; i++) {
342	605	FuFirmware *img = g_ptr_array_index(images, i);
343	605	fu_byte_array_append_uint32(buf_hdr, fu_firmware_get_addr(img), G_BIG_ENDIAN);
344	605	fu_byte_array_append_uint32(buf_hdr, fu_firmware_get_size(img), G_BIG_ENDIAN);
345	605	}
346	273	g_string_append_printf(str, "WACOM%u", images->len);
347	5.11k	for (guint i = 0; i < buf_hdr->len; i++)
348	4.84k	g_string_append_printf(str, "%02X", buf_hdr->data[i]);
349	273	g_string_append_printf(str, "%02X\n", fu_wacom_usb_firmware_calc_checksum(buf_hdr));
350
351		/* payload */
352	878	for (guint i = 0; i < images->len; i++) {
353	605	FuFirmware *img = g_ptr_array_index(images, i);
354	605	g_autoptr(GBytes) img_blob = NULL;
355	605	g_autoptr(GByteArray) buf_img = g_byte_array_new();
356
357		/* img header */
358	605	g_string_append_printf(str, "WA%u", (guint)fu_firmware_get_idx(img) + 1);
359	605	fu_byte_array_append_uint32(buf_img, fu_firmware_get_addr(img), G_BIG_ENDIAN);
360	3.02k	for (guint j = 0; j < buf_img->len; j++)
361	2.42k	g_string_append_printf(str, "%02X", buf_img->data[j]);
362	605	g_string_append_printf(str, "%02X\n", fu_wacom_usb_firmware_calc_checksum(buf_img));
363
364		/* srec */
365	605	img_blob = fu_firmware_write(img, error);
366	605	if (img_blob == NULL)
367	0	return NULL;
368	605	g_string_append_len(str,
369	605	(const gchar *)g_bytes_get_data(img_blob, NULL),
370	605	g_bytes_get_size(img_blob));
371	605	}
372
373		/* success */
374	273	g_byte_array_append(buf, (const guint8 *)str->str, str->len);
375	273	return g_steal_pointer(&buf);
376	273	}
377
378		static void
379		fu_wacom_usb_firmware_init(FuWacomUsbFirmware *self)
380	1.88k	{
381	1.88k	fu_firmware_set_images_max(FU_FIRMWARE(self), 1024);
382	1.88k	fu_firmware_add_image_gtype(FU_FIRMWARE(self), FU_TYPE_FIRMWARE);
383	1.88k	fu_firmware_add_image_gtype(FU_FIRMWARE(self), FU_TYPE_SREC_FIRMWARE);
384	1.88k	}
385
386		static void
387		fu_wacom_usb_firmware_class_init(FuWacomUsbFirmwareClass *klass)
388	1	{
389	1	FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
390	1	firmware_class->validate = fu_wacom_usb_firmware_validate;
391	1	firmware_class->parse = fu_wacom_usb_firmware_parse;
392	1	firmware_class->write = fu_wacom_usb_firmware_write;
393	1	}
394
395		FuFirmware *
396		fu_wacom_usb_firmware_new(void)
397	0	{
398	0	return FU_FIRMWARE(g_object_new(FU_TYPE_WACOM_USB_FIRMWARE, NULL));
399	0	}