I have some trouble with golang syscall when calling dll in win7-64

Here my code:

package main

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

var (
    WinSCard, _                  = syscall.LoadLibrary("C:\\windows\\system32\\WinSCard.dll")
    procSCardListReaders, _      = syscall.GetProcAddress(WinSCard, "SCardListReaders")
    procSCardEstablishContext, _ = syscall.GetProcAddress(WinSCard, "SCardEstablishContext")
)

func abort(funcname string, err error) {
    panic(fmt.Sprintf("%s failed: %v", funcname, err))
}

func SCardEstablishContext(dwScope uint32, pvReserved1 *uint32, pvReserved2 *uint32, phContext uintptr) int32 {
    ret, _, callErr := syscall.Syscall6(uintptr(procSCardEstablishContext),
        4,
        uintptr(unsafe.Pointer(&dwScope)),
        uintptr(unsafe.Pointer(pvReserved1)),
        uintptr(unsafe.Pointer(pvReserved2)),
        phContext,
        0,
        0)
    if callErr != 0 {
        abort("Err:", callErr)
    }
    return int32(ret)
}

func main() {
    var Hwd uintptr
    defer syscall.FreeLibrary(WinSCard)
    rt := SCardEstablishContext(0, nil, nil, Hwd)
    fmt.Println(rt)
}

Return -2146435068 means 0x80100004 means SCARD_E_INVALID_PARAMETER. One or more of the supplied parameters could not be properly interpreted.

The func SCardEstablishContext:

LONG WINAPI SCardEstablishContext(
    _In_   DWORD dwScope,
    _In_   LPCVOID pvReserved1,
    _In_   LPCVOID pvReserved2,
    _Out_  LPSCARDCONTEXT phContext
)

What's wrong with my parameters? Thx a lot!!

How about

func SCardListReaders(hContext *syscall.Handle, mszGroups string, mszReaders *byte, pcchReaders *uint32) (err error) {
r1, _, e1 := syscall.Syscall6(
    uintptr(procSCardListReaders),
    4,
    uintptr(unsafe.Pointer(hContext)),
    uintptr(unsafe.Pointer(syscall.StringBytePtr(mszGroups))),
    uintptr(unsafe.Pointer(mszReaders)),
    uintptr(unsafe.Pointer(pcchReaders)),
    0,
    0,
)
if r1 != 0 {
    if e1 != 0 {
        err = error(e1)
    } else {
        err = syscall.EINVAL
    }
}
return
}

var Groups string
var Readers byte
var pcchReaders uint32
er1 := SCardListReaders(&context, Groups, &Readers, &pcchReaders)
if er1 != nil {
    fmt.Println("SCardListReaders:", er1)
    return
}

return: invalid argument

For example,

package main

import (
    "fmt"
    "syscall"
    "unicode/utf16"
    "unsafe"
)

var (
    WinSCard, _                  = syscall.LoadLibrary(`C:\windows\system32\WinSCard.dll`)
    procSCardEstablishContext, _ = syscall.GetProcAddress(WinSCard, "SCardEstablishContext")
    procSCardReleaseContext, _   = syscall.GetProcAddress(WinSCard, "SCardReleaseContext")
    procSCardListReaders, _      = syscall.GetProcAddress(WinSCard, "SCardListReadersW")
)

const (
    SCARD_SCOPE_USER   = 0
    SCARD_SCOPE_SYSTEM = 2

    SCARD_ALL_READERS     = "SCard$AllReaders"
    SCARD_DEFAULT_READERS = "SCard$DefaultReaders"
)

func SCardListReaders(hContext syscall.Handle, mszGroups *uint16, mszReaders *uint16, pcchReaders *uint32) (retval error) {
    r0, _, _ := syscall.Syscall6(
        uintptr(procSCardListReaders),
        4,
        uintptr(hContext),
        uintptr(unsafe.Pointer(mszGroups)),
        uintptr(unsafe.Pointer(mszReaders)),
        uintptr(unsafe.Pointer(pcchReaders)),
        0,
        0,
    )
    if r0 != 0 {
        retval = syscall.Errno(r0)
    }
    return
}

func SCardReleaseContext(hContext syscall.Handle) (retval error) {
    r0, _, _ := syscall.Syscall(
        uintptr(procSCardReleaseContext),
        1,
        uintptr(hContext),
        0,
        0,
    )
    if r0 != 0 {
        retval = syscall.Errno(r0)
    }
    return
}

func SCardEstablishContext(dwScope uint32, pvReserved1 uintptr, pvReserved2 uintptr, phContext *syscall.Handle) (retval error) {
    r0, _, _ := syscall.Syscall6(
        uintptr(procSCardEstablishContext),
        4,
        uintptr(dwScope),
        uintptr(pvReserved1),
        uintptr(pvReserved2),
        uintptr(unsafe.Pointer(phContext)),
        0,
        0,
    )
    if r0 != 0 {
        retval = syscall.Errno(r0)
    }
    return
}

func ReturnValue(err error) uint32 {
    rv, ok := err.(syscall.Errno)
    if !ok {
        rv = 0
    }
    return uint32(rv)
}

func UTF16ToStrings(ls []uint16) []string {
    var ss []string
    if len(ls) == 0 {
        return ss
    }
    if ls[len(ls)-1] != 0 {
        ls = append(ls, 0)
    }
    i := 0
    for j, cu := range ls {
        if cu == 0 {
            if j >= 1 && ls[j-1] == 0 {
                break
            }
            if j-i > 0 {
                ss = append(ss, string(utf16.Decode(ls[i:j])))
            }
            i = j + 1
            continue
        }
    }
    return ss
}

func main() {
    var (
        context  syscall.Handle
        scope    uint32
        groups   *uint16
        cReaders uint32
    )

    context = 0
    groups, err := syscall.UTF16PtrFromString(SCARD_ALL_READERS)
    if err != nil {
        fmt.Println("Reader Group: ", err)
        return
    }
    err = SCardListReaders(context, groups, nil, &cReaders)
    if err != nil {
        fmt.Printf("SCardListReaders: 0x%X %s\n", ReturnValue(err), err)
        return
    }
    r := make([]uint16, cReaders)
    err = SCardListReaders(context, groups, &r[0], &cReaders)
    if err != nil {
        fmt.Printf("SCardListReaders: 0x%X %s\n", ReturnValue(err), err)
        return
    }
    readers := UTF16ToStrings(r[:cReaders])
    fmt.Println("Readers:", len(readers), readers)

    scope = SCARD_SCOPE_SYSTEM
    err = SCardEstablishContext(scope, 0, 0, &context)
    if err != nil {
        fmt.Printf("SCardEstablishContext: 0x%X %s\n", ReturnValue(err), err)
        return
    }
    defer SCardReleaseContext(context)
    fmt.Printf("Context: %X\n", context)
}

Output:

Computer 1:

Readers: 1 [O2 O2Micro CCID SC Reader 0]
Context: CD00000100000000

Computer 2:

Readers: 0 []
SCardEstablishContext: 0x8010001D The Smart card resource manager is not running.

Also, note the fix for the procSCardListReaders ProcName:

procSCardListReaders, _ = syscall.GetProcAddress(WinSCard, "SCardListReadersW")