How do I pass a void pointer pointer to a Windows DLL in Golang (void**)

Question

I'm trying to experiment with getting the ChakraCore.dll to load on Windows with Golang but I'm having trouble figuring out what parameter type I need to pass in as the third parameter.

My assumption from reading the library code and loosely following the Embedding ChakraCore is that the third parameter needs to be a void pointer pointer (void**) as the header files define JsRuntimeHandle as typedef void *JsRuntimeHandle;

I'm hoping to avoid CGo if possible as well.

Console output:

panic: JsCreateRuntime failed: An argument to a hosting API was null in a context where null is not allowed. (JsErrorNullArgument)

Code:

package main

import (
    "fmt"
    "syscall"
    "unsafe"
)

var (
    chakraCore, _        = syscall.LoadLibrary("ChakraCore.dll")
    jsCreateRuntime, _ = syscall.GetProcAddress(chakraCore, "JsCreateRuntime")
)

const (
    JsNoError = 0
    JsErrorNullArgument = 0x10002
)

const (
    JsRuntimeAttributeNone = 0x00000000
)

func main() {
    const functionName = "JsCreateRuntime"
    var runtime uintptr
    ret, _, err := syscall.Syscall(
       uintptr(jsCreateRuntime),
       3,
       uintptr(JsRuntimeAttributeNone),
       uintptr(0),
       uintptr(unsafe.Pointer(runtime)),
    )
    if err != 0 {
        panic(fmt.Sprintf("%s failed: %v", functionName, err))
    }
    switch (ret) {
    case JsNoError:
        break
    case JsErrorNullArgument:
        panic(fmt.Sprintf("%s failed: An argument to a hosting API was null in a context where null is not allowed. (JsErrorNullArgument)", functionName))
    default:
        panic(fmt.Sprintf("%s failed: Unhandled error kind (%v).", functionName, ret))
    }
    panic(fmt.Sprintf("runtime: %v | ret: %v\n", runtime, uint(ret)))
    return
}

Answer 1

I might have gotten something wrong here, but when I just ignore the error that Windows is giving me and keep going, everything seems to execute fine.

For example, if I run this:

package main

import (
    "errors"
    "fmt"
    "syscall"
    "unsafe"
)

var (
    chakraCore, _        = syscall.LoadLibrary("ChakraCore.dll")
    jsCreateRuntime, _ = syscall.GetProcAddress(chakraCore, "JsCreateRuntime")
    jsCreateContext, _ = syscall.GetProcAddress(chakraCore, "JsCreateContext")
    jsSetCurrentContext, _ = syscall.GetProcAddress(chakraCore, "JsSetCurrentContext")
    jsRunScript, _ = syscall.GetProcAddress(chakraCore, "JsRunScript")
    jsConvertValueToString, _ = syscall.GetProcAddress(chakraCore, "JsConvertValueToString")
    jsStringToPointer, _ = syscall.GetProcAddress(chakraCore, "JsStringToPointer")
)

const (
    JsNoError = 0
    JsErrorInvalidArgument = 0x10001
    JsErrorNullArgument = 0x10002

    JsErrorScriptCompile = 0x30002
)

const (
    JsRuntimeAttributeNone = 0x00000000
)

var jsExample = `
(()=>{
    return 'Hello world!';}
)()
`

func main() {
    var runtime unsafe.Pointer
    var context unsafe.Pointer
    var jsResult unsafe.Pointer
    var resultJSString unsafe.Pointer
    {
        const functionName = "JsCreateRuntime"
        ret, _, err := syscall.Syscall(
           uintptr(jsCreateRuntime),
           3,
           uintptr(JsRuntimeAttributeNone),
           uintptr(0),
           uintptr(unsafe.Pointer(&runtime)),
        )
        // NOTE: Skip this error as it seems to be a false positive
        //if err != 0 {
        //  panic(fmt.Sprintf("%s invalid DLL call: %v", functionName, err))
        //}
        if err := getJSError(ret); err != nil {
            panic(fmt.Sprintf("%s failed: %s", functionName, err))
        }
        if runtime == nil {
            panic("Runtime should not be 0. I think.")
        }
        fmt.Print(fmt.Sprintf("%s: runtime: %v | error code: %v | dll call error: %v\n", functionName, runtime, ret, err))
    }
    {
        const functionName = "JsCreateContext"
        ret, _, err := syscall.Syscall(
            uintptr(jsCreateContext),
            2,
            uintptr(runtime),
            uintptr(unsafe.Pointer(&context)),
            uintptr(0),
        )
        if err := getJSError(ret); err != nil {
            panic(fmt.Sprintf("%s failed: %s", functionName, err))
        }
        fmt.Print(fmt.Sprintf("%s: context: %v | error code: %v | dll call error: %v\n", functionName, context, ret, err))
    }
    {
        const functionName = "JsSetCurrentContext"
        ret, _, err := syscall.Syscall(
            uintptr(jsSetCurrentContext),
            1,
            uintptr(context),
            uintptr(0),
            uintptr(0),
        )
        if err := getJSError(ret); err != nil {
            panic(fmt.Sprintf("%s failed: %s", functionName, err))
        }
        fmt.Print(fmt.Sprintf("%s: error code: %v | dll call error: %v\n", functionName, ret, err))
    }
    {
        const functionName = "JsRunScript"
        context := 1
        str, err := syscall.UTF16PtrFromString(jsExample)
        if err != nil {
            panic(err)
        }
        url, err := syscall.UTF16PtrFromString("")
        if err != nil {
            panic(err)
        }
        ret, _, err := syscall.Syscall6(
            uintptr(jsRunScript),
            4,
            uintptr(unsafe.Pointer(str)),
            uintptr(context),
            uintptr(unsafe.Pointer(url)),
            uintptr(unsafe.Pointer(&jsResult)),
            uintptr(0),
            uintptr(0),
        )
        if err := getJSError(ret); err != nil {
            panic(fmt.Sprintf("%s failed: %s", functionName, err))
        }
        fmt.Print(fmt.Sprintf("%s: js result: %v | error code: %v | dll call error: %v\n", functionName, jsResult, ret, err))
    }
    {
        const functionName = "JsConvertValueToString"
        ret, _, err := syscall.Syscall(
            uintptr(jsConvertValueToString),
            2,
            uintptr(jsResult),
            uintptr(unsafe.Pointer(&resultJSString)),
            uintptr(0),
        )
        if err := getJSError(ret); err != nil {
            panic(fmt.Sprintf("%s failed: %s", functionName, err))
        }
        fmt.Print(fmt.Sprintf("%s: js convert val to string: %v | error code: %v | dll call error: %v\n", functionName, resultJSString, ret, err))
    }
    {
        const functionName = "JsStringToPointer"
        var utf16StringData *[0xffff]uint16
        var stringLen uintptr
        ret, _, err := syscall.Syscall(
            uintptr(jsStringToPointer),
            3,
            uintptr(resultJSString),
            uintptr(unsafe.Pointer(&utf16StringData)),
            uintptr(unsafe.Pointer(&stringLen)),
        )
        if err := getJSError(ret); err != nil {
            panic(fmt.Sprintf("%s failed: %s", functionName, err))
        }
        cStrData := syscall.UTF16ToString(utf16StringData[0 : stringLen])
        fmt.Print(fmt.Sprintf("%s: js string: %s (len: %v) | error code: %v | dll call error: %v\n", functionName, cStrData, stringLen, ret, err))
    }
    return
}

func getJSError(errorCode uintptr) error {
    switch (errorCode) {
    case JsNoError:
        return nil
    case JsErrorInvalidArgument:
        return errors.New("An argument to a hosting API was invalid. (JsErrorInvalidArgument)")
    case JsErrorNullArgument:
        return errors.New("An argument to a hosting API was null in a context where null is not allowed. (JsErrorNullArgument)")
    case JsErrorScriptCompile:
        return errors.New("JavaScript failed to compile. (JsErrorScriptCompile)")
    default:
       return fmt.Errorf("Unhandled error kind (%v).", errorCode)
    }
}

I get the following output in console:

JsCreateRuntime: runtime: 0x3bd3310 | error code: 0 | dll call error: The parameter is incorrect.

JsCreateContext: context: 0x3ce2000 | error code: 0 | dll call error: The operation completed successfully.

JsSetCurrentContext: error code: 0 | dll call error: The operation completed successfully.

JsRunScript: js result: 0x3d00ac0 | error code: 0 | dll call error: The operation completed successfully.

JsConvertValueToString: js convert val to string: 0x3d00ac0 | error code: 0 | dll call error: The operation completed successfully.

JsStringToPointer: js string: Hello world! (len: 12) | error code: 0 | dll call error: The operation completed successfully.