WSASendTo

関数

宛先アドレスを指定してデータグラムを送信する。

DLLWS2_32.dll呼出規約winapiSetLastErrorあり対応OSWindows 8.1 以降

シグネチャ

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

INT WSASendTo(
    SOCKET s,
    WSABUF* lpBuffers,
    DWORD dwBufferCount,
    DWORD* lpNumberOfBytesSent,   // optional
    DWORD dwFlags,
    const SOCKADDR* lpTo,   // optional
    INT iTolen,
    OVERLAPPED* lpOverlapped,   // optional
    LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine   // optional
);

パラメーター

名前	型	方向	説明
s	SOCKET	in	接続済み(または未接続)の socket を識別する記述子。
lpBuffers	WSABUF*	in	WSABUF 構造体の配列へのポインター。各 WSABUF 構造体には、バッファーへのポインターと、そのバッファーの長さ(バイト単位)が格納されます。Winsock アプリケーションでは、 WSASendTo 関数を呼び出すと、これらのバッファーの所有権はシステムに移り、アプリケーションはアクセスできなくなります。この配列は、送信操作が完了するまで有効である必要があります。
dwBufferCount	DWORD	in	lpBuffers 配列内の WSABUF 構造体の数。
lpNumberOfBytesSent	DWORD*	outoptional	I/O 操作が即座に完了した場合に、この呼び出しで送信されたバイト数へのポインター。誤った結果を避けるため、lpOverlapped パラメーターが NULL でない場合は、このパラメーターに NULL を指定してください。このパラメーターを NULL にできるのは、lpOverlapped パラメーターが NULL でない場合に限られます。
dwFlags	DWORD	in	WSASendTo 関数呼び出しの動作を変更するために使用するフラグ。
lpTo	SOCKADDR*	inoptional	SOCKADDR 構造体内の、ターゲットとなる socket のアドレスへの省略可能なポインター。
iTolen	INT	in	lpTo パラメーター内のアドレスのサイズ(バイト単位)。
lpOverlapped	OVERLAPPED*	inoutoptional	WSAOVERLAPPED 構造体へのポインター(非オーバーラップ socket では無視されます)。
lpCompletionRoutine	LPWSAOVERLAPPED_COMPLETION_ROUTINE	inoptional	送信操作が完了したときに呼び出される完了ルーチンへのポインター(非オーバーラップ socket では無視されます)。

戻り値の型: INT

公式ドキュメント

指定した宛先へ、必要に応じてオーバーラップ I/O を使用してデータを送信します。

戻り値

エラーが発生せず、送信操作が即座に完了した場合、 WSASendTo は 0 を返します。この場合、呼び出し元スレッドがアラート可能状態になった時点で完了ルーチンが呼び出されるよう、すでにスケジュールされています。それ以外の場合は SOCKET_ERROR が返され、 WSAGetLastError を呼び出すことで具体的なエラーコードを取得できます。エラーコード WSA_IO_PENDING は、オーバーラップ操作が正常に開始され、完了は後で通知されることを示します。それ以外のエラーコードは、オーバーラップ操作が正常に開始されず、完了通知が発生しないことを示します。

エラーコード	意味
WSAEACCES	要求されたアドレスがブロードキャストアドレスですが、適切なフラグが設定されていません。
WSAEADDRNOTAVAIL	リモートアドレスが有効なアドレスではありません(ADDR_ANY など)。
WSAEAFNOSUPPORT	指定されたファミリのアドレスは、この socket では使用できません。
WSAECONNRESET	UDP データグラム socket の場合、このエラーは、以前の送信操作が ICMP の "Port Unreachable" メッセージを引き起こしたことを示します。
WSAEDESTADDRREQ	宛先アドレスが必要です。
WSAEFAULT	lpBuffers、lpTo、lpOverlapped、lpNumberOfBytesSent、または lpCompletionRoutine パラメーターがユーザーアドレス空間の一部ではないか、lpTo パラメーターが小さすぎます。
WSAEHOSTUNREACH	到達不能なホストに対して socket 操作が試行されました。
WSAEINPROGRESS	ブロッキングの Windows Sockets 1.1 呼び出しが進行中であるか、サービスプロバイダーがコールバック関数をまだ処理しています。
WSAEINTR	ブロッキングの Windows Socket 1.1 呼び出しが WSACancelBlockingCall によってキャンセルされました。
WSAEINVAL	socket が bind でバインドされていないか、socket がオーバーラップフラグ付きで作成されていません。
WSAEMSGSIZE	socket がメッセージ指向であり、メッセージが基盤となるトランスポートでサポートされる最大サイズより大きくなっています。
WSAENETDOWN	ネットワークサブシステムに障害が発生しました。
WSAENETRESET	データグラム socket の場合、このエラーは TTL(time to live)が期限切れになったことを示します。
WSAENETUNREACH	現時点で、このホストからネットワークに到達できません。
WSAENOBUFS	Windows Sockets プロバイダーがバッファーのデッドロックを報告しました。
WSAENOTCONN	socket が接続されていません(コネクション指向 socket のみ)。
WSAENOTSOCK	記述子が socket ではありません。
WSAESHUTDOWN	socket がシャットダウンされています。how を SD_SEND または SD_BOTH に設定して shutdown を呼び出した後の socket では、 WSASendTo を実行できません。
WSAEWOULDBLOCK	Windows NT: オーバーラップ socket: 未処理のオーバーラップ I/O 要求が多すぎます。非オーバーラップ socket: socket が非ブロッキングとしてマークされており、送信操作を即座に完了できません。
WSANOTINITIALISED	この関数を使用する前に、 WSAStartup の呼び出しが成功している必要があります。
WSA_IO_PENDING	オーバーラップ操作が正常に開始され、完了は後で通知されます。
WSA_OPERATION_ABORTED	socket のクローズ、または WSAIoctl での SIO_FLUSH コマンドの実行により、オーバーラップ操作がキャンセルされました。

解説(Remarks)

WSASendTo 関数は、標準の sendto 関数に対して、次の 2 つの重要な点で拡張機能を提供します。

オーバーラップ socket と組み合わせて、オーバーラップ送信操作を実行できます。
複数の送信バッファーを指定できるため、スキャッター/ギャザー型の I/O に適用できます。

WSASendTo 関数は通常、s で指定したコネクションレス socket 上で、1 つ以上のバッファーに含まれるデータグラムを、lpTo パラメーターで識別される特定のピア socket へ送信するために使用します。コネクションレス socket が以前に connect 関数で特定のアドレスに接続されていた場合でも、lpTo はその特定のデータグラムについてのみ宛先アドレスを上書きします。コネクション指向 socket では、lpTo および iToLen パラメーターは無視され、この場合 WSASendTo は WSASend と同等になります。

オーバーラップ socket(WSA_FLAG_OVERLAPPED フラグ付きで WSASocket を使用して作成)では、データ送信にオーバーラップ I/O が使用されます。ただし、lpOverlapped と lpCompletionRoutine の両方が NULL の場合は、socket は非オーバーラップ socket として扱われます。バッファーがトランスポートによって消費されると、完了通知が発生します(完了ルーチンの呼び出し、またはイベントオブジェクトのシグナル設定)。操作が即座に完了しない場合、最終的な完了状態は完了ルーチンまたは WSAGetOverlappedResult を通じて取得します。

注: socket をオープンし、 setsockopt を呼び出してから sendto を呼び出すと、Windows Sockets は暗黙的に bind 関数の呼び出しを実行します。

lpOverlapped と lpCompletionRoutine の両方が NULL の場合、この関数内の socket は非オーバーラップ socket として扱われます。

非オーバーラップ socket では、最後の 2 つのパラメーター(lpOverlapped、lpCompletionRoutine)は無視され、 WSASendTo は send と同じブロッキングのセマンティクスを採用します。データはバッファーからトランスポートのバッファーへコピーされます。socket が非ブロッキングかつストリーム指向で、トランスポートのバッファーに十分な空きがない場合、 WSASendTo はアプリケーションのバッファーの一部だけが消費された状態で戻ります。同じバッファー状況でブロッキング socket の場合、 WSASendTo はアプリケーションのバッファー内容がすべて消費されるまでブロックします。

この関数がオーバーラップ方式で完了する場合、この呼び出しから戻る前に WSABUF 構造体をキャプチャするのは Winsock サービスプロバイダーの責任です。これにより、アプリケーションは lpBuffers パラメーターが指す WSABUF 配列をスタック上に構築できます。

メッセージ指向 socket では、基盤となるトランスポートの最大メッセージサイズを超えないよう注意する必要があります。この値は socket オプション SO_MAX_MSG_SIZE の値を取得することで得られます。データが長すぎて基盤となるプロトコルをアトミックに通過できない場合、エラー WSAEMSGSIZE が返され、データは送信されません。

socket がバインドされていない場合、システムによってローカルの関連付けに一意な値が割り当てられ、socket はバインド済みとしてマークされます。

socket が接続されている場合、getsockname 関数を使用して、socket に関連付けられたローカル IP アドレスとポートを特定できます。

socket が接続されていない場合、 getsockname 関数を使用して socket に関連付けられたローカルポート番号を特定できますが、返される IP アドレスは、対象プロトコルのワイルドカードアドレスに設定されます(例: IPv4 の場合は INADDR_ANY または "0.0.0.0"、IPv6 の場合は IN6ADDR_ANY_INIT または "::")。

WSASendTo が正常に完了しても、データが正常に配信されたことを示すわけではありません。

dwFlags パラメーターを使用すると、対象 socket に指定されたオプションを超えて、関数呼び出しの動作に影響を与えることができます。つまり、この関数のセマンティクスは socket オプションと dwFlags パラメーターによって決まります。後者は、次の表に示す値のいずれかをビット単位の OR 演算子で結合して構築します。

値	意味
MSG_DONTROUTE	データをルーティングの対象としないよう指定します。Windows Socket サービスプロバイダーは、このフラグを無視することを選択できます。
MSG_OOB	OOB データを送信します(SOCK_STREAM などのストリーム型 socket のみ)。
MSG_PARTIAL	lpBuffers が部分的なメッセージのみを含んでいることを指定します。部分メッセージ送信をサポートしないトランスポートでは、エラーコード WSAEOPNOTSUPP が返される点に注意してください。

注: lpOverlapped パラメーターを NULL に設定して WSASendTo のようなブロッキングの Winsock 呼び出しを行う場合、呼び出しが完了する前に Winsock がネットワークイベントを待機する必要が生じることがあります。この状況で Winsock はアラート可能な待機を実行し、同じスレッド上でスケジュールされた非同期プロシージャ呼び出し(APC)によって中断される可能性があります。同じスレッド上で進行中のブロッキング Winsock 呼び出しを中断した APC の内部から別のブロッキング Winsock 呼び出しを行うと、未定義の動作につながるため、Winsock クライアントは決して試みてはなりません。

オーバーラップ socket I/O

オーバーラップ操作が即座に完了した場合、 WSASendTo は 0 を返し、lpNumberOfBytesSent パラメーターには送信されたバイト数が設定されます。オーバーラップ操作が正常に開始され、後で完了する場合、 WSASendTo は SOCKET_ERROR を返し、エラーコード WSA_IO_PENDING を示します。この場合、lpNumberOfBytesSent は更新されません。オーバーラップ操作が完了すると、転送されたデータ量は、完了ルーチン内の cbTransferred パラメーター(指定されている場合)、または WSAGetOverlappedResult の lpcbTransfer パラメーターを通じて示されます。

注: 特定のスレッドによって開始されたすべての I/O は、そのスレッドが終了すると取り消されます。オーバーラップ socket では、操作が完了する前にスレッドがクローズされると、保留中の非同期操作が失敗する可能性があります。詳細については、ExitThread を参照してください。

オーバーラップ I/O を使用する WSASendTo 関数は、直前の WSARecv、 WSARecvFrom、 WSASend、または WSASendTo 関数の完了ルーチン内から呼び出すことができます。これにより、時間に敏感なデータ送信をプリエンプティブなコンテキスト内で完結させることができます。

lpOverlapped パラメーターは、オーバーラップ操作の間ずっと有効でなければなりません。複数の I/O 操作が同時に未処理の場合、それぞれが別個の WSAOVERLAPPED 構造体を参照する必要があります。

lpCompletionRoutine パラメーターが NULL の場合、lpOverlapped の hEvent パラメーターが有効なイベントオブジェクトハンドルを含んでいれば、オーバーラップ操作が完了したときにシグナル状態になります。アプリケーションは WSAWaitForMultipleEvents または WSAGetOverlappedResult を使用して、イベントオブジェクトを待機またはポーリングできます。

lpCompletionRoutine が NULL でない場合、hEvent パラメーターは無視され、アプリケーションが完了ルーチンへコンテキスト情報を渡すために使用できます。NULL でない lpCompletionRoutine を渡し、後で同じオーバーラップ I/O 要求に対して WSAGetOverlappedResult を呼び出す呼び出し元は、その WSAGetOverlappedResult の呼び出しで fWait パラメーターを TRUE に設定してはなりません。この場合、hEvent パラメーターの使用方法は未定義であり、hEvent パラメーターでの待機を試みると予測できない結果になります。

完了ルーチンは、Windows のファイル I/O 完了ルーチンに規定されているのと同じ規則に従います。完了ルーチンは、fAlertable パラメーターを TRUE に設定して WSAWaitForMultipleEvents 関数を呼び出したときなどに発生する、スレッドがアラート可能な待機状態になるまで呼び出されません。

トランスポートプロバイダーは、socket I/O 完了ルーチンのコンテキスト内から送信および受信操作を呼び出すことをアプリケーションに許可し、特定の socket について I/O 完了ルーチンがネストされないことを保証します。これにより、時間に敏感なデータ送信をプリエンプティブなコンテキスト内で完結させることができます。

完了ルーチンのプロトタイプは次のとおりです。


void CALLBACK CompletionROUTINE(
  IN DWORD dwError,
  IN DWORD cbTransferred,
  IN LPWSAOVERLAPPED lpOverlapped,
  IN DWORD dwFlags
);

CompletionRoutine 関数は、アプリケーション定義またはライブラリ定義の関数名のプレースホルダーです。dwError パラメーターは、lpOverlapped で示されるオーバーラップ操作の完了状態を指定します。cbTransferred パラメーターは、送信されたバイト数を指定します。現在、定義されているフラグ値はなく、dwFlags は 0 になります。この関数は値を返しません。

この関数から戻ると、この socket に対する別の保留中の完了ルーチンを呼び出すことができます。待機中のすべての完了ルーチンは、アラート可能スレッドの待機が WSA_IO_COMPLETION の戻りコードで満たされる前に呼び出されます。完了ルーチンは任意の順序で呼び出される可能性があり、必ずしもオーバーラップ操作が完了した順序と同じとは限りません。ただし、投入されたバッファーは、指定された順序と同じ順序で送信されることが保証されます。

サンプルコード

次の例は、イベントオブジェクトを使用した WSASendTo 関数の使用方法を示しています。

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <Ws2tcpip.h>
#include <stdio.h>
#include <stdlib.h>

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

int __cdecl main(int argc, char **argv)
{

    //---------------------------------------------
    // Declare and initialize variables
    WSADATA wsaData;
    WSABUF DataBuf;

    WSAOVERLAPPED Overlapped;
    SOCKET SendToSocket = INVALID_SOCKET;

    struct sockaddr_in RecvAddr;
    struct sockaddr_in LocalAddr;
    int RecvAddrSize = sizeof (RecvAddr);
    int LocalAddrSize = sizeof (LocalAddr);

    u_short Port = 27777;
    struct hostent *localHost;
    char *ip;
    
    char *targetip;
    char *targetport;

    char SendBuf[1024] = "Data buffer to send";
    int BufLen = 1024;
    DWORD BytesSent = 0;
    DWORD Flags = 0;

    int rc, err;
    int retval = 0;

    // Validate the parameters
    if (argc != 3) {
        printf("usage: %s targetip port\n", argv[0]);
        printf("  to sendto the localhost on port 27777\n");
        printf("       %s 127.0.0.1 27777\n", argv[0]);
        return 1;
    }

    targetip = argv[1];
    targetport = argv[2];

    //---------------------------------------------
    // Initialize Winsock
    // Load Winsock
    rc = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (rc != 0) {
        printf("Unable to load Winsock: %d\n", rc);
        return 1;
    }

    // Make sure the Overlapped struct is zeroed out
    SecureZeroMemory((PVOID) &Overlapped, sizeof(WSAOVERLAPPED));

    // Create an event handle and setup the overlapped structure.
    Overlapped.hEvent = WSACreateEvent();
    if (Overlapped.hEvent == WSA_INVALID_EVENT) {
        printf("WSACreateEvent failed with error: %d\n", WSAGetLastError());
        WSACleanup();
        return 1;
    }
    //---------------------------------------------
    // Create a socket for sending data
    SendToSocket =
        WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0,
                  WSA_FLAG_OVERLAPPED);
    if (SendToSocket == INVALID_SOCKET) {
        printf("socket failed with error: %d\n", WSAGetLastError());
        WSACloseEvent(Overlapped.hEvent);
        WSACleanup();
        return 1;
    }
    //---------------------------------------------
    // Set up the RecvAddr structure with the IP address of
    // the receiver (in this example case "123.123.123.1")
    // and the specified port number.
    RecvAddr.sin_family = AF_INET;

    RecvAddr.sin_addr.s_addr = inet_addr(targetip);
    if (RecvAddr.sin_addr.s_addr == INADDR_NONE)  {
        printf("The target ip address entered must be a legal IPv4 address\n");
        WSACloseEvent(Overlapped.hEvent);
        WSACleanup();
        return 1;
    }
    RecvAddr.sin_port = htons( (u_short) atoi(targetport));
    if(RecvAddr.sin_port == 0) {
        printf("The targetport must be a legal UDP port number\n");
        WSACloseEvent(Overlapped.hEvent);
        WSACleanup();
        return 1;
    }

    //---------------------------------------------
    // Set up the LocalAddr structure with the local IP address
    // and the specified port number.
    localHost = gethostbyname("");
    ip = inet_ntoa(*(struct in_addr *) *localHost->h_addr_list);

    LocalAddr.sin_family = AF_INET;
    LocalAddr.sin_addr.s_addr = inet_addr(ip);
    LocalAddr.sin_port = htons(Port);

    //---------------------------------------------
    // Bind the sending socket to the LocalAddr structure
    // that has the internet address family, local IP address
    // and specified port number.  
    rc = bind(SendToSocket, (struct sockaddr *) &LocalAddr, LocalAddrSize);
    if (rc == SOCKET_ERROR) {
        printf("bind failed with error: %d\n", WSAGetLastError());
        WSACloseEvent(Overlapped.hEvent);
        closesocket(SendToSocket);
        WSACleanup();
        return 1;
    }
    //---------------------------------------------
    // Send a datagram to the receiver
    printf("Sending datagram from IPv4 address = %s port=%d\n", 
       inet_ntoa(LocalAddr.sin_addr), ntohs(LocalAddr.sin_port) ); 
    printf("   to IPv4 address = %s port=%d\n", 
       inet_ntoa(RecvAddr.sin_addr), ntohs(RecvAddr.sin_port) ); 

//    printf("Sending a datagram...\n");
    DataBuf.len = BufLen;
    DataBuf.buf = SendBuf;
    rc = WSASendTo(SendToSocket, &DataBuf, 1,
                   &BytesSent, Flags, (SOCKADDR *) & RecvAddr,
                   RecvAddrSize, &Overlapped, NULL);

    if ((rc == SOCKET_ERROR) && (WSA_IO_PENDING != (err = WSAGetLastError()))) {
        printf("WSASendTo failed with error: %d\n", err);
        WSACloseEvent(Overlapped.hEvent);
        closesocket(SendToSocket);
        WSACleanup();
        return 1;
    }

    rc = WSAWaitForMultipleEvents(1, &Overlapped.hEvent, TRUE, INFINITE, TRUE);
    if (rc == WSA_WAIT_FAILED) {
        printf("WSAWaitForMultipleEvents failed with error: %d\n",
                WSAGetLastError());
        retval = 1;
    }

    rc = WSAGetOverlappedResult(SendToSocket, &Overlapped, &BytesSent,
                                FALSE, &Flags);
    if (rc == FALSE) {
        printf("WSASendTo failed with error: %d\n", WSAGetLastError());
        retval = 1;
    }
    else
        printf("Number of sent bytes = %d\n", BytesSent);
        
    //---------------------------------------------
    // When the application is finished sending, close the socket.
    printf("Finished sending. Closing socket.\n");
    WSACloseEvent(Overlapped.hEvent);
    closesocket(SendToSocket);
    printf("Exiting.\n");

    //---------------------------------------------
    // Clean up and quit.
    WSACleanup();
    return (retval);
}

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

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

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

各言語での呼び出し定義

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

INT WSASendTo(
    SOCKET s,
    WSABUF* lpBuffers,
    DWORD dwBufferCount,
    DWORD* lpNumberOfBytesSent,   // optional
    DWORD dwFlags,
    const SOCKADDR* lpTo,   // optional
    INT iTolen,
    OVERLAPPED* lpOverlapped,   // optional
    LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine   // optional
);

[DllImport("WS2_32.dll", SetLastError = true, ExactSpelling = true)]
static extern int WSASendTo(
    UIntPtr s,   // SOCKET
    IntPtr lpBuffers,   // WSABUF*
    uint dwBufferCount,   // DWORD
    IntPtr lpNumberOfBytesSent,   // DWORD* optional, out
    uint dwFlags,   // DWORD
    IntPtr lpTo,   // SOCKADDR* optional
    int iTolen,   // INT
    IntPtr lpOverlapped,   // OVERLAPPED* optional, in/out
    IntPtr lpCompletionRoutine   // LPWSAOVERLAPPED_COMPLETION_ROUTINE optional
);

<DllImport("WS2_32.dll", SetLastError:=True, ExactSpelling:=True)>
Public Shared Function WSASendTo(
    s As UIntPtr,   ' SOCKET
    lpBuffers As IntPtr,   ' WSABUF*
    dwBufferCount As UInteger,   ' DWORD
    lpNumberOfBytesSent As IntPtr,   ' DWORD* optional, out
    dwFlags As UInteger,   ' DWORD
    lpTo As IntPtr,   ' SOCKADDR* optional
    iTolen As Integer,   ' INT
    lpOverlapped As IntPtr,   ' OVERLAPPED* optional, in/out
    lpCompletionRoutine As IntPtr   ' LPWSAOVERLAPPED_COMPLETION_ROUTINE optional
) As Integer
End Function

' s : SOCKET
' lpBuffers : WSABUF*
' dwBufferCount : DWORD
' lpNumberOfBytesSent : DWORD* optional, out
' dwFlags : DWORD
' lpTo : SOCKADDR* optional
' iTolen : INT
' lpOverlapped : OVERLAPPED* optional, in/out
' lpCompletionRoutine : LPWSAOVERLAPPED_COMPLETION_ROUTINE optional
Declare PtrSafe Function WSASendTo Lib "ws2_32" ( _
    ByVal s As LongPtr, _
    ByVal lpBuffers As LongPtr, _
    ByVal dwBufferCount As Long, _
    ByVal lpNumberOfBytesSent As LongPtr, _
    ByVal dwFlags As Long, _
    ByVal lpTo As LongPtr, _
    ByVal iTolen As Long, _
    ByVal lpOverlapped As LongPtr, _
    ByVal lpCompletionRoutine As LongPtr) As Long
' VBA7前提(PtrSafe)。32bit Office では LongPtr→Long。Integer=16bit / Long=32bit / LongLong=64bit。

import ctypes
from ctypes import wintypes

WSASendTo = ctypes.windll.ws2_32.WSASendTo
WSASendTo.restype = ctypes.c_int
WSASendTo.argtypes = [
    ctypes.c_size_t,  # s : SOCKET
    ctypes.c_void_p,  # lpBuffers : WSABUF*
    wintypes.DWORD,  # dwBufferCount : DWORD
    ctypes.POINTER(wintypes.DWORD),  # lpNumberOfBytesSent : DWORD* optional, out
    wintypes.DWORD,  # dwFlags : DWORD
    ctypes.c_void_p,  # lpTo : SOCKADDR* optional
    ctypes.c_int,  # iTolen : INT
    ctypes.c_void_p,  # lpOverlapped : OVERLAPPED* optional, in/out
    ctypes.c_void_p,  # lpCompletionRoutine : LPWSAOVERLAPPED_COMPLETION_ROUTINE optional
]
# GetLastError: use ctypes.GetLastError() (or ctypes.WinDLL(use_last_error=True))

require 'fiddle'
require 'fiddle/import'

lib = Fiddle.dlopen('WS2_32.dll')
WSASendTo = Fiddle::Function.new(
  lib['WSASendTo'],
  [
    Fiddle::TYPE_UINTPTR_T,  # s : SOCKET
    Fiddle::TYPE_VOIDP,  # lpBuffers : WSABUF*
    -Fiddle::TYPE_INT,  # dwBufferCount : DWORD
    Fiddle::TYPE_VOIDP,  # lpNumberOfBytesSent : DWORD* optional, out
    -Fiddle::TYPE_INT,  # dwFlags : DWORD
    Fiddle::TYPE_VOIDP,  # lpTo : SOCKADDR* optional
    Fiddle::TYPE_INT,  # iTolen : INT
    Fiddle::TYPE_VOIDP,  # lpOverlapped : OVERLAPPED* optional, in/out
    Fiddle::TYPE_VOIDP,  # lpCompletionRoutine : LPWSAOVERLAPPED_COMPLETION_ROUTINE optional
  ],
  Fiddle::TYPE_INT)

#[link(name = "ws2_32")]
extern "system" {
    fn WSASendTo(
        s: usize,  // SOCKET
        lpBuffers: *mut WSABUF,  // WSABUF*
        dwBufferCount: u32,  // DWORD
        lpNumberOfBytesSent: *mut u32,  // DWORD* optional, out
        dwFlags: u32,  // DWORD
        lpTo: *const SOCKADDR,  // SOCKADDR* optional
        iTolen: i32,  // INT
        lpOverlapped: *mut OVERLAPPED,  // OVERLAPPED* optional, in/out
        lpCompletionRoutine: *const core::ffi::c_void  // LPWSAOVERLAPPED_COMPLETION_ROUTINE optional
    ) -> i32;
}
// crates: windows-sys provides ready-made bindings for this API.

$sig = @"
[DllImport("WS2_32.dll", SetLastError = true)]
public static extern int WSASendTo(UIntPtr s, IntPtr lpBuffers, uint dwBufferCount, IntPtr lpNumberOfBytesSent, uint dwFlags, IntPtr lpTo, int iTolen, IntPtr lpOverlapped, IntPtr lpCompletionRoutine);
"@
$api = Add-Type -MemberDefinition $sig -Name 'WS2_32_WSASendTo' -Namespace Win32 -PassThru
# $api::WSASendTo(s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags, lpTo, iTolen, lpOverlapped, lpCompletionRoutine)

#uselib "WS2_32.dll"
#func global WSASendTo "WSASendTo" sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr, sptr
; WSASendTo s, varptr(lpBuffers), dwBufferCount, varptr(lpNumberOfBytesSent), dwFlags, varptr(lpTo), iTolen, varptr(lpOverlapped), lpCompletionRoutine   ; 戻り値は stat
; s : SOCKET -> "sptr"
; lpBuffers : WSABUF* -> "sptr"
; dwBufferCount : DWORD -> "sptr"
; lpNumberOfBytesSent : DWORD* optional, out -> "sptr"
; dwFlags : DWORD -> "sptr"
; lpTo : SOCKADDR* optional -> "sptr"
; iTolen : INT -> "sptr"
; lpOverlapped : OVERLAPPED* optional, in/out -> "sptr"
; lpCompletionRoutine : LPWSAOVERLAPPED_COMPLETION_ROUTINE optional -> "sptr"
; ※HSP3.7は #func のため戻り値はシステム変数 stat に格納されます。

出力引数:

#uselib "WS2_32.dll"
#cfunc global WSASendTo "WSASendTo" sptr, var, int, var, int, var, int, var, sptr
; res = WSASendTo(s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags, lpTo, iTolen, lpOverlapped, lpCompletionRoutine)
; s : SOCKET -> "sptr"
; lpBuffers : WSABUF* -> "var"
; dwBufferCount : DWORD -> "int"
; lpNumberOfBytesSent : DWORD* optional, out -> "var"
; dwFlags : DWORD -> "int"
; lpTo : SOCKADDR* optional -> "var"
; iTolen : INT -> "int"
; lpOverlapped : OVERLAPPED* optional, in/out -> "var"
; lpCompletionRoutine : LPWSAOVERLAPPED_COMPLETION_ROUTINE optional -> "sptr"
; ※出力/バッファ引数は var 方式(変数を直接渡す)。varptr 方式にも切替可。#uselib "WS2_32.dll"
#cfunc global WSASendTo "WSASendTo" sptr, sptr, int, sptr, int, sptr, int, sptr, sptr
; res = WSASendTo(s, varptr(lpBuffers), dwBufferCount, varptr(lpNumberOfBytesSent), dwFlags, varptr(lpTo), iTolen, varptr(lpOverlapped), lpCompletionRoutine)
; s : SOCKET -> "sptr"
; lpBuffers : WSABUF* -> "sptr"
; dwBufferCount : DWORD -> "int"
; lpNumberOfBytesSent : DWORD* optional, out -> "sptr"
; dwFlags : DWORD -> "int"
; lpTo : SOCKADDR* optional -> "sptr"
; iTolen : INT -> "int"
; lpOverlapped : OVERLAPPED* optional, in/out -> "sptr"
; lpCompletionRoutine : LPWSAOVERLAPPED_COMPLETION_ROUTINE optional -> "sptr"
; ※出力/バッファ引数はポインタ方式(token=sptr / 呼び出しは varptr(変数))。