Merge pull request #20 from Sani7/TFTP

Add tftp functionality

.gitignore

@@ -59,3 +59,4 @@ project/Scripts
 Scripts/
 
 project/project\ Debug.launch
+build/

CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
+
+project(WSAA_tests LANGUAGES CXX C)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(VERSION_MAJOR 1)
+set(VERSION_MINOR 0)
+
+include(GNUInstallDirs)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
+  ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
+  ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
+  ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})
+set(PROJECT_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+enable_testing()
+add_subdirectory(tests)

README.md

@@ -67,3 +67,4 @@ This folder contains the following documents:
 - [logger.md](docs/logger.md): Logging and Debugging Messages
 - [mkllfs.md](docs/mkllfs.md): Make Linked List File System
 - [style_guide.md](docs/style_guide.md): Style Guide
+- [tftp.md](docs/tftp.md): Trivial File Transfer Protocol

docs/tftp.md

@@ -0,0 +1,35 @@
+# TFTP
+This is the documentation of the TFTP task
+## Initialization
+The TFTP task is initialized in the main function.
+```c
+// Initialize TFTP task
+tftp_init();
+```
+## Deinitialization
+If you would ever want to deinitialize the TFTP task, you can do so by calling the following function.
+```c
+// Deinitialize TFTP task
+tftp_server_deinit();
+```
+
+## Usage
+The TFTP task is used to receive and send files via TFTP.
+### Receive a file
+index.txt contains a list of files on the file system.
+```bash
+bash $ tftp <ip>
+tftp $ get index.txt
+```
+### Send a file
+You can only write to the following files:
+- virtImage.bmp
+```bash
+bash $ tftp <ip>
+tftp $ put <image.bmp> virtImage.bmp
+```
+- virtImage.gif
+```bash
+bash $ tftp <ip>
+tftp $ put <image.gif> virtImage.gif
+```

project/Core/Inc/tftp.h

@@ -0,0 +1,79 @@
+/**
+ * @file tftp.h
+ * @brief tftp server
+ * @author Sander S.
+ */
+
+#ifndef PROJECT_TFTP_H
+#define PROJECT_TFTP_H
+#include <tftp_server.h>
+#ifndef TESTING
+#include "lcd_api.h"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define LOGGER_LEVEL_ALL
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "llfs.h"
+#include "log.h"
+
+#define TFTP_READ 0
+
+#ifndef UNUSED
+#define UNUSED(x) (void)(x)
+#endif
+
+typedef struct tftp_custom_file_s {
+    char* data;
+    size_t len;
+    char* name;
+    size_t offset;
+} tftp_custom_file_t;
+
+/**
+ * @brief Initialize the TFTP server
+ */
+void tftp_server_init(void);
+
+/**
+ * @brief Uninitialize the TFTP server
+ */
+void tftp_server_deinit(void);
+
+/**
+ * @brief Custom fseek function
+ *
+ * @param handle The custom file handle
+ * @param offset The offset
+ * @param whence The whence
+ */
+void tftp_custom_fseek(tftp_custom_file_t* handle, size_t offset, int whence);
+
+/**
+ * @brief Custom fread function
+ *
+ * @param buf The buffer to read from
+ * @param bytes The amount of bytes to read
+ * @param handle The custom file handle
+ * @return The amount of bytes read
+ */
+size_t tftp_custom_fread(void* buf, size_t bytes, tftp_custom_file_t* handle);
+
+/**
+ * @brief Custom fwrite function
+ *
+ * @param buf The buffer to write to
+ * @param bytes The amount of bytes to write
+ * @param handle The custom file handle
+ * @return The amount of bytes written
+ */
+size_t tftp_custom_fwrite(const void* buf, size_t bytes, tftp_custom_file_t* handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PROJECT_TFTP_H

project/Core/Src/main.c

@@ -28,6 +28,7 @@
 #include "log.h"
 #include "llfs.h"
 #include "lcd_api.h"
+#include "tftp.h"
 
 /* USER CODE END Includes */
 
@@ -129,6 +130,8 @@ int main(void)
   /* Initialize the filesystem */
   llfs_init();
 
+  /* Initialize the tftp server */
+  tftp_server_init();
   /* USER CODE END 2 */
 
   /* Infinite loop */

project/Core/Src/tftp.c

@@ -0,0 +1,323 @@
+/**
+ * @file tftp.c
+ * @brief tftp server
+ * @author Sander S.
+ */
+
+#include "tftp.h"
+
+#define VIRT_INDEX_TXT 0
+#define VIRT_IMAGE_BMP 1
+#define VIRT_IMAGE_GIF 2
+#define VIRT_TEXT_TXT  3
+#define MAX_VIRT_FILES 4
+
+#define IMAGE_BUFFER_SIZE 81920
+
+static const char* TAG = "tftp_server";
+
+static tftp_custom_file_t virt_file[] = {{.name = "index.txt", .data = NULL, .len = 0, .offset = 0},
+                                         {.name = "virtImage.bmp", .data = NULL, .len = 0, .offset = 0},
+                                         {.name = "virtImage.gif", .data = NULL, .len = 0, .offset = 0},
+                                         {.name = "virtText.txt", .data = NULL, .len = 0, .offset = 0}};
+
+static int str_cat_str(char* dest, size_t dest_size, const char* src) {
+    size_t dest_len = strlen(dest);
+    size_t src_len = strlen(src);
+    if (dest_len + src_len > dest_size) {
+        return -1;
+    }
+    memcpy(dest + dest_len, src, src_len);
+    return 0;
+}
+
+static int str_cat(char* dest, size_t dest_size, char c) {
+    size_t dest_len = strlen(dest);
+    if (dest_len + 1 > dest_size) {
+        return -1;
+    }
+    dest[dest_len] = c;
+    dest[dest_len + 1] = '\0';
+    return 0;
+}
+
+/**
+ * @brief tftp custom file functions to set the offset and read the data
+ * @param[in,out] handle Custom file handles
+ * @param[in] offset The offset to set
+ * @param[in] whence The origin of the offset
+ */
+void tftp_custom_fseek(tftp_custom_file_t* handle, size_t offset, int whence) {
+    switch (whence) {
+        case SEEK_SET:
+            handle->offset = offset;
+            break;
+        case SEEK_CUR:
+            handle->offset += offset;
+            break;
+        case SEEK_END:
+            break;
+    }
+    if (handle->offset > handle->len) {
+        handle->offset = handle->len;
+    }
+}
+
+/**
+ * @brief tftp custom file functions to read the data
+ *        auto rolling over the offset
+ *        if the bytes to read is bigger than the remaining bytes
+ *        it will read the remaining bytes and set the bytes to 0
+ * @param[out] buf The buffer to write the data to
+ * @param[in] bytes The number of bytes to read
+ * @param[in,out] handle Custom file handles
+ */
+size_t tftp_custom_fread(void* buf, size_t bytes, tftp_custom_file_t* handle) {
+    if (handle->offset + bytes > handle->len) {
+        bytes = handle->len - handle->offset;
+    }
+    memcpy(buf, handle->data + handle->offset, bytes);
+    handle->offset += bytes;
+    ((char*)buf)[bytes] = '\0';
+    if (handle->offset > handle->len) {
+        bytes = 0;
+    }
+    return bytes;
+}
+
+/**
+ * @brief tftp custom file functions to write the data
+ *        auto rolling over the offset
+ *
+ * @param buf The buffer to write the data to
+ * @param bytes The number of bytes to write
+ * @param handle The handle to the file to write to
+ * @return The number of bytes written
+ */
+size_t tftp_custom_fwrite(const void* buf, size_t bytes, tftp_custom_file_t* handle) {
+    if (handle->offset + bytes > handle->len) {
+        bytes = handle->len - handle->offset;
+    }
+    memcpy(handle->data + handle->offset, buf, bytes);
+    handle->offset += bytes;
+    if (handle->offset > handle->len) {
+        bytes = 0;
+    }
+    return bytes;
+}
+
+/**
+ * @brief tftp helper functions
+ */
+
+/**
+ * @brief This function is called when a file is opened
+ *        It should return a handle to the file or NULL if the file does not exist
+ *        The handle contains a ptr to or the actual file data or a virtual file
+ *
+ * @param fname The name of the file to open
+ * @param mode 	Mode string from TFTP RFC
+ * @param write Flag indicating read (0) or write (!= 0) access
+ * @return void* File handle supplied to other functions
+ */
+void* tftp_open(const char* fname, const char* mode, uint8_t write) {
+    LOG_INFO(TAG, "Opening %s", fname);
+
+    UNUSED(mode);
+
+    if (strcmp(fname, virt_file[VIRT_INDEX_TXT].name) == 0 && write == TFTP_READ) {
+        tftp_custom_fseek(&virt_file[VIRT_INDEX_TXT], 0, SEEK_SET);
+        return &virt_file[0];
+    } else if (strcmp(fname, virt_file[VIRT_IMAGE_BMP].name) == 0 && write != TFTP_READ) {
+        return &virt_file[VIRT_IMAGE_BMP];
+    } else if (strcmp(fname, virt_file[VIRT_IMAGE_GIF].name) == 0 && write != TFTP_READ) {
+        return &virt_file[VIRT_IMAGE_GIF];
+    } else if (strcmp(fname, virt_file[VIRT_TEXT_TXT].name) == 0 && write != TFTP_READ) {
+        return &virt_file[VIRT_TEXT_TXT];
+    }
+
+    return fopen(fname, write ? "wb" : "rb");
+}
+
+/**
+ * @brief This function is called when a file is closed
+ *
+ * @param handle The handle to the file to close
+ */
+void tftp_close(void* handle) {
+    LOG_INFO(TAG, "closing file");
+    if (handle == NULL) {
+        LOG_CRIT(TAG, "handle is null");
+        return;
+    }
+
+    if (handle == &virt_file[VIRT_IMAGE_BMP]) {
+        lcd_clear_images();
+        lcd_clear_text();
+        lcd_draw_bmp_img((uint8_t*)virt_file[VIRT_IMAGE_BMP].data, 0, 0);
+    }
+
+    if (handle == &virt_file[VIRT_IMAGE_GIF]) {
+        lcd_clear_images();
+        lcd_clear_text();
+        lcd_draw_gif((uint8_t*)virt_file[VIRT_IMAGE_GIF].data, virt_file[VIRT_IMAGE_GIF].offset, 0, 0);
+    }
+
+    if (handle == &virt_file[VIRT_TEXT_TXT]) {
+        lcd_clear_images();
+        lcd_clear_text();
+        lcd_display_text((uint8_t*)virt_file[VIRT_TEXT_TXT].data, 0, 0, LCD_COLOR_WHITE, LCD_FONT16);
+    }
+
+    if (handle == &virt_file[VIRT_INDEX_TXT] || handle == &virt_file[VIRT_IMAGE_BMP]
+        || handle == &virt_file[VIRT_IMAGE_GIF] || handle == &virt_file[VIRT_TEXT_TXT]) {
+        ((tftp_custom_file_t*)handle)->offset = 0;
+        return;
+    }
+
+    fclose((FILE*)handle);
+}
+
+/**
+ * @brief This function is called when a file is read
+ *        The virtual files are filtered out first
+ *        then the file is trying to get read from the llfs
+ *
+ * @param handle File handle returned by open()
+ * @param buf Target buffer to copy read data to
+ * @param bytes Number of bytes to copy to buf
+ * @return int >= 0: Success; < 0: Error
+ */
+int tftp_read(void* handle, void* buf, int bytes) {
+    int ret = 0;
+    LOG_INFO(TAG, "reading file");
+    if (handle == NULL) {
+        LOG_CRIT(TAG, "handle is null");
+        return -1;
+    }
+    FILE* file = (FILE*)handle;
+
+    if ((tftp_custom_file_t*)file == &virt_file[VIRT_INDEX_TXT]) {
+        ret = (int)tftp_custom_fread(buf, (size_t)bytes, (tftp_custom_file_t*)file);
+        return ret;
+    } else if ((tftp_custom_file_t*)file == &virt_file[VIRT_IMAGE_BMP]) {
+        LOG_CRIT(TAG, "Exception: Trying to read a write only file");
+        return -1;
+    } else if ((tftp_custom_file_t*)file == &virt_file[VIRT_IMAGE_GIF]) {
+        LOG_CRIT(TAG, "Exception: Trying to read a write only file");
+        return -1;
+    } else if ((tftp_custom_file_t*)file == &virt_file[VIRT_TEXT_TXT]) {
+        LOG_CRIT(TAG, "Exception: Trying to read a write only file");
+        return -1;
+    }
+
+    ret = (int)fread(buf, sizeof(uint8_t), (size_t)bytes, file);
+    if (ret <= 0) {
+        return -1;
+    }
+    return ret;
+}
+
+/**
+ * @brief This function is called when a file is written
+ *
+ * @param handle File handle returned by open()
+ * @param p PBUF adjusted such that payload pointer points to the beginning of write data.
+ * In other words, TFTP headers are stripped off.
+ * @return int >= 0: Success; < 0: Error
+ */
+int tftp_write(void* handle, struct pbuf* p) {
+    LOG_INFO(TAG, "Writing file");
+    tftp_custom_file_t* file = (tftp_custom_file_t*)handle;
+    if (file == &virt_file[VIRT_IMAGE_BMP] || file == &virt_file[VIRT_IMAGE_GIF] || file == &virt_file[VIRT_TEXT_TXT]) {
+        return (int)tftp_custom_fwrite(p->payload, (size_t)(p->len), file);
+    }
+    return -1;
+}
+
+/**
+ * @brief This function creates the file list for index.txt
+ */
+void init_index(void) {
+    size_t len = 0;
+    // Add len of the virt files to the size
+    for (int i = 0; i < MAX_VIRT_FILES; i++) {
+        len += strlen(virt_file[i].name) + 1;
+    }
+    void* mem = NULL;   // Pointer for internal use by the llfs library
+    llfs_file_t* file;
+    while ((file = llfs_next_file(&mem, NULL)) != NULL) {
+        len += strlen(file->name) + 1;
+    }
+    len++; // +1 for the \0
+    virt_file[VIRT_INDEX_TXT].data = calloc(len, sizeof(char));
+    if (virt_file[VIRT_INDEX_TXT].data == NULL) {
+        LOG_FATAL(TAG, "Could not allocate memory for index.txt");
+        return;
+    }
+    virt_file[VIRT_INDEX_TXT].len = len;
+
+    for (int i = 0; i < MAX_VIRT_FILES; i++) {
+        str_cat_str(virt_file[VIRT_INDEX_TXT].data, len, virt_file[i].name);
+        str_cat(virt_file[VIRT_INDEX_TXT].data, len, '\n');
+    }
+
+    mem = NULL;
+    file = NULL;
+
+    while ((file = llfs_next_file(&mem, NULL)) != NULL) {
+        str_cat_str(virt_file[VIRT_INDEX_TXT].data, len, file->name);
+        str_cat(virt_file[VIRT_INDEX_TXT].data, len, '\n');
+    }
+}
+
+struct tftp_context tftpContext_s = {.open = tftp_open, .close = tftp_close, .read = tftp_read, .write = tftp_write};
+
+/**
+ * @brief Initialize tftp server
+ */
+void tftp_server_init(void) {
+    LOG_INFO(TAG, "Initializing tftp server");
+    // init the index.txt virt_file
+    init_index();
+    LOG_DEBUG(TAG, "index.txt: %s", virt_file[VIRT_INDEX_TXT].data);
+    // init the virtImage.raw virt_file with 80kb of ram
+    virt_file[VIRT_IMAGE_BMP].data = calloc(IMAGE_BUFFER_SIZE, sizeof(char));
+    if (virt_file[VIRT_IMAGE_BMP].data == NULL) {
+        LOG_FATAL(TAG, "Could not allocate memory for virtImage.bmp/virtImage.gif");
+        return;
+    }
+    virt_file[VIRT_IMAGE_BMP].len = IMAGE_BUFFER_SIZE;
+
+    virt_file[VIRT_IMAGE_GIF].data = virt_file[VIRT_IMAGE_BMP].data;
+    virt_file[VIRT_IMAGE_GIF].len = virt_file[VIRT_IMAGE_BMP].len;
+
+    virt_file[VIRT_TEXT_TXT].data = virt_file[VIRT_IMAGE_BMP].data;
+    virt_file[VIRT_TEXT_TXT].len = virt_file[VIRT_IMAGE_BMP].len;
+
+    // Init the tftp server
+    if (tftp_init(&tftpContext_s) != ERR_OK) {
+        LOG_FATAL(TAG, "Could not initialize tftp server");
+        return;
+    }
+    LOG_INFO(TAG, "tftp server initialized successfully");
+}
+
+void tftp_server_deinit(void) {
+    LOG_INFO(TAG, "Deinitializing tftp server");
+    tftp_cleanup();
+    LOG_INFO(TAG, "tftp server deinitialized successfully");
+    free(virt_file[VIRT_INDEX_TXT].data);
+    virt_file[VIRT_INDEX_TXT].data = NULL;
+    virt_file[VIRT_INDEX_TXT].len = 0;
+    virt_file[VIRT_INDEX_TXT].offset = 0;
+    free(virt_file[VIRT_IMAGE_BMP].data);
+    virt_file[VIRT_IMAGE_BMP].data = NULL;
+    virt_file[VIRT_IMAGE_BMP].len = 0;
+
+    virt_file[VIRT_IMAGE_GIF].data = NULL;
+    virt_file[VIRT_IMAGE_GIF].len = 0;
+
+    virt_file[VIRT_TEXT_TXT].data = NULL;
+    virt_file[VIRT_TEXT_TXT].len = 0;
+}

tests/CMakeLists.txt

@@ -0,0 +1,40 @@
+find_package(GTest REQUIRED)
+
+# Third Party
+include_directories(${GTEST_INCLUDE_DIR})
+
+link_directories(${GTEST_LIB_DIR})
+
+# tests
+file(GLOB_RECURSE TEST_SOURCES "*.cpp" "*.c")
+add_executable(tests)
+
+target_compile_definitions(tests
+    PRIVATE
+    "TESTING"
+)
+
+target_sources(tests
+    PRIVATE
+    ${TEST_SOURCES}
+    ../project/Core/Src/tftp.c
+)
+
+target_compile_options(tests PRIVATE $<$<CONFIG:Debug>:
+    -Wall -Wextra -pedantic-errors -Wconversion -Wsign-conversion
+    >)
+target_link_libraries(tests
+    PRIVATE
+    gtest
+    GTest::gtest_main
+)
+
+target_include_directories(tests
+    PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+    ${PROJECT_BINARY_DIR}
+    ../project/Core/Inc/
+)
+
+include(GoogleTest)
+gtest_discover_tests(tests)

tests/mocs.c

@@ -0,0 +1,31 @@
+#include "tftp.h"
+
+struct llfs_data_file llfs_root = {
+    .data = NULL,
+    .len = 0,
+    .name = "root",
+    .next = NULL,
+};
+
+void tftp_cleanup(void) {
+
+}
+uint32_t logger_get_timestamp(void) {
+    return 0;
+}
+
+int tftp_init(struct tftp_context* context) {
+    return 0;
+}
+
+void lcd_display_text(uint8_t* text, uint16_t x_pos, uint16_t y_pos, uint32_t color, uint32_t bg_color, sFONT *font) {
+    
+}
+
+void lcd_clear(uint32_t color) {
+    
+}
+
+void lcd_draw_bmp_img(uint8_t* bmp_buff, uint32_t x_pos, uint32_t y_pos) {
+    
+}

tests/tfpt_tests.cpp

@@ -0,0 +1,76 @@
+#include <gtest/gtest.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "tftp.h"
+
+tftp_custom_file_t file = {
+        .data = (char*)"1234567890",
+        .len = 11,
+        .name = (char*)"test.txt",
+        .ofset = 0
+    };
+tftp_custom_file_t write_file = {
+        .data = NULL,
+        .len = 0,
+        .name = (char*)"test.txt",
+        .ofset = 0
+    };
+
+TEST(TFTP, custom_fseek)
+{    
+    tftp_custom_fseek(&file, 5, SEEK_SET);
+    EXPECT_EQ(file.ofset, 5);
+    tftp_custom_fseek(&file, 5, SEEK_CUR);
+    EXPECT_EQ(file.ofset, 10);
+}
+
+TEST(TFTP, custom_fread)
+{
+    char buf[11];
+    tftp_custom_fseek(&file, 0, SEEK_SET);
+    size_t bytes = tftp_custom_fread(buf, 11, &file);
+    EXPECT_EQ(bytes, 11);
+    EXPECT_EQ(file.ofset, 11);
+    EXPECT_EQ(memcmp(buf, "1234567890", 10), 0);
+
+    memset(buf, 0, 11);
+
+    tftp_custom_fseek(&file, 0, SEEK_SET);
+    bytes = tftp_custom_fread(buf, 11, &file);
+    EXPECT_EQ(bytes, 11);
+    EXPECT_EQ(memcmp(buf, "1234567890", 10), 0);
+
+    memset(buf, 0, 11);
+
+    tftp_custom_fseek(&file, 0, SEEK_SET);
+    bytes = tftp_custom_fread(buf, 5, &file);
+    EXPECT_EQ(bytes, 5);
+    EXPECT_EQ(memcmp(buf, "12345", 5), 0);
+
+    memset(buf, 0, 11);
+
+    bytes = tftp_custom_fread(buf, 5, &file);
+    EXPECT_EQ(bytes, 5);
+    EXPECT_EQ(memcmp(buf, "67890", 5), 0);
+}
+
+TEST(TFTP, custom_fwrite) {
+    write_file.data = (char*)malloc(21 * sizeof(char));
+    write_file.len = 21;
+    tftp_custom_fwrite("0987654321", 10, &write_file);
+    EXPECT_EQ(write_file.ofset, 10);
+    EXPECT_EQ(write_file.len, 21);
+    EXPECT_EQ(memcmp(write_file.data, "0987654321", 10), 0);
+
+    tftp_custom_fwrite("1234567890", 10, &write_file);
+    EXPECT_EQ(write_file.ofset, 20);
+    EXPECT_EQ(write_file.len, 21);
+    EXPECT_EQ(memcmp(write_file.data, "09876543211234567890", 20), 0);
+
+    free(write_file.data);
+    write_file.data = NULL;
+    write_file.len = 0;
+}

tests/tftp_server.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <stdint.h>
+
+struct pbuf {
+  struct pbuf *next;
+  void *payload;
+  uint16_t tot_len;
+  uint16_t len;
+  uint8_t type_internal;
+  uint8_t flags;
+  //LWIP_PBUF_REF_T ref;
+
+  uint8_t if_idx;
+};
+typedef void sFONT;
+
+#define ERR_OK 0
+#define LCD_COLOR_BLACK 0
+#define LCD_COLOR_WHITE 1
+
+#define LCD_FONT16 0
+
+struct tftp_context {
+  void* (*open)(const char* fname, const char* mode, uint8_t write);
+  void (*close)(void* handle);
+  int (*read)(void* handle, void* buf, int bytes);
+  int (*write)(void* handle, struct pbuf* p);
+};
+
+void tftp_cleanup(void);
+uint32_t logger_get_timestamp(void);
+int tftp_init(struct tftp_context* context);
+void lcd_display_text(uint8_t* text, uint16_t x_pos, uint16_t y_pos, uint32_t color, uint32_t bg_color, sFONT *font);
+void lcd_draw_bmp_img(uint8_t* bmp_buff, uint32_t x_pos, uint32_t y_pos);
+void lcd_clear(uint32_t color);
+
+#ifdef __cplusplus
+}
+#endif