AcceptEx

関数

着信接続を受け入れ初期データとアドレスを取得する。

DLLMSWSOCK.dll呼出規約winapi対応OSWindows 8.1 以降

シグネチャ

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

BOOL AcceptEx(
    SOCKET sListenSocket,
    SOCKET sAcceptSocket,
    void* lpOutputBuffer,
    DWORD dwReceiveDataLength,
    DWORD dwLocalAddressLength,
    DWORD dwRemoteAddressLength,
    DWORD* lpdwBytesReceived,
    OVERLAPPED* lpOverlapped
);

パラメーター

名前	型	方向	説明
sListenSocket	SOCKET	in	既に listen 関数が呼び出されたソケットを識別するディスクリプターです。サーバーアプリケーションは、このソケットで接続試行を待機します。
sAcceptSocket	SOCKET	in	着信接続を受け入れるソケットを識別するディスクリプターです。このソケットはバインドも接続もされていてはなりません。
lpOutputBuffer	void*	out	新しい接続で送信された最初のデータブロック、サーバーのローカルアドレス、およびクライアントのリモートアドレスを受け取るバッファーへのポインターです。受信データはバッファーのオフセット 0 から始まる先頭部分に書き込まれ、アドレスはバッファーの後半部分に書き込まれます。このパラメーターは必ず指定する必要があります。
dwReceiveDataLength	DWORD	in	バッファー先頭で実際の受信データに使用される lpOutputBuffer 内のバイト数です。このサイズには、サーバーのローカルアドレスやクライアントのリモートアドレスのサイズを含めないでください。これらは出力バッファーに追加で付加されます。dwReceiveDataLength が 0 の場合、接続を受け入れても受信操作は行われません。代わりに AcceptEx は、データを待たずに接続が到着した時点で直ちに完了します。
dwLocalAddressLength	DWORD	in	ローカルアドレス情報のために予約するバイト数です。この値は、使用するトランスポートプロトコルの最大アドレス長より少なくとも 16 バイト大きくする必要があります。
dwRemoteAddressLength	DWORD	in	リモートアドレス情報のために予約するバイト数です。この値は、使用するトランスポートプロトコルの最大アドレス長より少なくとも 16 バイト大きくする必要があります。0 にすることはできません。
lpdwBytesReceived	DWORD*	out	受信したバイト数を受け取る DWORD へのポインターです。このパラメーターは、操作が同期的に完了した場合にのみ設定されます。ERROR_IO_PENDING を返して後で完了する場合、この DWORD は設定されないため、読み取られたバイト数は完了通知メカニズムから取得する必要があります。
lpOverlapped	OVERLAPPED*	inout	要求の処理に使用される OVERLAPPED 構造体です。このパラメーターは必ず指定する必要があり、NULL にすることはできません。

戻り値の型: BOOL

公式ドキュメント

AcceptEx 関数 (mswsock.h) は、新しい接続を受け入れ、ローカルアドレスとリモートアドレスを返し、クライアントアプリケーションが送信した最初のデータブロックを受信します。

戻り値

エラーが発生しなかった場合、 AcceptEx 関数は正常に完了し、TRUE が返されます。

関数が失敗した場合、 AcceptEx は FALSE を返します。続いて WSAGetLastError 関数を呼び出すことで、拡張エラー情報を取得できます。WSAGetLastError が ERROR_IO_PENDING を返す場合、操作は正常に開始され、まだ進行中です。エラーが WSAECONNRESET の場合、着信接続が示されましたが、呼び出しを受け入れる前にリモートピアによって接続が終了されたことを意味します。

解説(Remarks)

AcceptEx 関数は、複数のソケット関数を 1 回の API/カーネル遷移にまとめます。 AcceptEx 関数は、成功すると次の 3 つの処理を実行します。

新しい接続が受け入れられます。
接続のローカルアドレスとリモートアドレスの両方が返されます。
リモート側が送信した最初のデータブロックが受信されます。

注意 AcceptEx 関数の関数ポインターは、実行時に WSAIoctl 関数を SIO_GET_EXTENSION_FUNCTION_POINTER オペコードを指定して呼び出すことで取得する必要があります。WSAIoctl 関数に渡す入力バッファーには、AcceptEx 拡張関数を識別する値を持つグローバル一意識別子 (GUID) である WSAID_ACCEPTEX を含める必要があります。成功すると、WSAIoctl 関数が返す出力には AcceptEx 関数へのポインターが含まれます。WSAID_ACCEPTEX GUID は Mswsock.h ヘッダーファイルで定義されています。

プログラムは、 accept 関数の代わりに AcceptEx を使用することで、より高速にソケットへの接続を確立できます。

単一の出力バッファーが、データ、ローカルソケットアドレス (サーバー)、およびリモートソケットアドレス (クライアント) を受け取ります。

単一のバッファーを使用するとパフォーマンスが向上します。 AcceptEx を使用する場合、バッファーを 3 つの異なる部分 (データ、ローカルソケットアドレス、リモートソケットアドレス) に解析するために GetAcceptExSockaddrs 関数を呼び出す必要があります。Windows XP 以降では、 AcceptEx 関数が完了し、受け入れたソケットに SO_UPDATE_ACCEPT_CONTEXT オプションが設定されると、受け入れたソケットに関連付けられたローカルアドレスを getsockname 関数を使用して取得することもできます。同様に、受け入れたソケットに関連付けられたリモートアドレスは getpeername 関数を使用して取得できます。

アドレスは内部形式で書き込まれるため、ローカルアドレスおよびリモートアドレス用のバッファーサイズは、使用するトランスポートプロトコルの sockaddr 構造体のサイズより 16 バイト大きくする必要があります。たとえば、sockaddr_in (TCP/IP 用のアドレス構造体) のサイズは 16 バイトです。したがって、ローカルアドレスおよびリモートアドレスには、少なくとも 32 バイトのバッファーサイズを指定する必要があります。

AcceptEx 関数は、 accept 関数とは異なり、オーバーラップ I/O を使用します。アプリケーションが AcceptEx を使用すると、比較的少数のスレッドで多数のクライアントを処理できます。すべてのオーバーラップ対応の Windows 関数と同様に、完了通知メカニズムとして Windows イベントまたは完了ポートのいずれかを使用できます。

AcceptEx 関数と accept 関数のもう 1 つの重要な違いは、 AcceptEx では呼び出し元が既に 2 つのソケットを持っている必要がある点です。

リッスンするソケットを指定するもの。
接続を受け入れるソケットを指定するもの。

sAcceptSocket パラメーターは、バインドも接続もされていない、開かれた状態のソケットでなければなりません。

GetQueuedCompletionStatus 関数または GetOverlappedResult 関数の lpNumberOfBytesTransferred パラメーターは、要求で受信したバイト数を示します。

この操作が正常に完了すると、sAcceptSocket は次の関数にのみ渡すことができます。

ReadFile

WriteFile

send

WSASend

recv

WSARecv

TransmitFile

closesocket

setsockopt(SO_UPDATE_ACCEPT_CONTEXT のみ)

注意 TransmitFile 関数が TF_DISCONNECT フラグと TF_REUSE_SOCKET フラグの両方を指定して呼び出された場合、指定されたソケットは、バインドも接続もされていない状態に戻されます。このソケットハンドルは AcceptEx 関数の sAcceptSocket パラメーターに渡すことができますが、ConnectEx 関数に渡すことはできません。

AcceptEx 関数が返ると、ソケット sAcceptSocket は接続済みソケットの既定の状態になります。ソケット sAcceptSocket は、ソケットに SO_UPDATE_ACCEPT_CONTEXT が設定されるまで、sListenSocket パラメーターに関連付けられたソケットのプロパティを継承しません。SO_UPDATE_ACCEPT_CONTEXT オプションを設定するには、 setsockopt 関数を使用し、ソケットハンドルとして sAcceptSocket を、オプション値として sListenSocket を指定します。

例:

//Need to #include <mswsock.h> for SO_UPDATE_ACCEPT_CONTEXT

int iResult = 0;

iResult =  setsockopt( sAcceptSocket, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, 
    (char *)&sListenSocket, sizeof(sListenSocket) );

受信バッファーが提供される場合、オーバーラップ操作は、接続が受け入れられてデータが読み取られるまで完了しません。接続が受け入れられたかどうかを確認するには、 getsockopt 関数を SO_CONNECT_TIME オプションを指定して使用します。受け入れられている場合は、接続が確立されてからの経過時間を取得できます。戻り値は、ソケットが接続されてからの秒数です。ソケットが接続されていない場合、getsockopt は 0xFFFFFFFF を返します。オーバーラップ操作が完了したかどうかの確認と SO_CONNECT_TIME オプションを組み合わせることで、アプリケーションは接続が受け入れられたもののデータがまだ受信されていないことを判別できます。このように接続を精査することで、しばらく前に確立されたがデータをまったく受信していない接続を、アプリケーションが判別できるようになります。そのような接続は、受け入れたソケットを閉じて終了することをお勧めします。これにより AcceptEx 関数の呼び出しがエラーで完了します。

例:


INT seconds;
INT bytes = sizeof(seconds);
int iResult = 0;

iResult = getsockopt( sAcceptSocket, SOL_SOCKET, SO_CONNECT_TIME,
                      (char *)&seconds, (PINT)&bytes );

if ( iResult != NO_ERROR ) {
    printf( "getsockopt(SO_CONNECT_TIME) failed: %u\n", WSAGetLastError( ) );
    exit(1);
}

注意特定のスレッドによって開始されたすべての I/O は、そのスレッドが終了するとキャンセルされます。オーバーラップソケットの場合、操作が完了する前にスレッドが閉じられると、保留中の非同期操作が失敗することがあります。詳細については ExitThread を参照してください。

Windows Phone 8: この関数は、Windows Phone 8 以降の Windows Phone ストアアプリでサポートされます。

Windows 8.1 および Windows Server 2012 R2: この関数は、Windows 8.1、Windows Server 2012 R2 以降の Windows ストアアプリでサポートされます。

サンプルコード

次の例では、オーバーラップ I/O と完了ポートを使用して AcceptEx 関数を使用しています。

#ifndef UNICODE
#define UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <ws2tcpip.h>
#include <mswsock.h>
#include <stdio.h>

// Need to link with Ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

int main()
{
    //----------------------------------------
    // Declare and initialize variables
    WSADATA wsaData;
    int iResult = 0;
    BOOL bRetVal = FALSE;

    HANDLE hCompPort;
    HANDLE hCompPort2;
    
    LPFN_ACCEPTEX lpfnAcceptEx = NULL;
    GUID GuidAcceptEx = WSAID_ACCEPTEX;
    WSAOVERLAPPED olOverlap;

    SOCKET ListenSocket = INVALID_SOCKET;
    SOCKET AcceptSocket = INVALID_SOCKET;
    sockaddr_in service;
    char lpOutputBuf[1024];
    int outBufLen = 1024;
    DWORD dwBytes;

    hostent *thisHost;
    char *ip;
    u_short port;

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != NO_ERROR) {
        wprintf(L"Error at WSAStartup\n");
        return 1;
    }    

    // Create a handle for the completion port
    hCompPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (u_long) 0, 0);
    if (hCompPort == NULL) {
        wprintf(L"CreateIoCompletionPort failed with error: %u\n",
            GetLastError() );
        WSACleanup();
        return 1;
    }
            
    // Create a listening socket
    ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (ListenSocket == INVALID_SOCKET) {
        wprintf(L"Create of ListenSocket socket failed with error: %u\n",
            WSAGetLastError() );
        WSACleanup();
        return 1;
    }

    // Associate the listening socket with the completion port
    CreateIoCompletionPort((HANDLE) ListenSocket, hCompPort, (u_long) 0, 0);

    //----------------------------------------
    // Bind the listening socket to the local IP address
    // and port 27015
    port = 27015;
    thisHost = gethostbyname("");
    ip = inet_ntoa(*(struct in_addr *) *thisHost->h_addr_list);

    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr(ip);
    service.sin_port = htons(port);

    if (bind(ListenSocket, (SOCKADDR *) & service, sizeof (service)) == SOCKET_ERROR) {
        wprintf(L"bind failed with error: %u\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    //----------------------------------------
    // Start listening on the listening socket
    iResult = listen(ListenSocket, 100);
    if (iResult == SOCKET_ERROR) {
        wprintf(L"listen failed with error: %u\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    wprintf(L"Listening on address: %s:%d\n", ip, port);

    // Load the AcceptEx function into memory using WSAIoctl.
    // The WSAIoctl function is an extension of the ioctlsocket()
    // function that can use overlapped I/O. The function's 3rd
    // through 6th parameters are input and output buffers where
    // we pass the pointer to our AcceptEx function. This is used
    // so that we can call the AcceptEx function directly, rather
    // than refer to the Mswsock.lib library.
    iResult = WSAIoctl(ListenSocket, SIO_GET_EXTENSION_FUNCTION_POINTER,
             &GuidAcceptEx, sizeof (GuidAcceptEx), 
             &lpfnAcceptEx, sizeof (lpfnAcceptEx), 
             &dwBytes, NULL, NULL);
    if (iResult == SOCKET_ERROR) {
        wprintf(L"WSAIoctl failed with error: %u\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    // Create an accepting socket
    AcceptSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (AcceptSocket == INVALID_SOCKET) {
        wprintf(L"Create accept socket failed with error: %u\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    // Empty our overlapped structure and accept connections.
    memset(&olOverlap, 0, sizeof (olOverlap));

    bRetVal = lpfnAcceptEx(ListenSocket, AcceptSocket, lpOutputBuf,
                 outBufLen - ((sizeof (sockaddr_in) + 16) * 2),
                 sizeof (sockaddr_in) + 16, sizeof (sockaddr_in) + 16, 
                 &dwBytes, &olOverlap);
    if (bRetVal == FALSE) {
        wprintf(L"AcceptEx failed with error: %u\n", WSAGetLastError());
        closesocket(AcceptSocket);
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    // Associate the accept socket with the completion port
    hCompPort2 = CreateIoCompletionPort((HANDLE) AcceptSocket, hCompPort, (u_long) 0, 0); 
    // hCompPort2 should be hCompPort if this succeeds
    if (hCompPort2 == NULL) {
        wprintf(L"CreateIoCompletionPort associate failed with error: %u\n",
            GetLastError() );
        closesocket(AcceptSocket);
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
    
    // Continue on to use send, recv, TransmitFile(), etc.,.
    //...

    return 0;
}

QoS に関する注意

TransmitFile 関数では、ファイルの送信後にソケットを「切断済みで再利用可能」な状態に戻す 2 つのフラグ、TF_DISCONNECT または TF_REUSE_SOCKET を設定できます。これらのフラグは、Quality of Service が要求されているソケットでは使用しないでください。サービスプロバイダーが、ファイル転送の完了前にソケットに関連付けられた Quality of Service を直ちに削除する可能性があるためです。QoS 対応のソケットでは、これらのフラグに頼るのではなく、ファイル転送が完了した時点で単に closesocket 関数を呼び出すのが最善の方法です。

ATM に関する注意

Windows Sockets 2 で非同期転送モード (ATM) を使用する場合、接続の設定に関して重要な問題があります。ATM 接続設定に関する重要な情報については、 accept 関数のドキュメントの「解説」セクションを参照してください。

出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での呼び出し定義

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

BOOL AcceptEx(
    SOCKET sListenSocket,
    SOCKET sAcceptSocket,
    void* lpOutputBuffer,
    DWORD dwReceiveDataLength,
    DWORD dwLocalAddressLength,
    DWORD dwRemoteAddressLength,
    DWORD* lpdwBytesReceived,
    OVERLAPPED* lpOverlapped
);

[return: MarshalAs(UnmanagedType.Bool)]
[DllImport("MSWSOCK.dll", ExactSpelling = true)]
static extern bool AcceptEx(
    UIntPtr sListenSocket,   // SOCKET
    UIntPtr sAcceptSocket,   // SOCKET
    IntPtr lpOutputBuffer,   // void* out
    uint dwReceiveDataLength,   // DWORD
    uint dwLocalAddressLength,   // DWORD
    uint dwRemoteAddressLength,   // DWORD
    out uint lpdwBytesReceived,   // DWORD* out
    IntPtr lpOverlapped   // OVERLAPPED* in/out
);

<DllImport("MSWSOCK.dll", ExactSpelling:=True)>
Public Shared Function AcceptEx(
    sListenSocket As UIntPtr,   ' SOCKET
    sAcceptSocket As UIntPtr,   ' SOCKET
    lpOutputBuffer As IntPtr,   ' void* out
    dwReceiveDataLength As UInteger,   ' DWORD
    dwLocalAddressLength As UInteger,   ' DWORD
    dwRemoteAddressLength As UInteger,   ' DWORD
    <Out> ByRef lpdwBytesReceived As UInteger,   ' DWORD* out
    lpOverlapped As IntPtr   ' OVERLAPPED* in/out
) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function

' sListenSocket : SOCKET
' sAcceptSocket : SOCKET
' lpOutputBuffer : void* out
' dwReceiveDataLength : DWORD
' dwLocalAddressLength : DWORD
' dwRemoteAddressLength : DWORD
' lpdwBytesReceived : DWORD* out
' lpOverlapped : OVERLAPPED* in/out
Declare PtrSafe Function AcceptEx Lib "mswsock" ( _
    ByVal sListenSocket As LongPtr, _
    ByVal sAcceptSocket As LongPtr, _
    ByVal lpOutputBuffer As LongPtr, _
    ByVal dwReceiveDataLength As Long, _
    ByVal dwLocalAddressLength As Long, _
    ByVal dwRemoteAddressLength As Long, _
    ByRef lpdwBytesReceived As Long, _
    ByVal lpOverlapped As LongPtr) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。

import ctypes
from ctypes import wintypes

AcceptEx = ctypes.windll.mswsock.AcceptEx
AcceptEx.restype = wintypes.BOOL
AcceptEx.argtypes = [
    ctypes.c_size_t,  # sListenSocket : SOCKET
    ctypes.c_size_t,  # sAcceptSocket : SOCKET
    ctypes.POINTER(None),  # lpOutputBuffer : void* out
    wintypes.DWORD,  # dwReceiveDataLength : DWORD
    wintypes.DWORD,  # dwLocalAddressLength : DWORD
    wintypes.DWORD,  # dwRemoteAddressLength : DWORD
    ctypes.POINTER(wintypes.DWORD),  # lpdwBytesReceived : DWORD* out
    ctypes.c_void_p,  # lpOverlapped : OVERLAPPED* in/out
]

require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('MSWSOCK.dll')
AcceptEx = Fiddle::Function.new(
  lib['AcceptEx'],
  [
    Fiddle::TYPE_UINTPTR_T,  # sListenSocket : SOCKET
    Fiddle::TYPE_UINTPTR_T,  # sAcceptSocket : SOCKET
    Fiddle::TYPE_VOIDP,  # lpOutputBuffer : void* out
    -Fiddle::TYPE_INT,  # dwReceiveDataLength : DWORD
    -Fiddle::TYPE_INT,  # dwLocalAddressLength : DWORD
    -Fiddle::TYPE_INT,  # dwRemoteAddressLength : DWORD
    Fiddle::TYPE_VOIDP,  # lpdwBytesReceived : DWORD* out
    Fiddle::TYPE_VOIDP,  # lpOverlapped : OVERLAPPED* in/out
  ],
  Fiddle::TYPE_INT)

#[link(name = "mswsock")]
extern "system" {
    fn AcceptEx(
        sListenSocket: usize,  // SOCKET
        sAcceptSocket: usize,  // SOCKET
        lpOutputBuffer: *mut (),  // void* out
        dwReceiveDataLength: u32,  // DWORD
        dwLocalAddressLength: u32,  // DWORD
        dwRemoteAddressLength: u32,  // DWORD
        lpdwBytesReceived: *mut u32,  // DWORD* out
        lpOverlapped: *mut OVERLAPPED  // OVERLAPPED* in/out
    ) -> i32;
}
// crates: windows-sys provides ready-made bindings for this API.

$sig = @"
[return: MarshalAs(UnmanagedType.Bool)]
[DllImport("MSWSOCK.dll")]
public static extern bool AcceptEx(UIntPtr sListenSocket, UIntPtr sAcceptSocket, IntPtr lpOutputBuffer, uint dwReceiveDataLength, uint dwLocalAddressLength, uint dwRemoteAddressLength, out uint lpdwBytesReceived, IntPtr lpOverlapped);
"@
$api = Add-Type -MemberDefinition $sig -Name 'MSWSOCK_AcceptEx' -Namespace Win32 -PassThru
# $api::AcceptEx(sListenSocket, sAcceptSocket, lpOutputBuffer, dwReceiveDataLength, dwLocalAddressLength, dwRemoteAddressLength, lpdwBytesReceived, lpOverlapped)

#uselib "MSWSOCK.dll"
#func global AcceptEx "AcceptEx" sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr
; AcceptEx sListenSocket, sAcceptSocket, lpOutputBuffer, dwReceiveDataLength, dwLocalAddressLength, dwRemoteAddressLength, varptr(lpdwBytesReceived), varptr(lpOverlapped)   ; 戻り値は stat
; sListenSocket : SOCKET -> "sptr"
; sAcceptSocket : SOCKET -> "sptr"
; lpOutputBuffer : void* out -> "sptr"
; dwReceiveDataLength : DWORD -> "sptr"
; dwLocalAddressLength : DWORD -> "sptr"
; dwRemoteAddressLength : DWORD -> "sptr"
; lpdwBytesReceived : DWORD* out -> "sptr"
; lpOverlapped : OVERLAPPED* in/out -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。

出力引数:

#uselib "MSWSOCK.dll"
#cfunc global AcceptEx "AcceptEx" sptr, sptr, sptr, int, int, int, var, var
; res = AcceptEx(sListenSocket, sAcceptSocket, lpOutputBuffer, dwReceiveDataLength, dwLocalAddressLength, dwRemoteAddressLength, lpdwBytesReceived, lpOverlapped)
; sListenSocket : SOCKET -> "sptr"
; sAcceptSocket : SOCKET -> "sptr"
; lpOutputBuffer : void* out -> "sptr"
; dwReceiveDataLength : DWORD -> "int"
; dwLocalAddressLength : DWORD -> "int"
; dwRemoteAddressLength : DWORD -> "int"
; lpdwBytesReceived : DWORD* out -> "var"
; lpOverlapped : OVERLAPPED* in/out -> "var"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。#uselib "MSWSOCK.dll"
#cfunc global AcceptEx "AcceptEx" sptr, sptr, sptr, int, int, int, sptr, sptr
; res = AcceptEx(sListenSocket, sAcceptSocket, lpOutputBuffer, dwReceiveDataLength, dwLocalAddressLength, dwRemoteAddressLength, varptr(lpdwBytesReceived), varptr(lpOverlapped))
; sListenSocket : SOCKET -> "sptr"
; sAcceptSocket : SOCKET -> "sptr"
; lpOutputBuffer : void* out -> "sptr"
; dwReceiveDataLength : DWORD -> "int"
; dwLocalAddressLength : DWORD -> "int"
; dwRemoteAddressLength : DWORD -> "int"
; lpdwBytesReceived : DWORD* out -> "sptr"
; lpOverlapped : OVERLAPPED* in/out -> "sptr"
; ※出力/バッファ引数はポインタ方式(token=sptr / 呼び出しは varptr(変数))。