blob: 841a4f2386b85fb97f818b119bdfff52f3f73eb2 [file] [log] [blame]
Christopher Collins92ea77f2016-12-12 15:59:26 -08001/*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19#include <assert.h>
20#include <stddef.h>
21#include <inttypes.h>
22#include <ctype.h>
23#include <stdio.h>
24
25#include "sysflash/sysflash.h"
26
Fabio Utzig1a2e41a2017-11-17 12:13:09 -020027#include "bootutil/bootutil_log.h"
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +010028#include "cbor_encode.h"
Fabio Utzig1a2e41a2017-11-17 12:13:09 -020029
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020030#ifdef __ZEPHYR__
Øyvind Rønningstad212a35b2021-05-07 21:06:48 +020031#include <power/reboot.h>
Andrzej Puzdrowskif1d189c2019-12-12 09:34:11 +010032#include <sys/byteorder.h>
33#include <sys/__assert.h>
Peter Bigot54c1e3f2020-01-25 05:50:12 -060034#include <drivers/flash.h>
Andrzej Puzdrowskif1d189c2019-12-12 09:34:11 +010035#include <sys/crc.h>
36#include <sys/base64.h>
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020037#else
Christopher Collins92ea77f2016-12-12 15:59:26 -080038#include <bsp/bsp.h>
Christopher Collins92ea77f2016-12-12 15:59:26 -080039#include <hal/hal_system.h>
Christopher Collins92ea77f2016-12-12 15:59:26 -080040#include <os/endian.h>
Christopher Collins92ea77f2016-12-12 15:59:26 -080041#include <os/os_cputime.h>
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020042#include <crc/crc16.h>
43#include <base64/base64.h>
Andrzej Puzdrowski386b5922018-04-06 19:26:24 +020044#endif /* __ZEPHYR__ */
45
Andrzej Puzdrowskib788c712018-04-12 12:42:49 +020046#include <flash_map_backend/flash_map_backend.h>
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020047#include <hal/hal_flash.h>
48#include <os/os.h>
49#include <os/os_malloc.h>
Christopher Collins92ea77f2016-12-12 15:59:26 -080050
51#include <bootutil/image.h>
Andrzej Puzdrowskif48de7a2020-10-19 09:42:02 +020052#include <bootutil/bootutil.h>
Christopher Collins92ea77f2016-12-12 15:59:26 -080053
54#include "boot_serial/boot_serial.h"
55#include "boot_serial_priv.h"
56
Dominik Ermel3d4e55d2021-07-09 11:14:10 +000057#ifdef MCUBOOT_ERASE_PROGRESSIVELY
Andrzej Puzdrowskic2e30cf2018-07-20 16:19:09 +020058#include "bootutil_priv.h"
59#endif
60
Øyvind Rønningstadf42a8202019-12-13 03:27:54 +010061#include "serial_recovery_cbor.h"
Andrzej Puzdrowski4f9c7302021-07-16 17:34:43 +020062#include "bootutil/boot_hooks.h"
Øyvind Rønningstadf42a8202019-12-13 03:27:54 +010063
Carlos Falgueras Garcíaa4b4b0f2021-06-22 10:00:22 +020064BOOT_LOG_MODULE_DECLARE(mcuboot);
Emanuele Di Santo9f1933d2018-11-20 10:59:59 +010065
Dominik Ermele5ecbce2021-09-30 15:01:26 +000066#ifndef BOOT_IMAGE_NUMBER
67#define BOOT_IMAGE_NUMBER MCUBOOT_IMAGE_NUMBER
68#endif
69
Marko Kiiskila149b4572018-06-06 14:18:54 +030070#define BOOT_SERIAL_INPUT_MAX 512
Marek Pieta9183ffc2021-09-15 16:18:16 +020071#define BOOT_SERIAL_OUT_MAX (128 * MCUBOOT_IMAGE_NUMBER)
Christopher Collins92ea77f2016-12-12 15:59:26 -080072
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020073#ifdef __ZEPHYR__
Carles Cufi0165be82018-03-26 17:43:51 +020074/* base64 lib encodes data to null-terminated string */
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020075#define BASE64_ENCODE_SIZE(in_size) ((((((in_size) - 1) / 3) * 4) + 4) + 1)
76
77#define CRC16_INITIAL_CRC 0 /* what to seed crc16 with */
78#define CRC_CITT_POLYMINAL 0x1021
79
80#define ntohs(x) sys_be16_to_cpu(x)
81#define htons(x) sys_cpu_to_be16(x)
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020082#endif
Emanuele Di Santo9f1933d2018-11-20 10:59:59 +010083
Fabio Utzig6f49c272019-08-23 11:42:58 -030084#if (BOOT_IMAGE_NUMBER > 1)
85#define IMAGES_ITER(x) for ((x) = 0; (x) < BOOT_IMAGE_NUMBER; ++(x))
86#else
87#define IMAGES_ITER(x)
88#endif
89
Marko Kiiskila149b4572018-06-06 14:18:54 +030090static char in_buf[BOOT_SERIAL_INPUT_MAX + 1];
91static char dec_buf[BOOT_SERIAL_INPUT_MAX + 1];
Marko Kiiskila8b1ce3a2018-06-14 13:20:46 -070092const struct boot_uart_funcs *boot_uf;
Christopher Collins92ea77f2016-12-12 15:59:26 -080093static uint32_t curr_off;
94static uint32_t img_size;
95static struct nmgr_hdr *bs_hdr;
96
97static char bs_obuf[BOOT_SERIAL_OUT_MAX];
98
Christopher Collins92ea77f2016-12-12 15:59:26 -080099static void boot_serial_output(void);
100
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100101static cbor_state_backups_t dummy_backups;
102static cbor_state_t cbor_state = {
103 .backups = &dummy_backups
Christopher Collins92ea77f2016-12-12 15:59:26 -0800104};
Christopher Collins92ea77f2016-12-12 15:59:26 -0800105
Dominik Ermel3d51e432021-06-25 17:29:50 +0000106/**
Dominik Ermelbd69c3d2021-07-28 11:27:31 +0000107 * Function that processes MGMT_GROUP_ID_PERUSER mcumgr group and may be
108 * used to process any groups that have not been processed by generic boot
109 * serial implementation.
Dominik Ermel3d51e432021-06-25 17:29:50 +0000110 *
111 * @param[in] hdr -- the decoded header of mcumgr message;
112 * @param[in] buffer -- buffer with first mcumgr message;
113 * @param[in] len -- length of of data in buffer;
114 * @param[out] *cs -- object with encoded response.
115 *
116 * @return 0 on success; non-0 error code otherwise.
117 */
118extern int bs_peruser_system_specific(const struct nmgr_hdr *hdr,
119 const char *buffer,
120 int len, cbor_state_t *cs);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800121
122/*
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300123 * Convert version into string without use of snprintf().
Christopher Collins92ea77f2016-12-12 15:59:26 -0800124 */
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300125static int
126u32toa(char *tgt, uint32_t val)
Christopher Collins92ea77f2016-12-12 15:59:26 -0800127{
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300128 char *dst;
129 uint32_t d = 1;
130 uint32_t dgt;
131 int n = 0;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800132
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300133 dst = tgt;
134 while (val / d >= 10) {
135 d *= 10;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800136 }
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300137 while (d) {
138 dgt = val / d;
139 val %= d;
140 d /= 10;
141 if (n || dgt > 0 || d == 0) {
142 *dst++ = dgt + '0';
143 ++n;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800144 }
Christopher Collins92ea77f2016-12-12 15:59:26 -0800145 }
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300146 *dst = '\0';
147
148 return dst - tgt;
149}
150
151/*
152 * dst has to be able to fit "255.255.65535.4294967295" (25 characters).
153 */
154static void
155bs_list_img_ver(char *dst, int maxlen, struct image_version *ver)
156{
157 int off;
158
159 off = u32toa(dst, ver->iv_major);
160 dst[off++] = '.';
161 off += u32toa(dst + off, ver->iv_minor);
162 dst[off++] = '.';
163 off += u32toa(dst + off, ver->iv_revision);
164 dst[off++] = '.';
165 off += u32toa(dst + off, ver->iv_build_num);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800166}
167
168/*
169 * List images.
170 */
171static void
172bs_list(char *buf, int len)
173{
Christopher Collins92ea77f2016-12-12 15:59:26 -0800174 struct image_header hdr;
175 uint8_t tmpbuf[64];
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100176 uint32_t slot, area_id;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800177 const struct flash_area *fap;
Fabio Utzig6f49c272019-08-23 11:42:58 -0300178 uint8_t image_index;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800179
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100180 map_start_encode(&cbor_state, 1);
181 tstrx_put(&cbor_state, "images");
182 list_start_encode(&cbor_state, 5);
Fabio Utzig6f49c272019-08-23 11:42:58 -0300183 image_index = 0;
184 IMAGES_ITER(image_index) {
185 for (slot = 0; slot < 2; slot++) {
186 area_id = flash_area_id_from_multi_image_slot(image_index, slot);
187 if (flash_area_open(area_id, &fap)) {
188 continue;
189 }
Christopher Collins92ea77f2016-12-12 15:59:26 -0800190
Andrzej Puzdrowski4f9c7302021-07-16 17:34:43 +0200191 int rc = BOOT_HOOK_CALL(boot_read_image_header_hook,
192 BOOT_HOOK_REGULAR, image_index, slot, &hdr);
193 if (rc == BOOT_HOOK_REGULAR)
194 {
195 flash_area_read(fap, 0, &hdr, sizeof(hdr));
196 }
Christopher Collins92ea77f2016-12-12 15:59:26 -0800197
Andrzej Puzdrowski4f9c7302021-07-16 17:34:43 +0200198 fih_int fih_rc = FIH_FAILURE;
199
200 if (hdr.ih_magic == IMAGE_MAGIC)
201 {
202 BOOT_HOOK_CALL_FIH(boot_image_check_hook,
203 fih_int_encode(BOOT_HOOK_REGULAR),
204 fih_rc, image_index, slot);
205 if (fih_eq(fih_rc, BOOT_HOOK_REGULAR))
206 {
207 FIH_CALL(bootutil_img_validate, fih_rc, NULL, 0, &hdr, fap, tmpbuf, sizeof(tmpbuf),
208 NULL, 0, NULL);
209 }
210 }
211
212 flash_area_close(fap);
213
214 if (fih_not_eq(fih_rc, FIH_SUCCESS)) {
Fabio Utzig6f49c272019-08-23 11:42:58 -0300215 continue;
216 }
Fabio Utzig6f49c272019-08-23 11:42:58 -0300217
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100218 map_start_encode(&cbor_state, 20);
Fabio Utzig6f49c272019-08-23 11:42:58 -0300219
220#if (BOOT_IMAGE_NUMBER > 1)
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100221 tstrx_put(&cbor_state, "image");
222 uintx32_put(&cbor_state, image_index);
Fabio Utzig6f49c272019-08-23 11:42:58 -0300223#endif
224
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100225 tstrx_put(&cbor_state, "slot");
226 uintx32_put(&cbor_state, slot);
227 tstrx_put(&cbor_state, "version");
Fabio Utzig6f49c272019-08-23 11:42:58 -0300228
229 bs_list_img_ver((char *)tmpbuf, sizeof(tmpbuf), &hdr.ih_ver);
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100230 tstrx_put_term(&cbor_state, (char *)tmpbuf);
231 map_end_encode(&cbor_state, 20);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800232 }
Christopher Collins92ea77f2016-12-12 15:59:26 -0800233 }
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100234 list_end_encode(&cbor_state, 5);
235 map_end_encode(&cbor_state, 1);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800236 boot_serial_output();
237}
238
239/*
240 * Image upload request.
241 */
242static void
243bs_upload(char *buf, int len)
244{
Øyvind Rønningstadf42a8202019-12-13 03:27:54 +0100245 const uint8_t *img_data = NULL;
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100246 long long int off = UINT64_MAX;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800247 size_t img_blen = 0;
Fabio Utzig30f6b2a2018-03-29 16:18:53 -0300248 uint8_t rem_bytes;
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100249 long long int data_len = UINT64_MAX;
Fabio Utzig6f49c272019-08-23 11:42:58 -0300250 int img_num;
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300251 size_t slen;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800252 const struct flash_area *fap = NULL;
253 int rc;
Dominik Ermel3d4e55d2021-07-09 11:14:10 +0000254#ifdef MCUBOOT_ERASE_PROGRESSIVELY
Emanuele Di Santo205c8c62018-07-20 11:42:31 +0200255 static off_t off_last = -1;
256 struct flash_sector sector;
257#endif
Christopher Collins92ea77f2016-12-12 15:59:26 -0800258
Fabio Utzig6f49c272019-08-23 11:42:58 -0300259 img_num = 0;
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300260
261 /*
262 * Expected data format.
263 * {
Fabio Utzig6f49c272019-08-23 11:42:58 -0300264 * "image":<image number in a multi-image set (OPTIONAL)>
265 * "data":<image data>
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300266 * "len":<image len>
267 * "off":<current offset of image data>
268 * }
269 */
270
Øyvind Rønningstad212a35b2021-05-07 21:06:48 +0200271 struct Upload upload;
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100272 uint32_t decoded_len;
Øyvind Rønningstad212a35b2021-05-07 21:06:48 +0200273 bool result = cbor_decode_Upload((const uint8_t *)buf, len, &upload, &decoded_len);
274
275 if (!result || (len != decoded_len)) {
Øyvind Rønningstadf42a8202019-12-13 03:27:54 +0100276 goto out_invalid_data;
277 }
Dominik Ermel470e2f32020-01-10 13:28:48 +0000278
Øyvind Rønningstadf42a8202019-12-13 03:27:54 +0100279 for (int i = 0; i < upload._Upload_members_count; i++) {
Øyvind Rønningstad212a35b2021-05-07 21:06:48 +0200280 struct Member_ *member = &upload._Upload_members[i];
Øyvind Rønningstadf42a8202019-12-13 03:27:54 +0100281 switch(member->_Member_choice) {
282 case _Member_image:
283 img_num = member->_Member_image;
284 break;
285 case _Member_data:
286 img_data = member->_Member_data.value;
287 slen = member->_Member_data.len;
288 img_blen = slen;
289 break;
290 case _Member_len:
291 data_len = member->_Member_len;
292 break;
293 case _Member_off:
294 off = member->_Member_off;
295 break;
296 case _Member_sha:
297 default:
298 /* Nothing to do. */
299 break;
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300300 }
301 }
Øyvind Rønningstadf42a8202019-12-13 03:27:54 +0100302
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100303 if (off == UINT64_MAX || img_data == NULL) {
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300304 /*
305 * Offset must be set in every block.
306 */
307 goto out_invalid_data;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800308 }
309
Dominik Ermel48decca2021-07-09 10:23:58 +0000310#if !defined(MCUBOOT_SERIAL_DIRECT_IMAGE_UPLOAD)
Fabio Utzig6f49c272019-08-23 11:42:58 -0300311 rc = flash_area_open(flash_area_id_from_multi_image_slot(img_num, 0), &fap);
Dominik Ermel48decca2021-07-09 10:23:58 +0000312#else
313 rc = flash_area_open(flash_area_id_from_direct_image(img_num), &fap);
314#endif
Christopher Collins92ea77f2016-12-12 15:59:26 -0800315 if (rc) {
316 rc = MGMT_ERR_EINVAL;
317 goto out;
318 }
319
320 if (off == 0) {
321 curr_off = 0;
Dominik Ermel260ae092021-04-23 05:38:45 +0000322 if (data_len > flash_area_get_size(fap)) {
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300323 goto out_invalid_data;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800324 }
Dominik Ermel3d4e55d2021-07-09 11:14:10 +0000325#ifndef MCUBOOT_ERASE_PROGRESSIVELY
Dominik Ermel260ae092021-04-23 05:38:45 +0000326 rc = flash_area_erase(fap, 0, flash_area_get_size(fap));
Christopher Collins92ea77f2016-12-12 15:59:26 -0800327 if (rc) {
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300328 goto out_invalid_data;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800329 }
Emanuele Di Santo205c8c62018-07-20 11:42:31 +0200330#endif
Christopher Collins92ea77f2016-12-12 15:59:26 -0800331 img_size = data_len;
332 }
333 if (off != curr_off) {
334 rc = 0;
335 goto out;
336 }
Andrzej Puzdrowskif48de7a2020-10-19 09:42:02 +0200337
338 if (curr_off + img_blen > img_size) {
339 rc = MGMT_ERR_EINVAL;
340 goto out;
341 }
342
343 rem_bytes = img_blen % flash_area_align(fap);
344
345 if ((curr_off + img_blen < img_size) && rem_bytes) {
346 img_blen -= rem_bytes;
347 rem_bytes = 0;
Fabio Utzig30f6b2a2018-03-29 16:18:53 -0300348 }
Emanuele Di Santo205c8c62018-07-20 11:42:31 +0200349
Dominik Ermel3d4e55d2021-07-09 11:14:10 +0000350#ifdef MCUBOOT_ERASE_PROGRESSIVELY
Emanuele Di Santo205c8c62018-07-20 11:42:31 +0200351 rc = flash_area_sector_from_off(curr_off + img_blen, &sector);
352 if (rc) {
353 BOOT_LOG_ERR("Unable to determine flash sector size");
354 goto out;
355 }
Dominik Ermel260ae092021-04-23 05:38:45 +0000356 if (off_last != flash_sector_get_off(&sector)) {
357 off_last = flash_sector_get_off(&sector);
358 BOOT_LOG_INF("Erasing sector at offset 0x%x", flash_sector_get_off(&sector));
359 rc = flash_area_erase(fap, flash_sector_get_off(&sector),
360 flash_sector_get_size(&sector));
Emanuele Di Santo205c8c62018-07-20 11:42:31 +0200361 if (rc) {
362 BOOT_LOG_ERR("Error %d while erasing sector", rc);
363 goto out;
364 }
365 }
366#endif
367
368 BOOT_LOG_INF("Writing at 0x%x until 0x%x", curr_off, curr_off + img_blen);
Andrzej Puzdrowskif48de7a2020-10-19 09:42:02 +0200369 if (rem_bytes) {
370 /* the last chunk of the image might be unaligned */
371 uint8_t wbs_aligned[BOOT_MAX_ALIGN];
372 size_t w_size = img_blen - rem_bytes;
373
374 if (w_size) {
375 rc = flash_area_write(fap, curr_off, img_data, w_size);
376 if (rc) {
377 goto out_invalid_data;
378 }
379 curr_off += w_size;
380 img_blen -= w_size;
381 img_data += w_size;
382 }
383
384 if (img_blen) {
385 memcpy(wbs_aligned, img_data, rem_bytes);
386 memset(wbs_aligned + rem_bytes, flash_area_erased_val(fap),
387 sizeof(wbs_aligned) - rem_bytes);
388 rc = flash_area_write(fap, curr_off, wbs_aligned, flash_area_align(fap));
389 }
390
391 } else {
392 rc = flash_area_write(fap, curr_off, img_data, img_blen);
393 }
394
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300395 if (rc == 0) {
396 curr_off += img_blen;
Andrzej Puzdrowskic2e30cf2018-07-20 16:19:09 +0200397 if (curr_off == img_size) {
Andrzej Puzdrowski4f9c7302021-07-16 17:34:43 +0200398#ifdef MCUBOOT_ERASE_PROGRESSIVELY
Andrzej Puzdrowskic2e30cf2018-07-20 16:19:09 +0200399 /* get the last sector offset */
400 rc = flash_area_sector_from_off(boot_status_off(fap), &sector);
401 if (rc) {
402 BOOT_LOG_ERR("Unable to determine flash sector of"
403 "the image trailer");
404 goto out;
405 }
406 /* Assure that sector for image trailer was erased. */
407 /* Check whether it was erased during previous upload. */
Dominik Ermel260ae092021-04-23 05:38:45 +0000408 if (off_last < flash_sector_get_off(&sector)) {
409 BOOT_LOG_INF("Erasing sector at offset 0x%x",
410 flash_sector_get_off(&sector));
411 rc = flash_area_erase(fap, flash_sector_get_off(&sector),
412 flash_sector_get_size(&sector));
Andrzej Puzdrowskic2e30cf2018-07-20 16:19:09 +0200413 if (rc) {
414 BOOT_LOG_ERR("Error %d while erasing sector", rc);
415 goto out;
416 }
417 }
Andrzej Puzdrowskic2e30cf2018-07-20 16:19:09 +0200418#endif
Andrzej Puzdrowski4f9c7302021-07-16 17:34:43 +0200419 rc = BOOT_HOOK_CALL(boot_serial_uploaded_hook, 0, img_num, fap,
420 img_size);
421 if (rc) {
422 BOOT_LOG_ERR("Error %d post upload hook", rc);
423 goto out;
424 }
425 }
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300426 } else {
427 out_invalid_data:
Christopher Collins92ea77f2016-12-12 15:59:26 -0800428 rc = MGMT_ERR_EINVAL;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800429 }
Emanuele Di Santo205c8c62018-07-20 11:42:31 +0200430
Christopher Collins92ea77f2016-12-12 15:59:26 -0800431out:
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200432 BOOT_LOG_INF("RX: 0x%x", rc);
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100433 map_start_encode(&cbor_state, 10);
434 tstrx_put(&cbor_state, "rc");
435 uintx32_put(&cbor_state, rc);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800436 if (rc == 0) {
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100437 tstrx_put(&cbor_state, "off");
438 uintx32_put(&cbor_state, curr_off);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800439 }
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100440 map_end_encode(&cbor_state, 10);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800441
442 boot_serial_output();
443 flash_area_close(fap);
444}
445
446/*
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000447 * Send rc code only.
Christopher Collins92ea77f2016-12-12 15:59:26 -0800448 */
449static void
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000450bs_rc_rsp(int rc_code)
Christopher Collins92ea77f2016-12-12 15:59:26 -0800451{
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100452 map_start_encode(&cbor_state, 10);
453 tstrx_put(&cbor_state, "rc");
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000454 uintx32_put(&cbor_state, rc_code);
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100455 map_end_encode(&cbor_state, 10);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800456 boot_serial_output();
457}
458
459/*
460 * Reset, and (presumably) boot to newly uploaded image. Flush console
461 * before restarting.
462 */
Andrzej Puzdrowski268cdd02018-04-10 12:57:54 +0200463static void
Christopher Collins92ea77f2016-12-12 15:59:26 -0800464bs_reset(char *buf, int len)
465{
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000466 bs_rc_rsp(0);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800467
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200468#ifdef __ZEPHYR__
Andrzej Puzdrowski0cf0dbd2021-05-14 11:55:57 +0200469#ifdef CONFIG_MULTITHREADING
Carles Cufi7e7b4ad2020-03-30 19:12:02 +0200470 k_sleep(K_MSEC(250));
Andrzej Puzdrowski0cf0dbd2021-05-14 11:55:57 +0200471#else
472 k_busy_wait(250000);
473#endif
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200474 sys_reboot(SYS_REBOOT_COLD);
475#else
Christopher Collins92ea77f2016-12-12 15:59:26 -0800476 os_cputime_delay_usecs(250000);
477 hal_system_reset();
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200478#endif
Christopher Collins92ea77f2016-12-12 15:59:26 -0800479}
480
481/*
482 * Parse incoming line of input from console.
483 * Expect newtmgr protocol with serial transport.
484 */
485void
486boot_serial_input(char *buf, int len)
487{
488 struct nmgr_hdr *hdr;
489
490 hdr = (struct nmgr_hdr *)buf;
491 if (len < sizeof(*hdr) ||
492 (hdr->nh_op != NMGR_OP_READ && hdr->nh_op != NMGR_OP_WRITE) ||
493 (ntohs(hdr->nh_len) < len - sizeof(*hdr))) {
494 return;
495 }
496 bs_hdr = hdr;
497 hdr->nh_group = ntohs(hdr->nh_group);
498
499 buf += sizeof(*hdr);
500 len -= sizeof(*hdr);
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300501
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100502 cbor_state.payload_mut = (uint8_t *)bs_obuf;
503 cbor_state.payload_end = (const uint8_t *)bs_obuf
504 + sizeof(bs_obuf);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800505
506 /*
507 * Limited support for commands.
508 */
509 if (hdr->nh_group == MGMT_GROUP_ID_IMAGE) {
510 switch (hdr->nh_id) {
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300511 case IMGMGR_NMGR_ID_STATE:
Christopher Collins92ea77f2016-12-12 15:59:26 -0800512 bs_list(buf, len);
513 break;
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300514 case IMGMGR_NMGR_ID_UPLOAD:
Christopher Collins92ea77f2016-12-12 15:59:26 -0800515 bs_upload(buf, len);
516 break;
517 default:
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000518 bs_rc_rsp(MGMT_ERR_ENOTSUP);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800519 break;
520 }
521 } else if (hdr->nh_group == MGMT_GROUP_ID_DEFAULT) {
522 switch (hdr->nh_id) {
523 case NMGR_ID_CONS_ECHO_CTRL:
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000524 bs_rc_rsp(0);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800525 break;
526 case NMGR_ID_RESET:
527 bs_reset(buf, len);
528 break;
529 default:
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000530 bs_rc_rsp(MGMT_ERR_ENOTSUP);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800531 break;
532 }
Dominik Ermelbd69c3d2021-07-28 11:27:31 +0000533 } else if (MCUBOOT_PERUSER_MGMT_GROUP_ENABLED == 1) {
Dominik Ermel3d51e432021-06-25 17:29:50 +0000534 if (bs_peruser_system_specific(hdr, buf, len, &cbor_state) == 0) {
535 boot_serial_output();
536 }
Dominik Ermelc9dc2242021-07-28 17:08:23 +0000537 } else {
538 bs_rc_rsp(MGMT_ERR_ENOTSUP);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800539 }
540}
541
542static void
543boot_serial_output(void)
544{
545 char *data;
546 int len;
547 uint16_t crc;
548 uint16_t totlen;
549 char pkt_start[2] = { SHELL_NLIP_PKT_START1, SHELL_NLIP_PKT_START2 };
550 char buf[BOOT_SERIAL_OUT_MAX];
551 char encoded_buf[BASE64_ENCODE_SIZE(BOOT_SERIAL_OUT_MAX)];
552
553 data = bs_obuf;
Øyvind Rønningstad9f4aefd2021-03-08 21:11:25 +0100554 len = (uint32_t)cbor_state.payload_mut - (uint32_t)bs_obuf;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800555
556 bs_hdr->nh_op++;
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300557 bs_hdr->nh_flags = 0;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800558 bs_hdr->nh_len = htons(len);
559 bs_hdr->nh_group = htons(bs_hdr->nh_group);
560
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200561#ifdef __ZEPHYR__
Kumar Gala0813efe2020-05-27 12:25:41 -0500562 crc = crc16((uint8_t *)bs_hdr, sizeof(*bs_hdr), CRC_CITT_POLYMINAL,
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300563 CRC16_INITIAL_CRC, false);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200564 crc = crc16(data, len, CRC_CITT_POLYMINAL, crc, true);
565#else
Christopher Collins92ea77f2016-12-12 15:59:26 -0800566 crc = crc16_ccitt(CRC16_INITIAL_CRC, bs_hdr, sizeof(*bs_hdr));
567 crc = crc16_ccitt(crc, data, len);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200568#endif
Christopher Collins92ea77f2016-12-12 15:59:26 -0800569 crc = htons(crc);
570
Marko Kiiskila149b4572018-06-06 14:18:54 +0300571 boot_uf->write(pkt_start, sizeof(pkt_start));
Christopher Collins92ea77f2016-12-12 15:59:26 -0800572
573 totlen = len + sizeof(*bs_hdr) + sizeof(crc);
574 totlen = htons(totlen);
575
576 memcpy(buf, &totlen, sizeof(totlen));
577 totlen = sizeof(totlen);
578 memcpy(&buf[totlen], bs_hdr, sizeof(*bs_hdr));
579 totlen += sizeof(*bs_hdr);
580 memcpy(&buf[totlen], data, len);
581 totlen += len;
582 memcpy(&buf[totlen], &crc, sizeof(crc));
583 totlen += sizeof(crc);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200584#ifdef __ZEPHYR__
585 size_t enc_len;
Carles Cufi0165be82018-03-26 17:43:51 +0200586 base64_encode(encoded_buf, sizeof(encoded_buf), &enc_len, buf, totlen);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200587 totlen = enc_len;
588#else
Christopher Collins92ea77f2016-12-12 15:59:26 -0800589 totlen = base64_encode(buf, totlen, encoded_buf, 1);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200590#endif
Marko Kiiskila149b4572018-06-06 14:18:54 +0300591 boot_uf->write(encoded_buf, totlen);
592 boot_uf->write("\n\r", 2);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200593 BOOT_LOG_INF("TX");
Christopher Collins92ea77f2016-12-12 15:59:26 -0800594}
595
596/*
597 * Returns 1 if full packet has been received.
598 */
599static int
600boot_serial_in_dec(char *in, int inlen, char *out, int *out_off, int maxout)
601{
602 int rc;
603 uint16_t crc;
604 uint16_t len;
Marko Kiiskilae5aeee42018-12-21 15:00:16 +0200605
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200606#ifdef __ZEPHYR__
607 int err;
Andrzej Puzdrowskiec1e4d12018-06-18 14:36:14 +0200608 err = base64_decode( &out[*out_off], maxout - *out_off, &rc, in, inlen - 2);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200609 if (err) {
610 return -1;
611 }
612#else
Christopher Collins92ea77f2016-12-12 15:59:26 -0800613 if (*out_off + base64_decode_len(in) >= maxout) {
614 return -1;
615 }
616 rc = base64_decode(in, &out[*out_off]);
617 if (rc < 0) {
618 return -1;
619 }
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200620#endif
Fabio Utzig6f49c272019-08-23 11:42:58 -0300621
Christopher Collins92ea77f2016-12-12 15:59:26 -0800622 *out_off += rc;
Fabio Utzig6f49c272019-08-23 11:42:58 -0300623 if (*out_off <= sizeof(uint16_t)) {
624 return 0;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800625 }
Fabio Utzig6f49c272019-08-23 11:42:58 -0300626
627 len = ntohs(*(uint16_t *)out);
628 if (len != *out_off - sizeof(uint16_t)) {
629 return 0;
630 }
631
632 if (len > *out_off - sizeof(uint16_t)) {
633 len = *out_off - sizeof(uint16_t);
634 }
635
636 out += sizeof(uint16_t);
637#ifdef __ZEPHYR__
638 crc = crc16(out, len, CRC_CITT_POLYMINAL, CRC16_INITIAL_CRC, true);
639#else
640 crc = crc16_ccitt(CRC16_INITIAL_CRC, out, len);
641#endif
642 if (crc || len <= sizeof(crc)) {
643 return 0;
644 }
645 *out_off -= sizeof(crc);
646 out[*out_off] = '\0';
647
648 return 1;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800649}
650
651/*
652 * Task which waits reading console, expecting to get image over
653 * serial port.
654 */
655void
Marko Kiiskila149b4572018-06-06 14:18:54 +0300656boot_serial_start(const struct boot_uart_funcs *f)
Christopher Collins92ea77f2016-12-12 15:59:26 -0800657{
658 int rc;
659 int off;
David Brown57f0df32020-05-12 08:39:21 -0600660 int dec_off = 0;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800661 int full_line;
Marko Kiiskila149b4572018-06-06 14:18:54 +0300662 int max_input;
Christopher Collins92ea77f2016-12-12 15:59:26 -0800663
Marko Kiiskila149b4572018-06-06 14:18:54 +0300664 boot_uf = f;
Marko Kiiskila149b4572018-06-06 14:18:54 +0300665 max_input = sizeof(in_buf);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800666
667 off = 0;
668 while (1) {
Andrzej Puzdrowskiaea38eb2021-06-11 12:28:59 +0200669 MCUBOOT_CPU_IDLE();
Hein Wessels56d28f02021-11-19 08:42:08 +0100670 MCUBOOT_WATCHDOG_FEED();
Andrzej Puzdrowskiec1e4d12018-06-18 14:36:14 +0200671 rc = f->read(in_buf + off, sizeof(in_buf) - off, &full_line);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800672 if (rc <= 0 && !full_line) {
673 continue;
674 }
675 off += rc;
676 if (!full_line) {
Marko Kiiskilace50ab02018-06-06 11:33:33 +0300677 if (off == max_input) {
678 /*
679 * Full line, no newline yet. Reset the input buffer.
680 */
681 off = 0;
682 }
Christopher Collins92ea77f2016-12-12 15:59:26 -0800683 continue;
684 }
Andrzej Puzdrowskiec1e4d12018-06-18 14:36:14 +0200685 if (in_buf[0] == SHELL_NLIP_PKT_START1 &&
686 in_buf[1] == SHELL_NLIP_PKT_START2) {
Christopher Collins92ea77f2016-12-12 15:59:26 -0800687 dec_off = 0;
Andrzej Puzdrowskiec1e4d12018-06-18 14:36:14 +0200688 rc = boot_serial_in_dec(&in_buf[2], off - 2, dec_buf, &dec_off, max_input);
689 } else if (in_buf[0] == SHELL_NLIP_DATA_START1 &&
690 in_buf[1] == SHELL_NLIP_DATA_START2) {
691 rc = boot_serial_in_dec(&in_buf[2], off - 2, dec_buf, &dec_off, max_input);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800692 }
Andrzej Puzdrowskiec1e4d12018-06-18 14:36:14 +0200693
694 /* serve errors: out of decode memory, or bad encoding */
Christopher Collins92ea77f2016-12-12 15:59:26 -0800695 if (rc == 1) {
Andrzej Puzdrowskiec1e4d12018-06-18 14:36:14 +0200696 boot_serial_input(&dec_buf[2], dec_off - 2);
Christopher Collins92ea77f2016-12-12 15:59:26 -0800697 }
698 off = 0;
699 }
700}