storage.h

/*
 * Copyright (C) 2020 Koen Zandberg
 *               2020 Inria
 *
 * 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.
 */
 
#pragma once
 
#include "suit.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct suit_storage suit_storage_t;
 
typedef struct suit_storage_driver {
 
    int (*init)(suit_storage_t *storage);
 
    int (*start)(suit_storage_t *storage, const suit_manifest_t *manifest,
                 size_t len);
 
    int (*write)(suit_storage_t *storage, const suit_manifest_t *manifest, const
                 uint8_t *buf, size_t offset, size_t len);
 
    int (*finish)(suit_storage_t *storage, const suit_manifest_t *manifest);
 
    int (*read)(suit_storage_t *storage, uint8_t *buf, size_t offset,
                size_t len);
 
    int (*read_ptr)(suit_storage_t *storage,
                    const uint8_t **buf, size_t *len);
 
    int (*install)(suit_storage_t *storage, const suit_manifest_t *manifest);
 
    int (*erase)(suit_storage_t *storage);
 
    bool (*has_location)(const suit_storage_t *storage, const char *location);
 
    bool (*match_offset)(const suit_storage_t *storage, size_t offset);
 
    int (*set_active_location)(suit_storage_t *storage, const char *location);
 
    int (*get_seq_no)(const suit_storage_t *storage, uint32_t *seq_no);
 
    int (*set_seq_no)(suit_storage_t *storage, uint32_t seq_no);
 
    char separator;
} suit_storage_driver_t;
 
struct suit_storage {
    const suit_storage_driver_t *driver; 
};
 
suit_storage_t *suit_storage_find_by_id(const char *id);
 
suit_storage_t *suit_storage_find_by_component(const suit_manifest_t *manifest,
                                               const suit_component_t *component);
 
void suit_storage_init_all(void);
 
int suit_storage_get_highest_seq_no(uint32_t *seq_no);
 
int suit_storage_set_seq_no_all(uint32_t seq_no);
 
static inline char suit_storage_get_separator(const suit_storage_t *storage)
{
    return storage->driver->separator;
}
 
static inline bool suit_storage_has_readptr(const suit_storage_t *storage)
{
    return (storage->driver->read_ptr);
}
 
static inline bool suit_storage_has_offset(const suit_storage_t *storage)
{
    return (storage->driver->match_offset);
}
 
static inline int suit_storage_init(suit_storage_t *storage)
{
    return storage->driver->init(storage);
}
 
static inline int suit_storage_start(suit_storage_t *storage,
                                     const suit_manifest_t *manifest,
                                     size_t len)
{
    return storage->driver->start(storage, manifest, len);
}
 
static inline int suit_storage_write(suit_storage_t *storage,
                                     const suit_manifest_t *manifest,
                                     const uint8_t *buf, size_t offset,
                                     size_t len)
{
    return storage->driver->write(storage, manifest, buf, offset, len);
}
 
static inline int suit_storage_finish(suit_storage_t *storage,
                                      const suit_manifest_t *manifest)
{
    return storage->driver->finish(storage, manifest);
}
 
static inline int suit_storage_read(suit_storage_t *storage, uint8_t *buf,
                                    size_t offset, size_t len)
{
    return storage->driver->read(storage, buf, offset, len);
}
 
static inline int suit_storage_read_ptr(suit_storage_t *storage, const uint8_t
                                        **buf, size_t *len)
{
    return storage->driver->read_ptr(storage, buf, len);
}
 
static inline int suit_storage_install(suit_storage_t *storage,
                                       const suit_manifest_t *manifest)
{
    return storage->driver->install(storage, manifest);
}
 
static inline int suit_storage_erase(suit_storage_t *storage)
{
    return storage->driver->erase(storage);
}
 
static inline bool suit_storage_has_location(suit_storage_t *storage,
                                             const char *location)
{
    return storage->driver->has_location(storage, location);
}
 
static inline bool suit_storage_match_offset(const suit_storage_t *storage,
                                             size_t offset)
{
    return storage->driver->match_offset(storage, offset);
}
 
static inline int suit_storage_set_active_location(suit_storage_t *storage,
                                                   const char *location)
{
    return storage->driver->set_active_location(storage, location);
}
 
static inline int suit_storage_get_seq_no(const suit_storage_t *storage,
                                          uint32_t *seq_no)
{
    return storage->driver->get_seq_no(storage, seq_no);
}
 
static inline int suit_storage_set_seq_no(suit_storage_t *storage,
                                          uint32_t seq_no)
{
    return storage->driver->set_seq_no(storage, seq_no);
}
#ifdef __cplusplus
}
#endif