Add breakwater-parser C bindings

Author: sbernauer

Cargo.lock

@@ -1,5 +1,10 @@
 [workspace]
-members = ["breakwater-parser", "breakwater", "breakwater-egui-overlay"]
+members = [
+    "breakwater-parser",
+    "breakwater",
+    "breakwater-egui-overlay",
+    "breakwater-parser-c-bindings"
+]
 resolver = "2"
 
 [workspace.package]

Cargo.toml

@@ -16,6 +16,8 @@ CFLAGS += -O3 -g -gdwarf-2 $(shell $(PKGCONF) --cflags libdpdk)
 LIBS+= $(shell $(PKGCONF) --static --libs libdpdk)
 LIBS+= -I${FF_PATH}/lib -L${FF_PATH}/lib -Wl,--whole-archive,-lfstack,--no-whole-archive
 LIBS+= -Wl,--no-whole-archive -lrt -lm -ldl -lcrypto -pthread -lnuma
+# WIP, start with "sudo LD_LIBRARY_PATH=../target/release build/breakwater-f-stack"
+LIBS += -l breakwater_parser_c_bindings -L ../target/release/
 
 TARGET="breakwater-f-stack"
 all:

breakwater-f-stack/Makefile

@@ -18,6 +18,9 @@
 #include "framebuffer.h"
 #include "parser.h"
 
+extern void breakwater_init_original_parser(int width, int height);
+extern size_t breakwater_original_parser_parse(const char* buffer, size_t buffer_len);
+
 #define MAX_EVENTS 512
 
 /* kevent set */
@@ -160,7 +163,9 @@ int loop(void *arg)
             ssize_t readlen = ff_read(clientfd, buf, sizeof(buf));
             client->bytes_parsed += readlen;
 
-            size_t bytes_parsed = parse(buf, readlen, framebuffer, clientfd);
+            // size_t bytes_parsed = parse(buf, readlen, framebuffer, clientfd);
+            long parsed = breakwater_original_parser_parse(buf, readlen);
+            printf("Parse result: %ld\n", parsed);
         } else {
             printf("unknown event: %8.8X\n", event.flags);
         }
@@ -173,6 +178,8 @@ int main(int argc, char * argv[])
 {
     int err = 0;
 
+    breakwater_init_original_parser(WIDTH, HEIGHT);
+
     struct framebuffer* framebuffer;
     if((err = create_fb(&framebuffer, WIDTH, HEIGHT, SHARED_MEMORY_NAME))) {
 		fprintf(stderr, "Failed to allocate framebuffer: %s\n", strerror(err));

breakwater-f-stack/breakwater-f-stack.c

@@ -0,0 +1,16 @@
+[package]
+name = "breakwater-parser-c-bindings"
+description = "Pixelflut parser C bindings"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+breakwater-parser.workspace = true
+
+libc = "0.2"

breakwater-parser-c-bindings/Cargo.toml

@@ -0,0 +1,57 @@
+use core::str;
+use std::{
+    ffi::c_int,
+    slice,
+    sync::{Arc, Mutex, OnceLock},
+};
+
+use breakwater_parser::{OriginalParser, Parser, SimpleFrameBuffer};
+use libc::size_t;
+
+static ORIGINAL_PARSER: OnceLock<Mutex<OriginalParser<SimpleFrameBuffer>>> = OnceLock::new();
+
+#[unsafe(no_mangle)]
+pub extern "C" fn breakwater_init_original_parser(width: c_int, height: c_int) {
+    ORIGINAL_PARSER.get_or_init(|| {
+        // let fb = Arc::new(NoopFrameBuffer::new(
+        //     width.try_into().unwrap(),
+        //     height.try_into().unwrap(),
+        // ));
+        let fb = Arc::new(SimpleFrameBuffer::new(
+            width.try_into().unwrap(),
+            height.try_into().unwrap(),
+        ));
+
+        Mutex::new(OriginalParser::new(fb))
+    });
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn breakwater_original_parser_parser_lookahead() -> size_t {
+    let parser = ORIGINAL_PARSER
+        .get()
+        .expect("Call breakwater_init_original_parser first!");
+
+    parser
+        .lock()
+        .unwrap()
+        .parser_lookahead()
+        .try_into()
+        .unwrap()
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn breakwater_original_parser_parse(buffer: *mut u8, buffer_len: size_t) -> size_t {
+    let parser = ORIGINAL_PARSER
+        .get()
+        .expect("Call breakwater_init_original_parser first!");
+
+    let buffer = unsafe { slice::from_raw_parts(buffer, buffer_len.try_into().unwrap()) };
+
+    // FIXME: Somehow return the response to the C side
+    let mut response = Vec::new();
+    let parsed = { parser.lock().unwrap().parse(buffer, &mut response) };
+    dbg!(str::from_utf8(&response).unwrap());
+
+    parsed.try_into().unwrap()
+}

breakwater-parser-c-bindings/src/lib.rs

@@ -0,0 +1,6 @@
+cd ../..
+cargo build --release -p breakwater-parser-c-bindings
+cd -
+gcc test.c -o test -l breakwater_parser_c_bindings -L../../target/release
+
+LD_LIBRARY_PATH=../../target/release ./test

breakwater-parser-c-bindings/test-from-c/run.sh

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern void breakwater_init_original_parser(int width, int height);
+extern size_t breakwater_original_parser_parser_lookahead();
+extern size_t breakwater_original_parser_parse(const char* buffer, size_t buffer_len);
+
+int main(void) {
+    breakwater_init_original_parser(1920, 1080);
+    size_t parser_lookahead = breakwater_original_parser_parser_lookahead();
+    printf("Parser lookahead: %ld\n", parser_lookahead);
+
+    const char* text = 
+    "PX 0 0 123456\n"
+    "PX 0 1 111111\n"
+    "PX 0 2 222222\n"
+    "PX 0 3 333333\n"
+    "PX 0 4 444444\n"
+    "PX 0 5 555555\n"
+    "PX 0 6 666666\n"
+    "PX 0 7 777777\n"
+    "PX 0 8 888888\n"
+    "PX 0 9 999999\n"
+    "PX 0 0\n"
+    "PX 0 1\n"
+    "PX 0 2\n"
+    "PX 0 3\n"
+    "PX 0 4\n"
+    "PX 0 5\n"
+    "PX 0 6\n"
+    "PX 0 7\n";
+
+    size_t text_len = strlen(text);
+    size_t buffer_len = text_len + parser_lookahead;
+    unsigned char* buffer = malloc(buffer_len);
+    if (!buffer) {
+        perror("malloc failed");
+        return 1;
+    }
+    memcpy(buffer, text, text_len);
+
+    long parsed = breakwater_original_parser_parse(buffer, buffer_len);
+    printf("Parse result: %ld\n", parsed);
+
+    free(buffer);
+    return 0;
+}