WsCreateServiceEndpointFromTemplate

// webservices.dll
#include <windows.h>

HRESULT WsCreateServiceEndpointFromTemplate(
    WS_CHANNEL_TYPE channelType,
    const WS_SERVICE_ENDPOINT_PROPERTY* properties,   // optional
    DWORD propertyCount,
    const WS_STRING* addressUrl,   // optional
    const WS_SERVICE_CONTRACT* contract,
    WS_SERVICE_SECURITY_CALLBACK authorizationCallback,   // optional
    WS_HEAP* heap,
    WS_BINDING_TEMPLATE_TYPE templateType,
    void* templateValue,   // optional
    DWORD templateSize,
    const void* templateDescription,
    DWORD templateDescriptionSize,
    WS_SERVICE_ENDPOINT** serviceEndpoint,
    WS_ERROR* error   // optional
);

<DllImport("webservices.dll", ExactSpelling:=True)>
Public Shared Function WsCreateServiceEndpointFromTemplate(
    channelType As Integer,   ' WS_CHANNEL_TYPE
    properties As IntPtr,   ' WS_SERVICE_ENDPOINT_PROPERTY* optional
    propertyCount As UInteger,   ' DWORD
    addressUrl As IntPtr,   ' WS_STRING* optional
    contract As IntPtr,   ' WS_SERVICE_CONTRACT*
    authorizationCallback As IntPtr,   ' WS_SERVICE_SECURITY_CALLBACK optional
    ByRef heap As IntPtr,   ' WS_HEAP*
    templateType As Integer,   ' WS_BINDING_TEMPLATE_TYPE
    templateValue As IntPtr,   ' void* optional
    templateSize As UInteger,   ' DWORD
    templateDescription As IntPtr,   ' void*
    templateDescriptionSize As UInteger,   ' DWORD
    serviceEndpoint As IntPtr,   ' WS_SERVICE_ENDPOINT** out
    [error] As IntPtr   ' WS_ERROR* optional
) As Integer
End Function

' channelType : WS_CHANNEL_TYPE
' properties : WS_SERVICE_ENDPOINT_PROPERTY* optional
' propertyCount : DWORD
' addressUrl : WS_STRING* optional
' contract : WS_SERVICE_CONTRACT*
' authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional
' heap : WS_HEAP*
' templateType : WS_BINDING_TEMPLATE_TYPE
' templateValue : void* optional
' templateSize : DWORD
' templateDescription : void*
' templateDescriptionSize : DWORD
' serviceEndpoint : WS_SERVICE_ENDPOINT** out
' error : WS_ERROR* optional
Declare PtrSafe Function WsCreateServiceEndpointFromTemplate Lib "webservices" ( _
    ByVal channelType As Long, _
    ByVal properties As LongPtr, _
    ByVal propertyCount As Long, _
    ByVal addressUrl As LongPtr, _
    ByVal contract As LongPtr, _
    ByVal authorizationCallback As LongPtr, _
    ByRef heap As LongPtr, _
    ByVal templateType As Long, _
    ByVal templateValue As LongPtr, _
    ByVal templateSize As Long, _
    ByVal templateDescription As LongPtr, _
    ByVal templateDescriptionSize As Long, _
    ByVal serviceEndpoint As LongPtr, _
    ByVal error As LongPtr) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。

import ctypes
from ctypes import wintypes

WsCreateServiceEndpointFromTemplate = ctypes.windll.webservices.WsCreateServiceEndpointFromTemplate
WsCreateServiceEndpointFromTemplate.restype = ctypes.c_int
WsCreateServiceEndpointFromTemplate.argtypes = [
    ctypes.c_int,  # channelType : WS_CHANNEL_TYPE
    ctypes.c_void_p,  # properties : WS_SERVICE_ENDPOINT_PROPERTY* optional
    wintypes.DWORD,  # propertyCount : DWORD
    ctypes.c_void_p,  # addressUrl : WS_STRING* optional
    ctypes.c_void_p,  # contract : WS_SERVICE_CONTRACT*
    ctypes.c_void_p,  # authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional
    ctypes.c_void_p,  # heap : WS_HEAP*
    ctypes.c_int,  # templateType : WS_BINDING_TEMPLATE_TYPE
    ctypes.POINTER(None),  # templateValue : void* optional
    wintypes.DWORD,  # templateSize : DWORD
    ctypes.POINTER(None),  # templateDescription : void*
    wintypes.DWORD,  # templateDescriptionSize : DWORD
    ctypes.c_void_p,  # serviceEndpoint : WS_SERVICE_ENDPOINT** out
    ctypes.c_void_p,  # error : WS_ERROR* optional
]

require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('webservices.dll')
WsCreateServiceEndpointFromTemplate = Fiddle::Function.new(
  lib['WsCreateServiceEndpointFromTemplate'],
  [
    Fiddle::TYPE_INT,  # channelType : WS_CHANNEL_TYPE
    Fiddle::TYPE_VOIDP,  # properties : WS_SERVICE_ENDPOINT_PROPERTY* optional
    -Fiddle::TYPE_INT,  # propertyCount : DWORD
    Fiddle::TYPE_VOIDP,  # addressUrl : WS_STRING* optional
    Fiddle::TYPE_VOIDP,  # contract : WS_SERVICE_CONTRACT*
    Fiddle::TYPE_VOIDP,  # authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional
    Fiddle::TYPE_VOIDP,  # heap : WS_HEAP*
    Fiddle::TYPE_INT,  # templateType : WS_BINDING_TEMPLATE_TYPE
    Fiddle::TYPE_VOIDP,  # templateValue : void* optional
    -Fiddle::TYPE_INT,  # templateSize : DWORD
    Fiddle::TYPE_VOIDP,  # templateDescription : void*
    -Fiddle::TYPE_INT,  # templateDescriptionSize : DWORD
    Fiddle::TYPE_VOIDP,  # serviceEndpoint : WS_SERVICE_ENDPOINT** out
    Fiddle::TYPE_VOIDP,  # error : WS_ERROR* optional
  ],
  Fiddle::TYPE_INT)

#[link(name = "webservices")]
extern "system" {
    fn WsCreateServiceEndpointFromTemplate(
        channelType: i32,  // WS_CHANNEL_TYPE
        properties: *const WS_SERVICE_ENDPOINT_PROPERTY,  // WS_SERVICE_ENDPOINT_PROPERTY* optional
        propertyCount: u32,  // DWORD
        addressUrl: *const WS_STRING,  // WS_STRING* optional
        contract: *const WS_SERVICE_CONTRACT,  // WS_SERVICE_CONTRACT*
        authorizationCallback: *const core::ffi::c_void,  // WS_SERVICE_SECURITY_CALLBACK optional
        heap: *mut isize,  // WS_HEAP*
        templateType: i32,  // WS_BINDING_TEMPLATE_TYPE
        templateValue: *mut (),  // void* optional
        templateSize: u32,  // DWORD
        templateDescription: *const (),  // void*
        templateDescriptionSize: u32,  // DWORD
        serviceEndpoint: *mut *mut WS_SERVICE_ENDPOINT,  // WS_SERVICE_ENDPOINT** out
        error: *mut isize  // WS_ERROR* optional
    ) -> i32;
}
// crates: windows-sys provides ready-made bindings for this API.

$sig = @"
[DllImport("webservices.dll")]
public static extern int WsCreateServiceEndpointFromTemplate(int channelType, IntPtr properties, uint propertyCount, IntPtr addressUrl, IntPtr contract, IntPtr authorizationCallback, ref IntPtr heap, int templateType, IntPtr templateValue, uint templateSize, IntPtr templateDescription, uint templateDescriptionSize, IntPtr serviceEndpoint, IntPtr error);
"@
$api = Add-Type -MemberDefinition $sig -Name 'webservices_WsCreateServiceEndpointFromTemplate' -Namespace Win32 -PassThru
# $api::WsCreateServiceEndpointFromTemplate(channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error)

#uselib "webservices.dll"
#func global WsCreateServiceEndpointFromTemplate "WsCreateServiceEndpointFromTemplate" sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr
; WsCreateServiceEndpointFromTemplate channelType, varptr(properties), propertyCount, varptr(addressUrl), varptr(contract), authorizationCallback, varptr(heap), templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, varptr(serviceEndpoint), varptr(error)   ; 戻り値は stat
; channelType : WS_CHANNEL_TYPE -> "sptr"
; properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> "sptr"
; propertyCount : DWORD -> "sptr"
; addressUrl : WS_STRING* optional -> "sptr"
; contract : WS_SERVICE_CONTRACT* -> "sptr"
; authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> "sptr"
; heap : WS_HEAP* -> "sptr"
; templateType : WS_BINDING_TEMPLATE_TYPE -> "sptr"
; templateValue : void* optional -> "sptr"
; templateSize : DWORD -> "sptr"
; templateDescription : void* -> "sptr"
; templateDescriptionSize : DWORD -> "sptr"
; serviceEndpoint : WS_SERVICE_ENDPOINT** out -> "sptr"
; error : WS_ERROR* optional -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。

import (
	"golang.org/x/sys/windows"
	"unsafe"
)

var (
	webservices = windows.NewLazySystemDLL("webservices.dll")
	procWsCreateServiceEndpointFromTemplate = webservices.NewProc("WsCreateServiceEndpointFromTemplate")
)

// channelType (WS_CHANNEL_TYPE), properties (WS_SERVICE_ENDPOINT_PROPERTY* optional), propertyCount (DWORD), addressUrl (WS_STRING* optional), contract (WS_SERVICE_CONTRACT*), authorizationCallback (WS_SERVICE_SECURITY_CALLBACK optional), heap (WS_HEAP*), templateType (WS_BINDING_TEMPLATE_TYPE), templateValue (void* optional), templateSize (DWORD), templateDescription (void*), templateDescriptionSize (DWORD), serviceEndpoint (WS_SERVICE_ENDPOINT** out), error (WS_ERROR* optional)
r1, _, err := procWsCreateServiceEndpointFromTemplate.Call(
	uintptr(channelType),
	uintptr(properties),
	uintptr(propertyCount),
	uintptr(addressUrl),
	uintptr(contract),
	uintptr(authorizationCallback),
	uintptr(heap),
	uintptr(templateType),
	uintptr(templateValue),
	uintptr(templateSize),
	uintptr(templateDescription),
	uintptr(templateDescriptionSize),
	uintptr(serviceEndpoint),
	uintptr(error),
)
_ = err  // syscall.Errno (valid when the call sets last-error)
_ = r1   // HRESULT

function WsCreateServiceEndpointFromTemplate(
  channelType: Integer;   // WS_CHANNEL_TYPE
  properties: Pointer;   // WS_SERVICE_ENDPOINT_PROPERTY* optional
  propertyCount: DWORD;   // DWORD
  addressUrl: Pointer;   // WS_STRING* optional
  contract: Pointer;   // WS_SERVICE_CONTRACT*
  authorizationCallback: Pointer;   // WS_SERVICE_SECURITY_CALLBACK optional
  heap: Pointer;   // WS_HEAP*
  templateType: Integer;   // WS_BINDING_TEMPLATE_TYPE
  templateValue: Pointer;   // void* optional
  templateSize: DWORD;   // DWORD
  templateDescription: Pointer;   // void*
  templateDescriptionSize: DWORD;   // DWORD
  serviceEndpoint: Pointer;   // WS_SERVICE_ENDPOINT** out
  error: Pointer   // WS_ERROR* optional
): Integer; stdcall;
  external 'webservices.dll' name 'WsCreateServiceEndpointFromTemplate';

result := DllCall("webservices\WsCreateServiceEndpointFromTemplate"
    , "Int", channelType   ; WS_CHANNEL_TYPE
    , "Ptr", properties   ; WS_SERVICE_ENDPOINT_PROPERTY* optional
    , "UInt", propertyCount   ; DWORD
    , "Ptr", addressUrl   ; WS_STRING* optional
    , "Ptr", contract   ; WS_SERVICE_CONTRACT*
    , "Ptr", authorizationCallback   ; WS_SERVICE_SECURITY_CALLBACK optional
    , "Ptr", heap   ; WS_HEAP*
    , "Int", templateType   ; WS_BINDING_TEMPLATE_TYPE
    , "Ptr", templateValue   ; void* optional
    , "UInt", templateSize   ; DWORD
    , "Ptr", templateDescription   ; void*
    , "UInt", templateDescriptionSize   ; DWORD
    , "Ptr", serviceEndpoint   ; WS_SERVICE_ENDPOINT** out
    , "Ptr", error   ; WS_ERROR* optional
    , "Int")   ; return: HRESULT

●WsCreateServiceEndpointFromTemplate(channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error) = DLL("webservices.dll", "int WsCreateServiceEndpointFromTemplate(int, void*, dword, void*, void*, void*, void*, int, void*, dword, void*, dword, void*, void*)")
# 呼び出し: WsCreateServiceEndpointFromTemplate(channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error)
# channelType : WS_CHANNEL_TYPE -> "int"
# properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> "void*"
# propertyCount : DWORD -> "dword"
# addressUrl : WS_STRING* optional -> "void*"
# contract : WS_SERVICE_CONTRACT* -> "void*"
# authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> "void*"
# heap : WS_HEAP* -> "void*"
# templateType : WS_BINDING_TEMPLATE_TYPE -> "int"
# templateValue : void* optional -> "void*"
# templateSize : DWORD -> "dword"
# templateDescription : void* -> "void*"
# templateDescriptionSize : DWORD -> "dword"
# serviceEndpoint : WS_SERVICE_ENDPOINT** out -> "void*"
# error : WS_ERROR* optional -> "void*"
# なでしこ1は32bit・ANSI(Shift_JIS)。文字列=char*(ANSI)、ポインタ/ハンドル=void*(4byte)。

const std = @import("std");

extern "webservices" fn WsCreateServiceEndpointFromTemplate(
    channelType: i32, // WS_CHANNEL_TYPE
    properties: [*c]WS_SERVICE_ENDPOINT_PROPERTY, // WS_SERVICE_ENDPOINT_PROPERTY* optional
    propertyCount: u32, // DWORD
    addressUrl: [*c]WS_STRING, // WS_STRING* optional
    contract: [*c]WS_SERVICE_CONTRACT, // WS_SERVICE_CONTRACT*
    authorizationCallback: ?*anyopaque, // WS_SERVICE_SECURITY_CALLBACK optional
    heap: [*c]isize, // WS_HEAP*
    templateType: i32, // WS_BINDING_TEMPLATE_TYPE
    templateValue: ?*anyopaque, // void* optional
    templateSize: u32, // DWORD
    templateDescription: ?*anyopaque, // void*
    templateDescriptionSize: u32, // DWORD
    serviceEndpoint: [*c][*c]WS_SERVICE_ENDPOINT, // WS_SERVICE_ENDPOINT** out
    error: [*c]isize // WS_ERROR* optional
) callconv(std.os.windows.WINAPI) i32;

proc WsCreateServiceEndpointFromTemplate(
    channelType: int32,  # WS_CHANNEL_TYPE
    properties: ptr WS_SERVICE_ENDPOINT_PROPERTY,  # WS_SERVICE_ENDPOINT_PROPERTY* optional
    propertyCount: uint32,  # DWORD
    addressUrl: ptr WS_STRING,  # WS_STRING* optional
    contract: ptr WS_SERVICE_CONTRACT,  # WS_SERVICE_CONTRACT*
    authorizationCallback: pointer,  # WS_SERVICE_SECURITY_CALLBACK optional
    heap: ptr int,  # WS_HEAP*
    templateType: int32,  # WS_BINDING_TEMPLATE_TYPE
    templateValue: pointer,  # void* optional
    templateSize: uint32,  # DWORD
    templateDescription: pointer,  # void*
    templateDescriptionSize: uint32,  # DWORD
    serviceEndpoint: ptr WS_SERVICE_ENDPOINT,  # WS_SERVICE_ENDPOINT** out
    error: ptr int  # WS_ERROR* optional
): int32 {.importc: "WsCreateServiceEndpointFromTemplate", stdcall, dynlib: "webservices.dll".}

pragma(lib, "webservices");
extern(Windows)
int WsCreateServiceEndpointFromTemplate(
    int channelType,   // WS_CHANNEL_TYPE
    WS_SERVICE_ENDPOINT_PROPERTY* properties,   // WS_SERVICE_ENDPOINT_PROPERTY* optional
    uint propertyCount,   // DWORD
    WS_STRING* addressUrl,   // WS_STRING* optional
    WS_SERVICE_CONTRACT* contract,   // WS_SERVICE_CONTRACT*
    void* authorizationCallback,   // WS_SERVICE_SECURITY_CALLBACK optional
    ptrdiff_t* heap,   // WS_HEAP*
    int templateType,   // WS_BINDING_TEMPLATE_TYPE
    void* templateValue,   // void* optional
    uint templateSize,   // DWORD
    void* templateDescription,   // void*
    uint templateDescriptionSize,   // DWORD
    WS_SERVICE_ENDPOINT** serviceEndpoint,   // WS_SERVICE_ENDPOINT** out
    ptrdiff_t* error   // WS_ERROR* optional
);

ccall((:WsCreateServiceEndpointFromTemplate, "webservices.dll"), stdcall, Int32,
      (Int32, Ptr{WS_SERVICE_ENDPOINT_PROPERTY}, UInt32, Ptr{WS_STRING}, Ptr{WS_SERVICE_CONTRACT}, Ptr{Cvoid}, Ptr{Int}, Int32, Ptr{Cvoid}, UInt32, Ptr{Cvoid}, UInt32, Ptr{WS_SERVICE_ENDPOINT}, Ptr{Int}),
      channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error)
# channelType : WS_CHANNEL_TYPE -> Int32
# properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> Ptr{WS_SERVICE_ENDPOINT_PROPERTY}
# propertyCount : DWORD -> UInt32
# addressUrl : WS_STRING* optional -> Ptr{WS_STRING}
# contract : WS_SERVICE_CONTRACT* -> Ptr{WS_SERVICE_CONTRACT}
# authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> Ptr{Cvoid}
# heap : WS_HEAP* -> Ptr{Int}
# templateType : WS_BINDING_TEMPLATE_TYPE -> Int32
# templateValue : void* optional -> Ptr{Cvoid}
# templateSize : DWORD -> UInt32
# templateDescription : void* -> Ptr{Cvoid}
# templateDescriptionSize : DWORD -> UInt32
# serviceEndpoint : WS_SERVICE_ENDPOINT** out -> Ptr{WS_SERVICE_ENDPOINT}
# error : WS_ERROR* optional -> Ptr{Int}
# stdcall は 32bit のみ意味を持つ(x64 では無視)。

local ffi = require("ffi")
ffi.cdef[[
int32_t WsCreateServiceEndpointFromTemplate(
    int32_t channelType,
    void* properties,
    uint32_t propertyCount,
    void* addressUrl,
    void* contract,
    void* authorizationCallback,
    intptr_t* heap,
    int32_t templateType,
    void* templateValue,
    uint32_t templateSize,
    void* templateDescription,
    uint32_t templateDescriptionSize,
    void* serviceEndpoint,
    intptr_t* error);
]]
local webservices = ffi.load("webservices")
-- webservices.WsCreateServiceEndpointFromTemplate(channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error)
-- channelType : WS_CHANNEL_TYPE
-- properties : WS_SERVICE_ENDPOINT_PROPERTY* optional
-- propertyCount : DWORD
-- addressUrl : WS_STRING* optional
-- contract : WS_SERVICE_CONTRACT*
-- authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional
-- heap : WS_HEAP*
-- templateType : WS_BINDING_TEMPLATE_TYPE
-- templateValue : void* optional
-- templateSize : DWORD
-- templateDescription : void*
-- templateDescriptionSize : DWORD
-- serviceEndpoint : WS_SERVICE_ENDPOINT** out
-- error : WS_ERROR* optional
-- 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。

const koffi = require('koffi');
const lib = koffi.load('webservices.dll');
const WsCreateServiceEndpointFromTemplate = lib.func('__stdcall', 'WsCreateServiceEndpointFromTemplate', 'int32_t', ['int32_t', 'void *', 'uint32_t', 'void *', 'void *', 'void *', 'intptr_t *', 'int32_t', 'void *', 'uint32_t', 'void *', 'uint32_t', 'void *', 'intptr_t *']);
// WsCreateServiceEndpointFromTemplate(channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error)
// channelType : WS_CHANNEL_TYPE -> 'int32_t'
// properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> 'void *'
// propertyCount : DWORD -> 'uint32_t'
// addressUrl : WS_STRING* optional -> 'void *'
// contract : WS_SERVICE_CONTRACT* -> 'void *'
// authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> 'void *'
// heap : WS_HEAP* -> 'intptr_t *'
// templateType : WS_BINDING_TEMPLATE_TYPE -> 'int32_t'
// templateValue : void* optional -> 'void *'
// templateSize : DWORD -> 'uint32_t'
// templateDescription : void* -> 'void *'
// templateDescriptionSize : DWORD -> 'uint32_t'
// serviceEndpoint : WS_SERVICE_ENDPOINT** out -> 'void *'
// error : WS_ERROR* optional -> 'intptr_t *'
// 出力ポインタは koffi.out(...) で包む。構造体は koffi.struct で定義。
// コールバック(関数ポインタ)は koffi.proto/koffi.register で型を定義して渡す(素の void* では JS 関数を渡せない)。

const lib = Deno.dlopen("webservices.dll", {
  WsCreateServiceEndpointFromTemplate: { parameters: ["i32", "pointer", "u32", "pointer", "pointer", "pointer", "pointer", "i32", "pointer", "u32", "pointer", "u32", "pointer", "pointer"], result: "i32" },
});
// lib.symbols.WsCreateServiceEndpointFromTemplate(channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error)
// channelType : WS_CHANNEL_TYPE -> "i32"
// properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> "pointer"
// propertyCount : DWORD -> "u32"
// addressUrl : WS_STRING* optional -> "pointer"
// contract : WS_SERVICE_CONTRACT* -> "pointer"
// authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> "pointer"
// heap : WS_HEAP* -> "pointer"
// templateType : WS_BINDING_TEMPLATE_TYPE -> "i32"
// templateValue : void* optional -> "pointer"
// templateSize : DWORD -> "u32"
// templateDescription : void* -> "pointer"
// templateDescriptionSize : DWORD -> "u32"
// serviceEndpoint : WS_SERVICE_ENDPOINT** out -> "pointer"
// error : WS_ERROR* optional -> "pointer"
// 文字列引数は "buffer"(NUL 終端のバイト列を Uint8Array で渡す)。
// 値渡し構造体は { struct: [ ...field types... ] } を使用。

<?php
$ffi = FFI::cdef(<<<C
int32_t WsCreateServiceEndpointFromTemplate(
    int32_t channelType,
    void* properties,
    uint32_t propertyCount,
    void* addressUrl,
    void* contract,
    void* authorizationCallback,
    intptr_t* heap,
    int32_t templateType,
    void* templateValue,
    uint32_t templateSize,
    void* templateDescription,
    uint32_t templateDescriptionSize,
    void* serviceEndpoint,
    intptr_t* error);
C, "webservices.dll");
// $ffi->WsCreateServiceEndpointFromTemplate(channelType, properties, propertyCount, addressUrl, contract, authorizationCallback, heap, templateType, templateValue, templateSize, templateDescription, templateDescriptionSize, serviceEndpoint, error);
// channelType : WS_CHANNEL_TYPE
// properties : WS_SERVICE_ENDPOINT_PROPERTY* optional
// propertyCount : DWORD
// addressUrl : WS_STRING* optional
// contract : WS_SERVICE_CONTRACT*
// authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional
// heap : WS_HEAP*
// templateType : WS_BINDING_TEMPLATE_TYPE
// templateValue : void* optional
// templateSize : DWORD
// templateDescription : void*
// templateDescriptionSize : DWORD
// serviceEndpoint : WS_SERVICE_ENDPOINT** out
// error : WS_ERROR* optional
// 構造体/GUIDへのポインタは cdef が通るよう void* で表記(実型は各引数コメント参照)。値渡し構造体・enum は対応する typedef を cdef に追加すること。
// WINAPI(stdcall): x64 では呼出規約が統一されるため問題なし。x86 では __stdcall 対応のラッパが必要な場合あり。

import com.sun.jna.*;
import com.sun.jna.ptr.*;
import com.sun.jna.win32.StdCallLibrary;
import com.sun.jna.win32.W32APIOptions;

public interface Webservices extends StdCallLibrary {
    Webservices INSTANCE = Native.load("webservices", Webservices.class);
    int WsCreateServiceEndpointFromTemplate(
        int channelType,   // WS_CHANNEL_TYPE
        Pointer properties,   // WS_SERVICE_ENDPOINT_PROPERTY* optional
        int propertyCount,   // DWORD
        Pointer addressUrl,   // WS_STRING* optional
        Pointer contract,   // WS_SERVICE_CONTRACT*
        Callback authorizationCallback,   // WS_SERVICE_SECURITY_CALLBACK optional
        LongByReference heap,   // WS_HEAP*
        int templateType,   // WS_BINDING_TEMPLATE_TYPE
        Pointer templateValue,   // void* optional
        int templateSize,   // DWORD
        Pointer templateDescription,   // void*
        int templateDescriptionSize,   // DWORD
        Pointer serviceEndpoint,   // WS_SERVICE_ENDPOINT** out
        LongByReference error   // WS_ERROR* optional
    );
}

@[Link("webservices")]
lib Libwebservices
  fun WsCreateServiceEndpointFromTemplate = WsCreateServiceEndpointFromTemplate(
    channelType : Int32,   # WS_CHANNEL_TYPE
    properties : WS_SERVICE_ENDPOINT_PROPERTY*,   # WS_SERVICE_ENDPOINT_PROPERTY* optional
    propertyCount : UInt32,   # DWORD
    addressUrl : WS_STRING*,   # WS_STRING* optional
    contract : WS_SERVICE_CONTRACT*,   # WS_SERVICE_CONTRACT*
    authorizationCallback : Void*,   # WS_SERVICE_SECURITY_CALLBACK optional
    heap : LibC::SSizeT*,   # WS_HEAP*
    templateType : Int32,   # WS_BINDING_TEMPLATE_TYPE
    templateValue : Void*,   # void* optional
    templateSize : UInt32,   # DWORD
    templateDescription : Void*,   # void*
    templateDescriptionSize : UInt32,   # DWORD
    serviceEndpoint : WS_SERVICE_ENDPOINT**,   # WS_SERVICE_ENDPOINT** out
    error : LibC::SSizeT*   # WS_ERROR* optional
  ) : Int32
end
# 構造体/GUID/enum は lib 内に対応する型定義が必要。
# 呼出規約: x64 は規約統一のため OK。x86(32bit)は WINAPI=stdcall だが Crystal の fun に stdcall 付与構文がなく非対応。

import 'dart:ffi';
import 'package:ffi/ffi.dart';

typedef WsCreateServiceEndpointFromTemplateNative = Int32 Function(Int32, Pointer<Void>, Uint32, Pointer<Void>, Pointer<Void>, Pointer<Void>, Pointer<IntPtr>, Int32, Pointer<Void>, Uint32, Pointer<Void>, Uint32, Pointer<Void>, Pointer<IntPtr>);
typedef WsCreateServiceEndpointFromTemplateDart = int Function(int, Pointer<Void>, int, Pointer<Void>, Pointer<Void>, Pointer<Void>, Pointer<IntPtr>, int, Pointer<Void>, int, Pointer<Void>, int, Pointer<Void>, Pointer<IntPtr>);
final WsCreateServiceEndpointFromTemplate = DynamicLibrary.open('webservices.dll')
    .lookupFunction<WsCreateServiceEndpointFromTemplateNative, WsCreateServiceEndpointFromTemplateDart>('WsCreateServiceEndpointFromTemplate');
// channelType : WS_CHANNEL_TYPE -> Int32
// properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> Pointer<Void>
// propertyCount : DWORD -> Uint32
// addressUrl : WS_STRING* optional -> Pointer<Void>
// contract : WS_SERVICE_CONTRACT* -> Pointer<Void>
// authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> Pointer<Void>
// heap : WS_HEAP* -> Pointer<IntPtr>
// templateType : WS_BINDING_TEMPLATE_TYPE -> Int32
// templateValue : void* optional -> Pointer<Void>
// templateSize : DWORD -> Uint32
// templateDescription : void* -> Pointer<Void>
// templateDescriptionSize : DWORD -> Uint32
// serviceEndpoint : WS_SERVICE_ENDPOINT** out -> Pointer<Void>
// error : WS_ERROR* optional -> Pointer<IntPtr>
// 文字列は package:ffi の "...".toNativeUtf16()/toNativeUtf8() で変換。

{$mode objfpc}{$H+}
function WsCreateServiceEndpointFromTemplate(
  channelType: Integer;   // WS_CHANNEL_TYPE
  properties: Pointer;   // WS_SERVICE_ENDPOINT_PROPERTY* optional
  propertyCount: DWORD;   // DWORD
  addressUrl: Pointer;   // WS_STRING* optional
  contract: Pointer;   // WS_SERVICE_CONTRACT*
  authorizationCallback: Pointer;   // WS_SERVICE_SECURITY_CALLBACK optional
  heap: Pointer;   // WS_HEAP*
  templateType: Integer;   // WS_BINDING_TEMPLATE_TYPE
  templateValue: Pointer;   // void* optional
  templateSize: DWORD;   // DWORD
  templateDescription: Pointer;   // void*
  templateDescriptionSize: DWORD;   // DWORD
  serviceEndpoint: Pointer;   // WS_SERVICE_ENDPOINT** out
  error: Pointer   // WS_ERROR* optional
): Integer; stdcall;
  external 'webservices.dll' name 'WsCreateServiceEndpointFromTemplate';

import Foreign
import Foreign.C.Types
import Foreign.C.String

foreign import stdcall safe "WsCreateServiceEndpointFromTemplate"
  c_WsCreateServiceEndpointFromTemplate :: Int32 -> Ptr () -> Word32 -> Ptr () -> Ptr () -> Ptr () -> Ptr CIntPtr -> Int32 -> Ptr () -> Word32 -> Ptr () -> Word32 -> Ptr () -> Ptr CIntPtr -> IO Int32
-- channelType : WS_CHANNEL_TYPE -> Int32
-- properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> Ptr ()
-- propertyCount : DWORD -> Word32
-- addressUrl : WS_STRING* optional -> Ptr ()
-- contract : WS_SERVICE_CONTRACT* -> Ptr ()
-- authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> Ptr ()
-- heap : WS_HEAP* -> Ptr CIntPtr
-- templateType : WS_BINDING_TEMPLATE_TYPE -> Int32
-- templateValue : void* optional -> Ptr ()
-- templateSize : DWORD -> Word32
-- templateDescription : void* -> Ptr ()
-- templateDescriptionSize : DWORD -> Word32
-- serviceEndpoint : WS_SERVICE_ENDPOINT** out -> Ptr ()
-- error : WS_ERROR* optional -> Ptr CIntPtr
-- 要 GHC(Windows)。stdcall は x64 では ccall として扱われる。ブロックする API は safe 呼び出し推奨。

open Ctypes
open Foreign

let wscreateserviceendpointfromtemplate =
  foreign "WsCreateServiceEndpointFromTemplate"
    (int32_t @-> (ptr void) @-> uint32_t @-> (ptr void) @-> (ptr void) @-> (ptr void) @-> (ptr intptr_t) @-> int32_t @-> (ptr void) @-> uint32_t @-> (ptr void) @-> uint32_t @-> (ptr void) @-> (ptr intptr_t) @-> returning int32_t)
(* channelType : WS_CHANNEL_TYPE -> int32_t *)
(* properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> (ptr void) *)
(* propertyCount : DWORD -> uint32_t *)
(* addressUrl : WS_STRING* optional -> (ptr void) *)
(* contract : WS_SERVICE_CONTRACT* -> (ptr void) *)
(* authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> (ptr void) *)
(* heap : WS_HEAP* -> (ptr intptr_t) *)
(* templateType : WS_BINDING_TEMPLATE_TYPE -> int32_t *)
(* templateValue : void* optional -> (ptr void) *)
(* templateSize : DWORD -> uint32_t *)
(* templateDescription : void* -> (ptr void) *)
(* templateDescriptionSize : DWORD -> uint32_t *)
(* serviceEndpoint : WS_SERVICE_ENDPOINT** out -> (ptr void) *)
(* error : WS_ERROR* optional -> (ptr intptr_t) *)
(* foreign は cdecl 前提。x64 Windows では WINAPI と一致。構造体は ctypes structure を定義のこと。 *)

(cffi:define-foreign-library webservices (t "webservices.dll"))
(cffi:use-foreign-library webservices)

(cffi:defcfun ("WsCreateServiceEndpointFromTemplate" ws-create-service-endpoint-from-template :convention :stdcall) :int32
  (channel-type :int32)   ; WS_CHANNEL_TYPE
  (properties :pointer)   ; WS_SERVICE_ENDPOINT_PROPERTY* optional
  (property-count :uint32)   ; DWORD
  (address-url :pointer)   ; WS_STRING* optional
  (contract :pointer)   ; WS_SERVICE_CONTRACT*
  (authorization-callback :pointer)   ; WS_SERVICE_SECURITY_CALLBACK optional
  (heap :pointer)   ; WS_HEAP*
  (template-type :int32)   ; WS_BINDING_TEMPLATE_TYPE
  (template-value :pointer)   ; void* optional
  (template-size :uint32)   ; DWORD
  (template-description :pointer)   ; void*
  (template-description-size :uint32)   ; DWORD
  (service-endpoint :pointer)   ; WS_SERVICE_ENDPOINT** out
  (error :pointer))   ; WS_ERROR* optional
; isize/usize(INT_PTR/SIZE_T)は x64 前提で :int64/:uint64。x86 では :int32/:uint32。

use Win32::API;
my $WsCreateServiceEndpointFromTemplate = Win32::API::More->new('webservices',
    'int WsCreateServiceEndpointFromTemplate(int channelType, LPVOID properties, DWORD propertyCount, LPVOID addressUrl, LPVOID contract, LPVOID authorizationCallback, LPVOID heap, int templateType, LPVOID templateValue, DWORD templateSize, LPVOID templateDescription, DWORD templateDescriptionSize, LPVOID serviceEndpoint, LPVOID error)');
# my $ret = $WsCreateServiceEndpointFromTemplate->Call($channelType, $properties, $propertyCount, $addressUrl, $contract, $authorizationCallback, $heap, $templateType, $templateValue, $templateSize, $templateDescription, $templateDescriptionSize, $serviceEndpoint, $error);
# channelType : WS_CHANNEL_TYPE -> int
# properties : WS_SERVICE_ENDPOINT_PROPERTY* optional -> LPVOID
# propertyCount : DWORD -> DWORD
# addressUrl : WS_STRING* optional -> LPVOID
# contract : WS_SERVICE_CONTRACT* -> LPVOID
# authorizationCallback : WS_SERVICE_SECURITY_CALLBACK optional -> LPVOID
# heap : WS_HEAP* -> LPVOID
# templateType : WS_BINDING_TEMPLATE_TYPE -> int
# templateValue : void* optional -> LPVOID
# templateSize : DWORD -> DWORD
# templateDescription : void* -> LPVOID
# templateDescriptionSize : DWORD -> DWORD
# serviceEndpoint : WS_SERVICE_ENDPOINT** out -> LPVOID
# error : WS_ERROR* optional -> LPVOID
# 値渡し構造体は pack() した文字列、または Win32::API::Struct を使用。
# コールバック(関数ポインタ)は Perl sub を直接渡せません。Win32::API::Callback を使用してください。