Initial commit.

Author: andreiavrammsd

.gitignore

@@ -0,0 +1,4 @@
+.idea
+*.so
+*.o
+app

Dockerfile

@@ -0,0 +1,17 @@
+FROM ubuntu:18.04
+
+ARG GO=1.13.4
+
+RUN apt update && apt upgrade -y
+RUN apt install -y wget make gcc
+
+WORKDIR /tmp
+RUN wget https://dl.google.com/go/go${GO}.linux-amd64.tar.gz
+RUN tar -xvf go${GO}.linux-amd64.tar.gz
+RUN mv go /usr/local
+
+RUN echo export GOROOT=/usr/local/go >> ~/.bashrc
+RUN echo export GOPATH=\$HOME/go >> ~/.bashrc
+RUN echo export PATH=\$GOPATH/bin:\$GOROOT/bin:\$PATH >> ~/.bashrc
+
+WORKDIR /src

Makefile

@@ -0,0 +1,19 @@
+.PHONY: all c go run env
+
+TESTLIBPATH="./ctestlib"
+
+all: c go run
+
+env:
+	docker build --tag cgo .
+	docker run --rm -ti -v $(shell pwd):/src cgo
+
+c:
+	gcc -c -Wall -Werror -fpic -o ${TESTLIBPATH}/test.o ${TESTLIBPATH}/test.c
+	gcc -shared -o ${TESTLIBPATH}/libtest.so ${TESTLIBPATH}/test.o
+
+go:
+	go build -o app *.go
+
+run:
+	./app

README.md

@@ -0,0 +1,22 @@
+# CGO Examples
+
+Examples of calling C code from Go (including a test C library). Passing and getting numbers, strings, enums, structs, callbacks.
+
+### Build and run Docker env
+```bash
+make env
+```
+
+### Compile and run app
+```bash
+make
+```
+
+See [Makefile](Makefile)
+
+### Docs
+* https://golang.org/cmd/cgo/
+* https://blog.golang.org/c-go-cgo
+* https://github.com/golang/go/wiki/cgo
+* https://gist.github.com/zchee/b9c99695463d8902cd33
+* https://dev.to/mattn/call-go-function-from-c-function-1n3

ctestlib/test.c

@@ -0,0 +1,46 @@
+#include "test.h"
+
+int sum(int a, int b) {
+	return a + b;
+}
+
+const char* get_string() {
+	return "string sent from C";
+}
+
+void print_string(char* a) {
+	printf("string sent from Go: %s\n", a);
+}
+
+void print_buffer(unsigned char *buf, size_t size) {
+	for (uint i = 0; i < size; i++) {
+		printf("%X", buf[i]);
+	}
+	printf("\n");
+}
+
+int point_diff(point p) {
+	return p.x - p.y;
+}
+
+void pass_void_pointer(void *ptr) {
+    printf("%d\n", *((int*)ptr));
+}
+
+void generate_numbers(uint num, uint callback) {
+	void evenNumberCallbackProxy(uint, int);
+
+	for (uint i = 0; i <= num; i++) {
+		if (i % 2 == 0) {
+			evenNumberCallbackProxy(callback, i);
+		}
+	}
+}
+
+void user_action(uint callback) {
+	void userCallbackProxy(uint);
+
+	for (int i = 0; i < 5; i++) {
+		userCallbackProxy(callback);
+	}
+}

ctestlib/test.h

@@ -0,0 +1,34 @@
+#ifndef _TESTLIB_H_
+#define _TESTLIB_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct point
+{
+	int x;
+	int y;
+} point;
+
+enum status {
+    PENDING,
+    DONE,
+};
+
+int sum(int a, int b);
+
+const char* get_string();
+
+void print_string(char* a);
+
+void print_buffer(unsigned char *buf, size_t size);
+
+int point_diff(point p);
+
+void pass_void_pointer(void *ptr);
+
+void generate_numbers(uint num, uint callback);
+
+void user_action(uint callback);
+
+#endif

main.go

@@ -0,0 +1,104 @@
+package main
+
+/*
+#cgo CFLAGS: -I${SRCDIR}/ctestlib
+#cgo LDFLAGS: -Wl,-rpath,${SRCDIR}/ctestlib
+#cgo LDFLAGS: -L${SRCDIR}/ctestlib
+#cgo LDFLAGS: -ltest
+
+#include <test.h>
+*/
+import "C"
+import (
+	"bytes"
+	"fmt"
+	"unsafe"
+)
+
+type User struct {
+	Username string
+	Visits   int
+}
+
+type Status int
+
+const (
+	Pending Status = iota
+	Done
+)
+
+func evenNumberCallback(num int) {
+	fmt.Println("odd number: ", num)
+}
+
+func userCallback(user unsafe.Pointer) {
+	u := (*User)(unsafe.Pointer(user))
+	u.Visits++
+}
+
+func main() {
+	// Numbers
+	fmt.Println("\nNumbers")
+
+	a := 1
+	b := 2
+	sum := int(C.sum(C.int(a), C.int(b)))
+	fmt.Print(sum, "\n\n")
+
+	// Get string
+	fmt.Println("Get string")
+	getString := C.GoString(C.get_string())
+	fmt.Println(getString)
+	stringBytes := C.GoBytes(unsafe.Pointer(C.get_string()), 24)
+	fmt.Println(stringBytes[0:bytes.Index(stringBytes, []byte{0})])
+	fmt.Println()
+
+	// Send string
+	fmt.Println("Send string")
+	str := "lorem ipsum"
+	cStr := C.CString(str)
+	C.print_string(cStr)
+	C.free(unsafe.Pointer(cStr))
+	fmt.Println()
+
+	// Send bytes
+	fmt.Println("Send byte array")
+	data := []byte{1, 4, 2}
+	cBytes := (*C.uchar)(unsafe.Pointer(&data[0]))
+	cBytesLength := C.size_t(len(data))
+	fmt.Print("bytes: ")
+	C.print_buffer(cBytes, cBytesLength)
+	fmt.Println()
+
+	// Struct
+	fmt.Println("Get and pass struct")
+	point := C.struct_point{}
+	point.x = 0
+	point.y = 2
+	fmt.Println(point)
+	fmt.Print(C.point_diff(point), "\n\n")
+
+	// Arbitrary data: unsafe.Pointer to void pointer
+	fmt.Println("Pass void pointer")
+	C.pass_void_pointer(unsafe.Pointer(&point.y))
+	fmt.Println()
+
+	// Enum
+	fmt.Println("Access enum")
+	fmt.Print(C.enum_status(Pending) == C.PENDING, C.PENDING, C.DONE, "\n\n")
+
+	// Callback
+	fmt.Println("Pass callback")
+	c := registerCallback(evenNumberCallback, nil)
+	C.generate_numbers(5, c)
+	unregisterCallback(c)
+
+	// Callback with params
+	user := User{
+		Username: "johndoe",
+	}
+	cWithParams := registerCallback(userCallback, unsafe.Pointer(&user))
+	C.user_action(cWithParams)
+	unregisterCallback(cWithParams)
+	fmt.Println(user)
+}

proxy.go

@@ -0,0 +1,57 @@
+package main
+
+import "C"
+import (
+	"sync"
+	"unsafe"
+)
+
+type (
+	index    uint8
+	store    map[index]interface{}
+	callback struct {
+		callback interface{}
+		arg      unsafe.Pointer
+	}
+)
+
+var (
+	storage = make(store)
+	mutex   sync.Mutex
+)
+
+//export evenNumberCallbackProxy
+func evenNumberCallbackProxy(i C.uint, num int) {
+	c := getCallback(index(i))
+	c.callback.(func(int))(num)
+}
+
+//export userCallbackProxy
+func userCallbackProxy(i C.uint) {
+	c := getCallback(index(i))
+	c.callback.(func(unsafe.Pointer))(c.arg)
+}
+
+func registerCallback(c interface{}, arg unsafe.Pointer) C.uint {
+	mutex.Lock()
+	i := index(len(storage))
+	storage[i] = &callback{
+		callback: c,
+		arg:      arg,
+	}
+	mutex.Unlock()
+
+	return C.uint(i)
+}
+
+func getCallback(i index) *callback {
+	mutex.Lock()
+	defer mutex.Unlock()
+	return storage[i].(*callback)
+}
+
+func unregisterCallback(i C.uint) {
+	mutex.Lock()
+	delete(storage, index(i))
+	mutex.Unlock()
+}