例 856. UDP クライアント兼サーバーの実装

// UDP ソケット (_socket) はクラスのメンバ変数として定義する
class MyClass {
private:
    SFXUDPSocket _socket;  // UDP ソケット

public:
    Void Start(Void);

    // コールバック関数
    XALLBACK_DECLARE_SFXUDPSOCKET(OnBind)
    XALLBACK_DECLARE_SFXUDPSOCKET(OnSend)
    XALLBACK_DECLARE_SFXUDPSOCKET(OnReceive)
};

Void MyClass::Start(Void)
{
    SFCError error;

    // ソケットを開く
    if ((error = _socket.Open()) == SFERR_NO_ERROR) {

        // ソケットをローカル の IP アドレスとポート番号にバインドする
        OnBind(SFERR_NO_ERROR);
    }
    return;
}

// Bind 可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXUDPSOCKET(MyClass, OnBind, error)
{
    SFXSocketAddress address(SFXInetAddress::LoopbackInetAddress(), 1024);

    // エラーが発生したかどうかチェックする
    if (error == SFERR_NO_ERROR) {

        error = _socket.Bind(address);

        switch (error) {

            case SFERR_NO_ERROR:

                // データを送信する
                OnSend(SFERR_NO_ERROR);
                break;

            case AEE_NET_WOULDBLOCK:
                // バインドがブロックされたとき

                // Bind をスケジュールする: OnBind コールバック関数を登録する
                // ※ OnBind コールバック関数は Bind 可能になれば BREW AEE により呼び出される
                _socket.ScheduleBind(XALLBACK_INTERNAL(OnBind));
                break;
        }
    }
    return;
}

// Send（データ送信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXUDPSOCKET(MyClass, OnSend, error)
{
    static ACharConst data[] = "udp!";
    SFXSocketAddress address(SFXInetAddress::LoopbackInetAddress(), 1024);
    UInt32 send_size;
    UInt32 data_size = sizeof(data) - 1;

    send_size = data_size;

    // エラーが発生したかどうかチェックする
    if (error == SFERR_NO_ERROR) {

        // データを送信する
        error = _socket.Send(address, data, &send_size);

        switch (error) {

            case SFERR_NO_ERROR:

                // 指定したサイズのデータが書き込まれたかチェックする
                // Send 関数は指定したサイズのデータを一度に書き込めないことがある
                // その場合、ここでは簡易化のためエラーとしている
                if (send_size == data_size) {

                    // データを受信する
                    OnReceive(SFERR_NO_ERROR);
                }
                else {

                    TRACE("...send failed...");
                }
                break;

            case AEE_NET_WOULDBLOCK:
                // データ送信がブロックされたとき

                // Send をスケジュールする: OnSend コールバック関数を登録する
                // ※ OnSend コールバック関数は Send 可能になれば BREW AEE により呼び出される
                _socket.ScheduleSend(XALLBACK_INTERNAL(OnSend));
                break;
        }
    }
    return;
}

// Receive（データ受信）可能が通知されるコールバック関数
XALLBACK_IMPLEMENT_SFXUDPSOCKET(MyClass, OnReceive, error)
{
    SFXSocketAddress socket;
    SFXBuffer buffer;
    UInt32 receive_size;
    UInt32 buffer_size(4);

    // エラーが発生したかどうかチェックする
    if (error == SFERR_NO_ERROR) {

        buffer.SetSize(buffer_size);
        receive_size = buffer_size;

        // データを受信する
        error = _socket.Receive(&socket, buffer.GetBuffer(), &receive_size);

        switch (error) {

            case SFERR_NO_ERROR:

                // 指定したサイズのデータが読み込まれたかチェックする
                // Receive 関数は指定したサイズのデータを一度に読み込めないことがある
                // その場合、ここでは簡易化のためエラーとしている
                if (receive_size == buffer_size) {

                    // 読み込んだデータを表示する
                    buffer.SetSize(buffer_size + 1);
                    buffer[buffer_size - 1] = '\0';
                    TRACE(":%s", SFXAnsiString(buffer).GetCString());

                    // ソケットを閉じる
                    _socket.Close();
                }
                else {

                    TRACE("...receive failed...");
                }
                break;

            case AEE_NET_WOULDBLOCK:
                // データ受信がブロックされたとき

                // Receive をスケジュールする: OnReceive コールバック関数を登録する
                // ※ OnReceive コールバック関数は Receive 可能になれば BREW AEE により呼び出される
                _socket.ScheduleReceive(XALLBACK_INTERNAL(OnReceive));
                break;
        }
    }
    return;
}