Add package tiny-vcdiff

CODEOWNERS

@@ -108,6 +108,7 @@
 /pkg/openthread/                            @Hyungsin @jia200x
 /pkg/semtech-loramac/                       @aabadie @jia200x
 /pkg/tinydtls/                              @rfuentess @leandrolanzieri
+/pkg/tinyvcdiff/                            @jue89
 /pkg/u8g2/                                  @basilfx
 /pkg/ucglib/                                @basilfx
 /pkg/wakaama/                               @leandrolanzieri

pkg/Kconfig

@@ -64,6 +64,7 @@ rsource "tiny-asn1/Kconfig"
 rsource "tinycbor/Kconfig"
 rsource "tinycrypt/Kconfig"
 rsource "tinydtls/Kconfig"
+rsource "tinyvcdiff/Kconfig"
 rsource "tlsf/Kconfig"
 rsource "tweetnacl/Kconfig"
 rsource "u8g2/Kconfig"

pkg/tinyvcdiff/Kconfig

@@ -0,0 +1,46 @@
+# Copyright (c) 2022 Juergen Fitschen
+#
+# This file is subject to the terms and conditions of the GNU Lesser
+# General Public License v2.1. See the file LICENSE in the top level
+# directory for more details.
+
+menuconfig PACKAGE_TINYVCDIFF
+    bool "Tiny VCDIFF"
+    depends on TEST_KCONFIG
+
+if PACKAGE_TINYVCDIFF
+
+config TINYVCDIFF_BUFFER_SIZE
+    int "Buffer size"
+    default 128
+    help
+        For VCDIFF copy and run instruction the library requires a buffer.
+        The best performance is achieved for sizes of typical page sizes of
+        the underlying MTD or VFS backend. But a size of just 1 byte would
+        work, too.
+
+menuconfig MODULE_TINYVCDIFF_MTD
+    bool "MTD Backend"
+    depends on MODULE_MTD
+    default y
+    help
+        Use a MTD device as VCDIFF target or source.
+
+if MODULE_TINYVCDIFF_MTD
+
+config TINYVCDIFF_MTD_WRITE_SIZE
+    int "Write size"
+    default 4
+    help
+        Alignment and minimum size for MTD write access.
+
+endif # MODULE_TINYVCDIFF_MTD
+
+config MODULE_TINYVCDIFF_VFS
+    bool "VFS Backend"
+    depends on MODULE_VFS
+    default y
+    help
+        Use a VFS file as VCDIFF target or source.
+
+endif # PACKAGE_TINYVCDIFF

pkg/tinyvcdiff/Makefile

@@ -0,0 +1,9 @@
+PKG_NAME=tinyvcdiff
+PKG_URL=https://github.com/jue89/tiny-vcdiff.git
+PKG_VERSION=e1a679f36d0212f2b84057a70c72f6e9deda45b3
+PKG_LICENSE=MIT
+
+include $(RIOTBASE)/pkg/pkg.mk
+
+all:
+	$(QQ)"$(MAKE)" -C $(PKG_SOURCE_DIR)/src -f $(CURDIR)/$(PKG_NAME).mk

pkg/tinyvcdiff/Makefile.dep

@@ -0,0 +1,7 @@
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE += tinyvcdiff_mtd
+endif
+
+ifneq (,$(filter vfs,$(USEMODULE)))
+  USEMODULE += tinyvcdiff_vfs
+endif

pkg/tinyvcdiff/Makefile.include

@@ -0,0 +1,19 @@
+# Buffer size for vcdiff
+CONFIG_TINYVCDIFF_BUFFER_SIZE ?= 128
+CFLAGS += -DVCDIFF_BUFFER_SIZE=$(CONFIG_TINYVCDIFF_BUFFER_SIZE)
+
+# Disable debugging if DEVELHELP is turned off
+ifneq ($(DEVELHELP),1)
+  CFLAGS += -DVCDIFF_NDEBUG
+endif
+
+INCLUDES += -I$(PKGDIRBASE)/tinyvcdiff/include
+INCLUDES += -I$(RIOTPKG)/tinyvcdiff/include
+
+ifneq (,$(filter tinyvcdiff_mtd,$(USEMODULE)))
+  DIRS += $(RIOTPKG)/tinyvcdiff/contrib/tinyvcdiff_mtd
+endif
+
+ifneq (,$(filter tinyvcdiff_vfs,$(USEMODULE)))
+  DIRS += $(RIOTPKG)/tinyvcdiff/contrib/tinyvcdiff_vfs
+endif

pkg/tinyvcdiff/contrib/tinyvcdiff_mtd/Makefile

@@ -0,0 +1,3 @@
+MODULE = tinyvcdiff_mtd
+
+include $(RIOTBASE)/Makefile.base

pkg/tinyvcdiff/contrib/tinyvcdiff_mtd/mtd.c

@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2022 Juergen Fitschen
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+#include "vcdiff_mtd.h"
+#include "assert.h"
+#include <string.h>
+
+#define ENABLE_DEBUG 0
+#include "debug.h"
+
+static int _erase (void *dev, size_t offset, size_t len)
+{
+    int rc;
+    vcdiff_mtd_t *mtd = dev;
+    size_t addr = offset + len;
+    size_t page = addr / mtd->dev->page_size;
+    size_t sector = page / mtd->dev->pages_per_sector;
+    size_t cnt = sector - mtd->next_erase_sector + 1;
+
+    /* early exit if all sectors are already in the erased state */
+    if (cnt == 0) {
+        return 0;
+    }
+
+    /* erase sectors */
+    rc = mtd_erase_sector(mtd->dev, mtd->next_erase_sector, cnt);
+    if (rc != 0) {
+        return rc;
+    }
+
+    mtd->next_erase_sector += cnt;
+
+    return 0;
+}
+
+static int _read (void *dev, uint8_t *dest, size_t offset, size_t len)
+{
+    vcdiff_mtd_t *mtd = dev;
+
+    /* mtd_read_page will take care of calculation the right page */
+    int rc = mtd_read_page(mtd->dev, dest, 0, offset, len);
+
+    return rc;
+}
+
+static int _align_write (vcdiff_mtd_t *mtd, uint8_t **src, size_t *len)
+{
+    size_t alignment_offset;
+    size_t copy_len;
+
+    alignment_offset = mtd->offset % CONFIG_TINYVCDIFF_MTD_WRITE_SIZE;
+    if (alignment_offset == 0) {
+        /* we are already aligned */
+        return 0;
+    }
+
+    /* check how many bytes have to be copied to be aligned */
+    copy_len = CONFIG_TINYVCDIFF_MTD_WRITE_SIZE - alignment_offset;
+    if (copy_len > *len) {
+        copy_len = *len;
+    }
+
+    /* copy unaligned bytes to the write buffer */
+    memcpy(&mtd->write_buffer[alignment_offset], *src, copy_len);
+    alignment_offset += copy_len;
+    mtd->offset += copy_len;
+    *len -= copy_len;
+    *src += copy_len;
+    DEBUG("_align_write: buffered %zuB for alignment\n", copy_len);
+
+    if (alignment_offset < CONFIG_TINYVCDIFF_MTD_WRITE_SIZE) {
+        /* we haven't collected enough bytes, yet */
+        return 0;
+    }
+
+    assert(alignment_offset == CONFIG_TINYVCDIFF_MTD_WRITE_SIZE);
+
+    DEBUG("_align_write: write buffered data\n");
+
+    /* write buffer to mtd
+     * mtd_read_page will take care of calculation the right page
+     * it's safe to call mtd_read_page_raw: the erase driver already
+     * prepared the sector for writing */
+    return mtd_write_page_raw(mtd->dev, mtd->write_buffer, 0,
+                              mtd->offset - alignment_offset,
+                              CONFIG_TINYVCDIFF_MTD_WRITE_SIZE);
+}
+
+static int _write (void *dev, uint8_t *src, size_t offset, size_t len)
+{
+    int rc;
+    size_t to_copy;
+    vcdiff_mtd_t *mtd = dev;
+
+    assert(offset == mtd->offset);
+
+    DEBUG("_write: 0x%zx + %zuB\n", mtd->offset, len);
+
+    /* align writes */
+    rc = _align_write(dev, &src, &len);
+    if (rc < 0) {
+        /* an error occurred */
+        return rc;
+    } else if (len == 0) {
+        /* no bytes are left */
+        return 0;
+    }
+
+    assert((mtd->offset % CONFIG_TINYVCDIFF_MTD_WRITE_SIZE) == 0);
+
+    /* copy all aligned data */
+    to_copy = (len / CONFIG_TINYVCDIFF_MTD_WRITE_SIZE) * CONFIG_TINYVCDIFF_MTD_WRITE_SIZE;
+    rc = mtd_write_page_raw(mtd->dev, src, 0, mtd->offset, to_copy);
+    if (rc < 0) {
+        return rc;
+    }
+    mtd->offset += to_copy;
+    len -= to_copy;
+    src += to_copy;
+    if (len == 0) {
+        /* no bytes are left */
+        return 0;
+    }
+
+    assert(len < CONFIG_TINYVCDIFF_MTD_WRITE_SIZE);
+
+    /* copy remaining bytes into write_buffer */
+    memcpy(mtd->write_buffer, src, len);
+    mtd->offset += len;
+    DEBUG("_write: buffered %zuB for alignment\n", len);
+
+    return rc;
+}
+
+static int _flush (void *dev)
+{
+    vcdiff_mtd_t *mtd = dev;
+    int rc;
+    uint8_t buf[CONFIG_TINYVCDIFF_MTD_WRITE_SIZE];
+    size_t alignment_offset;
+
+    alignment_offset = mtd->offset % CONFIG_TINYVCDIFF_MTD_WRITE_SIZE;
+    if (alignment_offset == 0) {
+        /* we are already aligned -> no bytes are left in the buffer */
+        return 0;
+    }
+
+    DEBUG("_flush: write last %zuB\n", alignment_offset);
+
+    /* get present bytes from MTD to pad alignment */
+    rc = mtd_read_page(mtd->dev, buf, 0, mtd->offset - alignment_offset,
+                       CONFIG_TINYVCDIFF_MTD_WRITE_SIZE);
+    if (rc < 0) {
+        return rc;
+    }
+
+    /* pad write buffer */
+    memcpy(&mtd->write_buffer[alignment_offset], &buf[alignment_offset],
+           CONFIG_TINYVCDIFF_MTD_WRITE_SIZE - alignment_offset);
+
+    /* write last buffer */
+    rc = mtd_write_page_raw(mtd->dev, mtd->write_buffer, 0,
+                            mtd->offset - alignment_offset,
+                            CONFIG_TINYVCDIFF_MTD_WRITE_SIZE);
+
+    return rc;
+}
+
+const vcdiff_driver_t vcdiff_mtd_driver = {
+    .erase = _erase,
+    .read = _read,
+    .write = _write,
+    .flush = _flush
+};

pkg/tinyvcdiff/contrib/tinyvcdiff_vfs/Makefile

@@ -0,0 +1,3 @@
+MODULE = tinyvcdiff_vfs
+
+include $(RIOTBASE)/Makefile.base

pkg/tinyvcdiff/contrib/tinyvcdiff_vfs/vfs.c

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2022 Juergen Fitschen
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+#include "vcdiff_vfs.h"
+#include <unistd.h>
+#include "errno.h"
+
+static int _read (void *dev, uint8_t *dest, size_t offset, size_t len)
+{
+    int rc;
+    vcdiff_vfs_t *vfs = dev;
+
+    /* seek to the given offset */
+    rc = vfs_lseek(vfs->fd, offset, SEEK_SET);
+    if (rc < 0) {
+        return rc;
+    } else if ((size_t) rc != offset) {
+        return -EFAULT;
+    }
+
+    /* read from file into the buffer */
+    rc = vfs_read(vfs->fd, dest, len);
+    if (rc < 0) {
+        return rc;
+    } else if ((size_t) rc != len) {
+        return -EFAULT;
+    }
+
+    return 0;
+}
+
+static int _write (void *dev, uint8_t *src, size_t offset, size_t len)
+{
+    int rc;
+    vcdiff_vfs_t *vfs = dev;
+
+    /* make sure to stay in the set file size bounds */
+    if (offset + len > vfs->max_size) {
+        return -EFBIG;
+    }
+
+    /* seek to the given offset */
+    rc = vfs_lseek(vfs->fd, offset, SEEK_SET);
+    if (rc < 0) {
+        return rc;
+    } else if ((size_t) rc != offset) {
+        return -EFAULT;
+    }
+
+    /* write all bytes to the file */
+    rc = vfs_write(vfs->fd, src, len);
+    if (rc < 0) {
+        return rc;
+    } else if ((size_t) rc != len) {
+        return -EFAULT;
+    }
+
+    return 0;
+}
+
+const vcdiff_driver_t vcdiff_vfs_driver = {
+    .read = _read,
+    .write = _write
+};