libuv サンプル. tcp server & client. クライアントがファイル名を送り, サーバでは足元からファイルを読んでクライアントに返す.

README.md

how to compile

$ gcc -g -Wall -I /path/to/libuv/include /path/to/libuv/uv.a -framework CoreServices server.c -o server
$ gcc -g -Wall -I /path/to/libuv/include /path/to/libuv/uv.a -framework CoreServices client.c -o client

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uv.h>

#define log(x) printf("%s\n", x);

uv_loop_t *loop;

void on_connect(uv_connect_t *req, int status);
void on_write_end(uv_write_t *req, int status);
uv_buf_t alloc_buffer(uv_handle_t *handle, size_t suggested_size);
void echo_read(uv_stream_t *server, ssize_t nread, uv_buf_t buf);

// サーバからのレスポンスを表示
void echo_read(uv_stream_t *server, ssize_t nread, uv_buf_t buf) {
    if (nread == -1) {
        fprintf(stderr, "error echo_read");
        return;
    }

    // 結果を buf から取得して表示
    printf("result: %s\n", buf.base);
}

// suggeseted_size で渡された領域を確保
uv_buf_t alloc_buffer(uv_handle_t *handle, size_t suggested_size) {
    // 読み込みのためのバッファを、サジェストされたサイズで確保
    return uv_buf_init((char*) malloc(suggested_size), suggested_size);
}

// サーバへデータ送信後, サーバからのレスポンスを読み込む
void on_write_end(uv_write_t *req, int status) {
    if (status == -1) {
        fprintf(stderr, "error on_write_end");
        return;
    }

    // 書き込みが終わったら、すぐに読み込みを開始
    uv_read_start(req->handle, alloc_buffer, echo_read);
}

// サーバとの接続を確立後, サーバに文字列を送信
void on_connect(uv_connect_t *req, int status) {
    if (status == -1) {
        fprintf(stderr, "error on_write_end");
        return;
    }

    // 送信メッセージを登録
    char *message = "hello.txt";
    int len = strlen(message);

    /** これだとセグフォ
     * uv_buf_t buf[1];
     * buf[0].len = len;
     * buf[0].base = message;
     */

    // 送信データ用のバッファ
    char buffer[100];
    uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));

    // 送信データを載せる
    buf.len = len;
    buf.base = message;

    // ハンドルを取得
    uv_stream_t* tcp = req->handle;

    // 書き込み用構造体
    uv_write_t write_req;

    int buf_count = 1;
    // 書き込み
    uv_write(&write_req, tcp, &buf, buf_count, on_write_end);
}

int main(void) {
    // loop 生成
    loop = uv_default_loop();

    // Network I/O の構造体
    uv_tcp_t client;

    // loop への登録
    uv_tcp_init(loop, &client);

    // アドレスの取得
    struct sockaddr_in req_addr = uv_ip4_addr("127.0.0.1", 7000);

    // TCP コネクション用の構造体
    uv_connect_t connect_req;

    // 接続
    uv_tcp_connect(&connect_req, &client, req_addr, on_connect);

    // ループを開始
    return uv_run(loop);
}

hello.txt

hello from file on server!

server.c

#include <stdio.h>
#include <stdlib.h>
#include <uv.h>

// uv_handle_t > uv_stream_t > uv_tcp_t

const int backlog = 128;
const int buffer_size = 1024;
uv_fs_t open_req;
uv_fs_t read_req;
uv_tcp_t *client; // 接続してきたクライアント(取り回しを楽にするため

void on_new_connection(uv_stream_t *server, int status);
uv_buf_t alloc_buffer(uv_handle_t *handle, size_t suggested_size);
void on_client_read(uv_stream_t *client, ssize_t nread, uv_buf_t buf);
void on_client_write(uv_write_t *req, int status);
void on_file_open(uv_fs_t *req);
void on_file_read(uv_fs_t *req);

// クライアントと接続後, クライアントからのデータを読み込む
void on_new_connection(uv_stream_t *server, int status) {
    if (status == -1) {
        fprintf(stderr, "error on_new_connection");
        uv_close((uv_handle_t*) client, NULL);
        return;
    }

    // クライアントを保持するためのメモリを確保
    client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
    // loop への登録
    uv_tcp_init(uv_default_loop(), client);

    // accept
    int result = uv_accept(server, (uv_stream_t*) client);

    if (result == 0) { // success
        // クライアントからのデータを読みだして、alloc_buffer で確保した猟奇にに書き込み、callback を呼ぶ
        uv_read_start((uv_stream_t*) client, alloc_buffer, on_client_read);
    } else { // error
        uv_close((uv_handle_t*) client, NULL);
    }
}

// suggeseted_size で渡された領域を確保
uv_buf_t alloc_buffer(uv_handle_t *handle, size_t suggested_size) {
    return uv_buf_init((char*) malloc(suggested_size), suggested_size);
}

// tcp クライアントから受け取ったファイル名を開く
void on_client_read(uv_stream_t *_client, ssize_t nread, uv_buf_t buf) {
    if (nread == -1) {
        fprintf(stderr, "error on_client_read");
        uv_close((uv_handle_t*) client, NULL);
        return;
    }

    // クライアントから受け取ったデータ
    char *filename = buf.base;
    int mode = 0;

    // ファイルを開く
    uv_fs_open(uv_default_loop(), &open_req, filename, O_RDONLY, mode, on_file_open);
}

// client に返したあとの後片付け
void on_client_write(uv_write_t *req, int status) {
    if (status == -1) {
        fprintf(stderr, "error on_client_write");
        uv_close((uv_handle_t*) client, NULL);
        return;
    }

    // 開放
    free(req);
    char *buffer = (char*) req->data;
    free(buffer);

    // tcp connection を閉じる
    uv_close((uv_handle_t*) client, NULL);
}

// 開いたファイルの内容を読む
void on_file_open(uv_fs_t *req) {
    if (req->result == -1) {
        fprintf(stderr, "error on_file_read");
        uv_close((uv_handle_t*) client, NULL);
        return;
    }

    // ファイルから読み込んだデータを入れるバッファ
    char *buffer = (char *) malloc(sizeof(char) * buffer_size);

    // 読み込みを登録,書き込みのバッファを指定
    int offset = -1;
    // data フィールドに入れてコールバック関数に渡す
    read_req.data = (void*) buffer;
    uv_fs_read(uv_default_loop(), &read_req, req->result, buffer, sizeof(char) * buffer_size, offset, on_file_read);
    uv_fs_req_cleanup(req);
}

// ファイルの内容をクライアントに返す
void on_file_read(uv_fs_t *req) {
    if (req->result < 0) {
        fprintf(stderr, "error on_file_read");
        uv_close((uv_handle_t*) client, NULL);
    } else if (req->result == 0) { // 読み終わったら閉じる
        uv_fs_t close_req;
        uv_fs_close(uv_default_loop(), &close_req, open_req.result, NULL);
        uv_close((uv_handle_t*) client, NULL);
    } else { // 読み込んだ内容をクライアントに返す
        // 書き込み用の領域確保
        uv_write_t *write_req = (uv_write_t *) malloc(sizeof(uv_write_t));

        // クライアントに返す内容
        // req->data に入っているバッファのポインタより読み込む
        char *message = (char*) req->data;

        // uv_write 庭付 uv_buf_t の準備
        uv_buf_t buf = uv_buf_init(message, sizeof(message));
        buf.len = req->result;
        buf.base = message;
        int buf_count = 1;

        // data フィールドから on_client_write に渡す
        write_req->data = (void*) message;

        // client に buf を書き込む
        uv_write(write_req, (uv_stream_t*) client, &buf, buf_count, on_client_write);
    }
    uv_fs_req_cleanup(req);
}

int main(void) {
    // Network I/O の構造体
    uv_tcp_t server;
    // loop への登録
    uv_tcp_init(uv_default_loop(), &server);
    // アドレスの取得
    struct sockaddr_in bind_addr = uv_ip4_addr("0.0.0.0", 7000);
    // bind
    uv_tcp_bind(&server, bind_addr);

    // uv_stream_t: uv_handle_t のサブクラス uv_tcp_t の親
    // listen
    int r = uv_listen((uv_stream_t*) &server, backlog, on_new_connection);
    if (r) {
        // エラー処理
        fprintf(stderr, "error uv_listen");
        return 1;
    }

    // ループ開始
    uv_run(uv_default_loop());

    return 0;
}