LIBUV學習筆記（三）libuv中pipe/tty相關操作以及一個簡單的unix域回射服務器/客戶端例子

uv_pipe_t — Pipe handle

Pipe handles provide an abstraction over local domain sockets on Unix and named pipes on Windows.

libuv中的uv_pipe起到的是unix like系統中unix域socket以及windows中命名管道的抽象封裝，也就意味着我們可以使用這一工具簡單的實現進程間通訊(IPC)。

主要有以下幾個API：

int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc)

　　初始化一個pipe handle,ipc指示了該管道是否會用來進行進程間handle傳輸(這里應該指的是進程間文件描述符傳遞吧?Unix域socket之間的)。

int uv_pipe_open(uv_pipe_t* handle, uv_file file)

　　打開現存的文件描述符，會被設置成非阻塞模式

int uv_pipe_bind(uv_pipe_t* handle, const char* name)

　　綁定到路徑(名字)

void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb)

　　連接(connect)到指定pipe，並調用回調cb

int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size)

　　獲得指定pipe綁定的sockname

int uv_pipe_getpeername(const uv_pipe_t* handle, char* buffer, size_t* size)

　　獲得pipe連接的sockname(服務器端)

 

uv_tty_t — TTY handle

TTY handles represent a stream for the console.

TTY抽象綁定了指定的終端流，uv_tty_t同樣是uv_stream_t的子類

主要API有：

int uv_tty_init(uv_loop_t* loop, uv_tty_t* handle, uv_file fd, int readable)

　　tty handle初始化，fd的常用值為

　　• 0 = stdin
　　• 1 = stdout
　　• 2 = stderr

int uv_tty_set_mode(uv_tty_t* handle, uv_tty_mode_t mode)

　　改變tty模式

其他操作和普通stream差不多。

 

簡單的unix域回射服務器/客戶斷例子

libuv的官方源碼給出了一個基於uv_pipe的echo服務器端程序，我自己寫了一個基於tty和pipe的回射客戶端，下面來看源碼：

pipe-echo-server.c

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

uv_loop_t *loop;

typedef struct {
    uv_write_t req;
    uv_buf_t buf;
} write_req_t;

void free_write_req(uv_write_t *req) {
    write_req_t *wr = (write_req_t*) req;
    free(wr->buf.base);
    free(wr);
}

void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {//用於讀數據時的緩沖區分配
  buf->base = (char*)malloc(suggested_size);
  buf->len = suggested_size;
}

void echo_write(uv_write_t *req, int status) {
    if (status < 0) {
        fprintf(stderr, "Write error %s\n", uv_err_name(status));
    }
    free_write_req(req);
}

void echo_read(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
    if (nread > 0) {
        write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));
        req->buf = uv_buf_init(buf->base, nread);//這是個構造函數，這里僅僅是淺拷貝！指針只是進行了賦值而已！！！
        uv_write((uv_write_t*) req, client, &req->buf, 1, echo_write);
        return;
    }

    if (nread < 0) {
        if (nread != UV_EOF)
            fprintf(stderr, "Read error %s\n", uv_err_name(nread));
        uv_close((uv_handle_t*) client, NULL);
    }

    free(buf->base);
}

void on_new_connection(uv_stream_t *server, int status) {
    if (status == -1) {
        // error!
        return;
    }

    uv_pipe_t *client = (uv_pipe_t*) malloc(sizeof(uv_pipe_t));
    uv_pipe_init(loop, client, 0);
    if (uv_accept(server, (uv_stream_t*) client) == 0) {//accept成功之后開始讀
        uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);//開始從pipe讀（在loop中注冊讀事件），讀完回調
    }
    else {
        uv_close((uv_handle_t*) client, NULL);//出錯關閉
    }
}

void remove_sock(int sig) {
    uv_fs_t req;
    uv_fs_unlink(loop, &req, "echo.sock", NULL);//刪除操作
    exit(0);
}

int main() {
    loop = uv_default_loop();

    uv_pipe_t server;
    uv_pipe_init(loop, &server, 0);

    signal(SIGINT, remove_sock);//收到結束信號順便刪除相關pipe文件

    int r;
    if ((r = uv_pipe_bind(&server, "echo.sock"))) {//服務器端綁定unix域地址
        fprintf(stderr, "Bind error %s\n", uv_err_name(r));
        return 1;
    }
    if ((r = uv_listen((uv_stream_t*) &server, 128, on_new_connection))) {//開始連接，出現回調，enent loop由此開始
        fprintf(stderr, "Listen error %s\n", uv_err_name(r));
        return 2;
    }
    return uv_run(loop, UV_RUN_DEFAULT);
}

接下來是客戶端代碼：

pipe-echo-client.c（自己寫的，僅供參考，很多異常處理代碼都省略了）

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

uv_loop_t * loop;
uv_tty_t tty_stdin,tty_stdout;
uv_pipe_t server;

typedef struct {//該結構存在的意義就是向回調函數傳遞緩沖區地址，並及時釋放
    uv_write_t req;
    uv_buf_t buf;
} write_req_t;

void free_write_req(uv_write_t *req) {
    write_req_t *wr = (write_req_t*) req;
    free(wr->buf.base);
    free(wr);
}

void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
  buf->base = (char*)malloc(suggested_size);
  buf->len = suggested_size;
}

void write_to_stdout_cb(uv_write_t* req, int status){
    if(status){
        fprintf(stderr, "Write error %s\n", uv_strerror(status));
        exit(0);
    }
    free_write_req(req);
}

void read_from_pipe_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf){
    write_req_t *wri = (write_req_t *)malloc(sizeof(write_req_t));
    wri->buf = uv_buf_init(buf->base,nread);
    uv_write((uv_write_t*)wri,(uv_stream_t*)&tty_stdout,&wri->buf,1,write_to_stdout_cb);
}

void write_to_pipe_cb(uv_write_t* req, int status){
    if(status){
        fprintf(stderr, "Write error %s\n", uv_strerror(status));
        exit(0);
    }
    uv_read_start((uv_stream_t*)&server,alloc_buffer,read_from_pipe_cb);//再一次構造緩沖區
    free_write_req(req);//釋放動態分配的所有數據
}

void read_from_input_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf){
    write_req_t *wri = (write_req_t *)malloc(sizeof(write_req_t));//實例化新結構，主要2個作用：產生write所需的uv_write_t;臨時存儲buf（同時提供給回調函數析構方法）便於該數據的及時free
    wri->buf=uv_buf_init(buf->base, nread);//buf復制
    uv_write((uv_write_t*)wri,(uv_stream_t*)&server,&wri->buf,1,write_to_pipe_cb);//需要注意的是write調用的時候&wri->buf必須依然有效！所以這里直接用buf會出現問題！
    //write完成之后當前緩沖區也就失去了意義，於是向回調函數傳遞buf指針，並由回調函數負責析構該緩沖區
}

int main() {
    loop = uv_default_loop();
    
    uv_pipe_init(loop, &server, 1);
    uv_tty_init(loop,&tty_stdin,0,1);
    uv_tty_init(loop,&tty_stdout,1,0);

    uv_connect_t conn;
    uv_pipe_connect((uv_connect_t*)&conn,&server,"echo.sock",NULL);//連接pipe
    uv_read_start((uv_stream_t*)&tty_stdin,alloc_buffer,read_from_input_cb);//從stdin讀數據，並由此觸發回調,每次alloc_buffer回調產生一個緩沖數據結構uv_buf_t並在堆上分配數據！

    return uv_run(loop, UV_RUN_DEFAULT);
}

一些注釋已經寫在代碼旁邊了，特別需要注意的就是回調函數的調用時機與非阻塞調用的流程，以及buffer相關的操作。。。坑挺多的，也只有一步一步踩過才能真正算懂。