最近看了一些有關 libuv 的東西，另外復習了一些與同步、異步、阻塞、非阻塞，異步IO(aio)的東西， 算是技術積累吧，等有時間了整理出一個完整的文檔出來，希望在今后的編程中用到。

不多說了，本文是今后幾篇《libuv 中文編程指南》的前言，先介紹下 libuv 究竟是干什么的吧，看看 開源中國社區收錄的有關 libuv 的介紹，

libuv 是 Node 的新跨平臺抽象層，用于抽象 Windows 的 IOCP 及 Unix 的 libev。作者打算在這個庫的包含所有平臺的差異性。特性：非阻塞 TCP 套接字非阻塞命名管道UDP定時器子進程生成通過 uv_getaddrinfo 實現異步 DNS異步文件系統 API：uv_fs_*高分辨率時間：uv_hrtime正在運行程序路徑查找：uv_exepath線程池調度：uv_queue_workTTY控制的ANSI轉義代碼: uv_tty_t文件系統事件現在支持 inotify, ReadDirectoryChangesW 和 kqueue。很快會支持事件端口：uv_fs_event_t進程間的 IPC 與套接字共享：uv_write2已受支持的平臺：Microsoft Windows 操作系統，如 Windows XP SP2。使用 Visual Studio 或 MinGW 構建Linux 2.6 使用 GCC 工具鏈MacOS 使用 GCC 或 XCode 工具鏈Solaris 121 或之后版本，使用 GCC 工具鏈

《libuv 中文編程指南》翻譯自 https://github.com/nikhilm/uvbook，目前已經完成了四篇， 在線地址：http://forhappy.github.com/uvbook/，如果你訪問 github 比較慢，可以直接訪問博客園的相關頁面，我相關內容復制/粘貼過來了，為了中文表述的清晰妥當, 書中很多內容并沒有逐字逐句翻譯, 但由于中文譯者的水平有限, 本書中文版可能存在一些翻譯錯誤, 如果您發現了中文版的錯誤, 請聯系 mailto:haipingf@gmail.com. 如果你想參考本書原始文檔, 請訪問本書的英文頁面An Introduction to libuv.。以下是前四篇的鏈接，不過博客園的頁面缺少 CSS 樣式，所以不太美觀，還是建議去 github 上面直接瀏覽。

libuv 中文編程指南(一)序言

libuv 中文編程指南(二)libuv 基礎

libuv 中文編程指南(三)文件系統

libuv 中文編程指南(四)網絡

另外四篇我會在完成翻譯后一起更新，如果你也想一起翻譯文檔，可以 fork 倉庫 https://github.com/forhappy/uvbook，共同完善這份文檔 ；-）

序言

本書由一系列 libuv 教程組成， libuv 是一個高性能事件驅動的程序庫，封裝了 Windows 和 Unix 平臺一些底層特性，為開發者提供了統一的 API.

本書旨在涵蓋 libuv 的主要特性, 并不是一份完整介紹 libuv 內部每個 API 和數據結構的指南, 官方文檔 official libuv documentation 可以直接在 libuv 源碼提供的頭文件中找到.

本書還沒有完成，某些章節可能不完整，但我希望在我不斷完善本書同時，你也能夠從中獲益 :-)

本書為誰而寫?

如果你正在閱讀本書，你或許是:

系統開發人員, 編寫一些諸如守護進程(daemons), 網絡服務程序或者客戶端等底層應用, 你發現 libuv 的事件循環方式適合你的應用場景, 因此你決定使用 libuv.

Node.js 某一模塊的作者, 決定使用 C/C++ 封裝系統平臺某些同步或者異步 API, 并將其暴露給 Javasript, 你可以在 node.js 上下文中只使用 libuv, 但你也需要參考其他資源, 因為本書并沒有包括 v8/node.js 相關的內容.

本書假設你對 C 語言有了一定的了解。

背景

node.js 最初發起于 2009 年, 是一個可以讓 Javascript 代碼脫離瀏覽器的執行環境, libuv 使用了 Google 的V8 執行引擎 和 Marc Lehmann 的 libev. Node.js 將事件驅動的 I/O 模型與適合該模型的編程語言(Javascript)融合在了一起, 隨著 node.js 的日益流行, node.js 的開發者們也意識到應該讓 node.js 在 Windows 平臺下也能工作, 但是 libev 只能在 Unix 環境下運行. Windows 平臺上與 kqueue(FreeBSD) 或者 (e)poll(Linux) 等內核事件通知相應的機制 是 IOCP, libuv 依據不同平臺的特性(Unix 平臺為 libev, Windows 平臺為 IOCP) 給上層應用提供了統一基于 libev API 的抽象, 不過 node-v0.9.0 版本的 libuv 中 libev 的依賴已被移除, 參見:libev has been removed libuv 直接與 Unix 平臺交互.

本書代碼

本書所有代碼均可以在 Github 上獲取, Clone/Download 本書源碼，然后進入到code/ 目錄執行 make 編譯本書的例子. 書中的代碼基于 node-v0.9.8 版本的 libuv, 為了方便讀者學習，本書的源碼中也附帶了相應版本的 libuv，你可以在 libuv/ 目錄中找到源碼，libuv 會在你編譯書中的例子時被自動編譯。

文件系統

簡單的文件讀寫是通過 uv_fs_* 函數族和與之相關的uv_fs_t 結構體完成的.

libuv 提供的文件操作和 socket operations 并不相同. 套接字操作使用了操作系統本身提供了非阻塞操作, 而文件操作內部使用了阻塞函數, 但是 libuv 是在線程池中調用這些函數, 并在應用程序需要交互時通知在事件循環中注冊的監視器.

所有的文件操作函數都有兩種形式 - 同步 synchronous 和 asynchronous.

同步 synchronous 形式如果沒有指定回調函數則會被自動調用( 阻塞的 ), 函數的返回值和 Unix 系統的函數調用返回值相同(調用成功通常返回 0, 若出現錯誤則返回 -1).

而異步 asynchronous 形式則會在傳入回調函數時被調用, 并且返回 0.

讀寫文件

文件描述符可以采用如下方式獲得:

int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int mode, uv_fs_cb cb)

?

參數 flags 與 mode 和標準的 Unix flags 相同. libuv 會小心地處理 Windows 環境下的相關標志位(flags)的轉換, 所以編寫跨平臺程序時你不用擔心不同平臺上文件打開的標志位不同。

關閉文件描述符可以使用:

int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)

與文件系統相關的操作的回調函數具有如下簽名:

void callback(uv_fs_t* req);

讓我們來看看 cat 命令的一個簡單實現吧: 我們首先注冊一個在文件打開時的回調函數 (顧名思義, 該函數將在文件打開時被調用).

void on_open(uv_fs_t *req) {if (req->result != -1) {uv_fs_read(uv_default_loop(), &read_req, req->result,buffer, sizeof(buffer), -1, on_read);}else {fprintf(stderr, "error opening file: %d\n", req->errorno);}uv_fs_req_cleanup(req); }

uv_fs_t 的 result 字段在執行 us_fs_open 時代表一個文件描述符, 如果文件成功被打開, 我們開始讀取文件.

必須調用 uv_fs_req_cleanup() 來釋放 libuv 內部使用的內存空間.

void on_read(uv_fs_t *req) {uv_fs_req_cleanup(req);if (req->result < 0) {fprintf(stderr, "Read error: %s\n", uv_strerror(uv_last_error(uv_default_loop())));}else if (req->result == 0) {uv_fs_t close_req;// synchronousuv_fs_close(uv_default_loop(), &close_req, open_req.result, NULL);}else {uv_fs_write(uv_default_loop(), &write_req, 1, buffer, req->result, -1, on_write);} }

在調用 read 時, 你應該傳遞一個初始化的緩沖區, 在 read 回調函數被觸發(調用之前), 該緩沖區將會被填滿數據.

在 read 的回調函數中 result 如果是 0, 則讀取文件時遇到了文件尾(EOF), -1 則代表出現了錯誤, 而正整數則是表示成功讀取的字節數.

此處給你展示了編寫異步程序的通用模式, uv_fs_close() 是異步調用的.通常如果任務是一次性的, 或者只在程序啟動和關閉時被執行的話都可以采用同步方式執行, 因為我們期望提高 I/O 效率, 采用異步編程時程序也可以做一些基本的任務并處理多路 I/O.. 對于單個任務而言性能差異可以忽略, 但是代碼卻能大大簡化.

我們可以總結出真正的系統調用返回值一般是存放在 uv_fs_t.result.

寫入文件與上述過程類似, 使用 uv_fs_write 即可.write 的回調函數在寫入完成時被調用.. 在我們的程序中回調函數只是只是簡單地發起了下一次讀操作, 因此, 讀寫操作會通過回調函數連續進行下去.

void on_write(uv_fs_t *req) {uv_fs_req_cleanup(req);if (req->result < 0) {fprintf(stderr, "Write error: %s\n", uv_strerror(uv_last_error(uv_default_loop())));}else {uv_fs_read(uv_default_loop(), &read_req, open_req.result, buffer, sizeof(buffer), -1, on_read);} }

錯誤值通常保存在 errno 并可以通過 uv_fs_t.errorno 獲取, 但是被轉換成了標準的UV_* 錯誤碼. 目前還沒有方法直接從 errorno 解析得到錯誤消息的字符串表示.

由于文件系統和磁盤通常為了提高性能吞吐率而配置了緩沖區, libuv 中一次 ‘成功’ 的寫操作可能不會被立刻提交到磁盤上, 你可以通過uv_fs_fsync 來保證一致性.

我們再來看看 main 函數中設置的多米諾骨牌吧(原作者意指在 main 中設置回調函數后會觸發整個程序開始執行):

int main(int argc, char **argv) {uv_fs_open(uv_default_loop(), &open_req, argv[1], O_RDONLY, 0, on_open);uv_run(uv_default_loop(), UV_RUN_DEFAULT);return 0; }

文件系統相關操作(Filesystem operations)

所有的標準文件系統操作, 例如 unlink,rmdir, stat 都支持異步操作, 并且各個函數的參數非常直觀. 他們和 read/write/open 的調用模式一致, 返回值都存放在uv_fs_t.result 域. 完整的列表如下:

UV_EXTERN int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path,int flags, int mode, uv_fs_cb cb);UV_EXTERN int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file,void* buf, size_t length, int64_t offset, uv_fs_cb cb);UV_EXTERN int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file,void* buf, size_t length, int64_t offset, uv_fs_cb cb);UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path,int mode, uv_fs_cb cb);UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req,const char* path, int flags, uv_fs_cb cb);UV_EXTERN int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,const char* new_path, uv_fs_cb cb);UV_EXTERN int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file,uv_fs_cb cb);UV_EXTERN int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file,int64_t offset, uv_fs_cb cb);UV_EXTERN int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd,uv_file in_fd, int64_t in_offset, size_t length, uv_fs_cb cb);UV_EXTERN int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path,int mode, uv_fs_cb cb);UV_EXTERN int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path,double atime, double mtime, uv_fs_cb cb);UV_EXTERN int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file,double atime, double mtime, uv_fs_cb cb);UV_EXTERN int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path,uv_fs_cb cb);UV_EXTERN int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,const char* new_path, uv_fs_cb cb);

?

回調函數中應該調用 uv_fs_req_cleanup() 函數來釋放uv_fs_t 參數占用的內存.

緩沖區與流(Buffers and Streams)

libuv 中基本的 I/O 工具是流(uv_stream_t). TCP 套接字, UDP 套接字, 文件, 管道, 和進程間通信都可以作為流 的子類.

流 (Streams) 通過每個子類特定的函數來初始化, 然后可以通過如下函數進行操作:

int uv_read_start(uv_stream_t*, uv_alloc_cb alloc_cb, uv_read_cb read_cb); int uv_read_stop(uv_stream_t*); int uv_write(uv_write_t* req, uv_stream_t* handle,uv_buf_t bufs[], int bufcnt, uv_write_cb cb);

?

基于流的函數比上面介紹的文件系統相關的函數更容易使用, libuv 在調用 uv_read_start 后會自動從流中讀取數據, 直到調用了uv_read_stop.

用于保存數據的單元被抽象成了 buffer 結構 – uv_buf_t. 它其實只保存了指向真實數據的指針(uv_buf_t.base) 以及真實數據的長度 (uv_buf_t.len).uv_buf_t 本身是輕量級的, 通常作為值被傳遞給函數, 真正需要進行內存管理的是 buffer 結構中的指針所指向的真實數據, 通常由應用程序申請分配并釋放.

為了示范流的用法, 我們借助了(管道) uv_pipe_t , 這使得我們把本地文件變成了流[#]_. 下面是利用 libuv 實現的一個簡單的tee . 將所有的操作變成了異步方式后, 事件 I/O 的強大能力便展現出來. 兩個寫操作并不會阻塞對方, 但是我們必須小心地拷貝數據至緩沖區, 并確保在寫入數據之前緩沖區不被釋放.

該程序按照如下方式執行:

./uvtee <output_file>

我們在指定的文件上打開了一個管道, libuv 的文件管道默認是雙向打開的.

int main(int argc, char **argv) {loop = uv_default_loop();uv_pipe_init(loop, &stdin_pipe, 0);uv_pipe_open(&stdin_pipe, 0);uv_pipe_init(loop, &stdout_pipe, 0);uv_pipe_open(&stdout_pipe, 1);uv_fs_t file_req;int fd = uv_fs_open(loop, &file_req, argv[1], O_CREAT | O_RDWR, 0644, NULL);uv_pipe_init(loop, &file_pipe, 0);uv_pipe_open(&file_pipe, fd);uv_read_start((uv_stream_t*)&stdin_pipe, alloc_buffer, read_stdin);uv_run(loop, UV_RUN_DEFAULT);return 0; }

若是 IPC 或命名管道, uv_pipe_init() 的第三個參數應該設置為 1, 我們會在進程 一節對此作出詳細解釋. 調用 uv_pipe_open() 將文件描述符和文件關聯在了一起.

我們開始監控標準輸入 stdin. 回調函數alloc_buffer 為程序開辟了一個新的緩沖區來容納新到來的數據.read_stdin 也會被調用, 并且 uv_buf_t 作為調用參數.

uv_buf_t alloc_buffer(uv_handle_t *handle, size_t suggested_size) {return uv_buf_init((char*) malloc(suggested_size), suggested_size); }void read_stdin(uv_stream_t *stream, ssize_t nread, uv_buf_t buf) {if (nread == -1) {if (uv_last_error(loop).code == UV_EOF) {uv_close((uv_handle_t*)&stdin_pipe, NULL);uv_close((uv_handle_t*)&stdout_pipe, NULL);uv_close((uv_handle_t*)&file_pipe, NULL);}}else {if (nread > 0) {write_data((uv_stream_t*)&stdout_pipe, nread, buf, on_stdout_write);write_data((uv_stream_t*)&file_pipe, nread, buf, on_file_write);}}if (buf.base)free(buf.base); }

?

此處使用標準的 malloc 已經可以足夠, 但是你也可以指定其他的內存分配策略. 例如, node.js 使用自己特定的 slab 分配器.

在任何情況下出錯, read 回調函數 nread 參數都為 -1. 出錯原因可能是 EOF(遇到文件尾), 在此種情況下我們使用 ‘’uv_close()’’ 函數關閉所有的流,uv_close() 會根據所傳遞進來句柄的內部類型來自動處理. 如果沒有出現錯誤,nread 是一個非負數, 意味著我們可以向輸出流中寫入nread 字節的數據. 最后記住一點, 緩沖區 buffer 的分配和釋放是由應用程序負責的, 所以記得釋放不再使用的內存空間.

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 on_stdout_write(uv_write_t *req, int status) {free_write_req(req); }void on_file_write(uv_write_t *req, int status) {free_write_req(req); }void write_data(uv_stream_t *dest, size_t size, uv_buf_t buf, uv_write_cb callback) {write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));req->buf = uv_buf_init((char*) malloc(size), size);memcpy(req->buf.base, buf.base, size);uv_write((uv_write_t*) req, (uv_stream_t*)dest, &req->buf, 1, callback); }

write_data() 將讀取的數據拷貝一份至緩沖區req->buf.base, 同樣地, 當 write 完成后回調函數被調用時, 該緩沖區也并不會被傳遞到回調函數中, 所以, 為了繞過這一缺點, 我們將寫請求和緩沖區封裝在write_req_t 結構體中, 然后在回調函數中解封該結構體來獲取相關參數.

文件變更事件(File change events)

現代操作系統都提供了 API 用來在單獨的文件或文件夾上設置監視器, 當文件被修改時應用程序會得到通知, libuv 也封裝了常用的文件變更通知程序庫 [1]. 這是 libuv 中最不一致的部分了, 文件變更通知系統本身在不同的系統中實現起來差別非常大, 因此讓所有的事情在每個平臺上都完美地工作將變得異常困難, 為了給出一個示例，我寫了一個簡單的工具, 該函數按照如下命令行運行， 并監視指定的文件.

./onchange <command> <file1> [file2] ...

文件變更通知通過 uv_fs_event_init() 啟動:

while (argc-- > 2) {fprintf(stderr, "Adding watch on %s\n", argv[argc]);uv_fs_event_init(loop, (uv_fs_event_t*) malloc(sizeof(uv_fs_event_t)), argv[argc], run_command, 0);}

第三個參數是實際監控的文件或者文件夾, 最后一個參數 flags 可取值如下:

UV_FS_EVENT_WATCH_ENTRY = 1,UV_FS_EVENT_STAT = 2,UV_FS_EVENT_RECURSIVE = 3

?

若設置 UV_FS_EVENT_WATCH_ENTRY 和UV_FS_EVENT_STAT 不做任何事情(目前). 設置了UV_FS_EVENT_RECURSIVE 將會監視子文件夾(需 libuv 支持).

回調函數將接受以下參數:

uv_fs_event_t*handle - 監視器. filename

字段是該監視器需要監視的文件.

constchar *filename - 如果監視目錄, 則該參數指明該目錄中發生了變更的文件,

在 Linux 和 Windows 平臺上可以是非 null.

int flags - UV_RENAME 或UV_CHANGE.

int status - 目前為 0.

我們的例子只是簡單地打印出參數, 并通過 system 函數運行指定命令.

void run_command(uv_fs_event_t *handle, const char *filename, int events, int status) {fprintf(stderr, "Change detected in %s: ", handle->filename);if (events == UV_RENAME)fprintf(stderr, "renamed");if (events == UV_CHANGE)fprintf(stderr, "changed");fprintf(stderr, " %s\n", filename ? filename : "");system(command); }

網絡

libuv 的網絡接口與 BSD 套接字接口存在很大的不同, 某些事情在 libuv 下變得更簡單了, 并且所有接口都是都是非阻塞的, 但是原則上還是一致的. 另外 libuv 也提供了一些工具類的函數抽象了一些讓人生厭的, 重復而底層的任務,比如使用 BSD 套接字結構來建立套接字, DNS 查詢, 或者其他各種參數的設置.

libuv 中在網絡 I/O 中使用了 uv_tcp_t 和uv_udp_t 兩個結構體.

TCP

TCP 是一種面向連接的流式協議, 因此是基于 libuv 的流式基礎架構上的.

服務器(Server)

服務器端的 sockets 處理流程如下:

uv_tcp_init 初始化 TCP 監視器.

uv_tcp_bind 綁定.

在指定的監視器上調用 uv_listen 來設置回調函數, 當有新的客戶端連接到來時, libuv 就會調用設置的回調函數.

uv_accept 接受連接.

使用 stream operations 與客戶端進行通信.

以下是一個簡單的 echo 服務器的例子:

int main() {loop = uv_default_loop();uv_tcp_t server;uv_tcp_init(loop, &server);struct sockaddr_in bind_addr = uv_ip4_addr("0.0.0.0", 7000);uv_tcp_bind(&server, bind_addr);int r = uv_listen((uv_stream_t*) &server, 128, on_new_connection);if (r) {fprintf(stderr, "Listen error %s\n", uv_err_name(uv_last_error(loop)));return 1;}return uv_run(loop, UV_RUN_DEFAULT); }

你可以看到輔助函數 uv_ip4_addr 用來將人為可讀的字符串類型的 IP 地址和端口號轉換成 BSD 套接字 API 所需要的struct sockaddr_in 類型的結構. 逆變換可以使用uv_ip4_name 來完成.

對于 IPv6 來說應該使用 uv_ip6_* 形式的函數.

大部分的設置(setup)函數都是普通函數, 因為他們都是 計算密集型(CPU-bound), 直到調用了uv_listen 我們才回到 libuv 中回調函數風格.uv_listen 的第二個參數 backlog 隊列長度 – 即連接隊列最大長度.

當客戶端發起了新的連接時, 回調函數需要為客戶端套接字設置一個監視器, 并調用 uv_accept 函數將客戶端套接字與新的監視器在關聯一起. 在例子中我們將從流中讀取數據.

void on_new_connection(uv_stream_t *server, int status) {if (status == -1) {// error!return;}uv_tcp_t *client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));uv_tcp_init(loop, client);if (uv_accept(server, (uv_stream_t*) client) == 0) {uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);}else {uv_close((uv_handle_t*) client, NULL);} }

剩余部分的函數與上一節流式例子中的代碼相似, 你可以在例子程序中找到具體代碼, 如果套接字不再使用記得調用 uv_close 關閉該套接字. 如果你不再接受連接, 你可以在 uv_listen 的回調函數中關閉套接字.

客戶端(Client)

在服務器端你需要調用 bind/listen/accept, 而在客戶端你只需要調用 uv_tcp_connect.uv_tcp_connect 使用了與 uv_listen 風格相似的回調函數 uv_connect_cb 如下:

uv_tcp_t socket; uv_tcp_init(loop, &socket);uv_connect_t connect;struct sockaddr_in dest = uv_ip4_addr("127.0.0.1", 80);uv_tcp_connect(&connect, &socket, dest, on_connect);

建立連接后會調用 on_connect.

UDP

User Datagram Protocol 提供了無連接, 不可靠網絡通信協議, 因此 libuv 并不提供流式 UDP 服務, 而是通過uv_udp_t 結構體(用于接收)和 uv_udp_send_t 結構體(用于發送)以及相關的函數給開發人員提供了非阻塞的 UDP 服務. 所以, 真正讀寫 UDP 的函數與普通的流式讀寫非常相似.為了示范如何使用 UDP, 下面提供了一個簡單的例子用來從DHCP 獲取 IP 地址. – DHCP 發現.

Note

你應該以 root 用戶運行 udp-dhcp, 因為該程序使用了端口號低于 1024 的端口.

uv_loop_t *loop; uv_udp_t send_socket; uv_udp_t recv_socket;int main() {loop = uv_default_loop();uv_udp_init(loop, &recv_socket);struct sockaddr_in recv_addr = uv_ip4_addr("0.0.0.0", 68);uv_udp_bind(&recv_socket, recv_addr, 0);uv_udp_recv_start(&recv_socket, alloc_buffer, on_read);uv_udp_init(loop, &send_socket);uv_udp_bind(&send_socket, uv_ip4_addr("0.0.0.0", 0), 0);uv_udp_set_broadcast(&send_socket, 1);uv_udp_send_t send_req;uv_buf_t discover_msg = make_discover_msg(&send_req);struct sockaddr_in send_addr = uv_ip4_addr("255.255.255.255", 67);uv_udp_send(&send_req, &send_socket, &discover_msg, 1, send_addr, on_send);return uv_run(loop, UV_RUN_DEFAULT); }

0.0.0.0 地址可以綁定本機所有網口.255.255.255.255 是廣播地址, 意味著網絡包可以發送給子網中所有網口, 端口0 說明操作系統可以任意指定端口進行綁定.

首先我們在 68 號端口上設置了綁定本機所有網口的接收套接字(DHCP 客戶端), 并且設置了讀監視器. 然后我們利用相同的方法設置了一個用于發送消息的套接字. 并使用uv_udp_send 在 67 號端口上(DHCP 服務器)發送廣播消息.

設置廣播標志也是 必要 的, 不然你會得到 EACCES 錯誤[1]. 發送的具體消息與本書無關, 如果你對此感興趣, 可以參考源碼. 若出錯, 則讀寫回調函數會收到 -1 狀態碼.

由于 UDP 套接字并不和特定的對等方保持連接, 所以 read 回調函數中將會收到用于標識發送者的額外信息. 如果緩沖區是由你自己的分配的, 并且不夠容納接收的數據, 則``flags`` 標志位可能是UV_UDP_PARTIAL. 在這種情況下, 操作系統會丟棄不能容納的數據. (這也是 UDP 為你提供的特性).

void on_read(uv_udp_t *req, ssize_t nread, uv_buf_t buf, struct sockaddr *addr, unsigned flags) {if (nread == -1) {fprintf(stderr, "Read error %s\n", uv_err_name(uv_last_error(loop)));uv_close((uv_handle_t*) req, NULL);free(buf.base);return;}char sender[17] = { 0 };uv_ip4_name((struct sockaddr_in*) addr, sender, 16);fprintf(stderr, "Recv from %s\n", sender);// ... DHCP specific code free(buf.base);uv_udp_recv_stop(req); }

UDP 選項(UDP Options)

生存時間TTL(Time-to-live)

可以通過 uv_udp_set_ttl 來設置網絡數據包的生存時間(TTL).

僅使用 IPv6 協議

IPv6 套接字可以同時在 IPv4 和 IPv6 協議下進行通信. 如果你只想使用 IPv6 套接字, 在調用 uv_udp_bind6 [2] 時請傳遞 UV_UDP_IPV6ONLY 參數.

多播(Multicast)

套接字可以使用如下函數訂閱(取消訂閱)一個多播組:

UV_EXTERN int uv_udp_set_membership(uv_udp_t* handle,const char* multicast_addr, const char* interface_addr,uv_membership membership);

membership 取值可以是 UV_JOIN_GROUP 或 UV_LEAVE_GROUP.

多播包的本地回路是默認開啟的 [3], 可以使用 uv_udp_set_multicast_loop 來開啟/關閉該特性.

多播包的生存時間可以使用 uv_udp_set_multicast_ttl 來設置.

DNS 查詢(Querying DNS)

libuv 提供了異步解析 DNS 的功能, 用于替代 getaddrinfo[4]. 在回調函數中, 你可以在獲得的 IP 地址上執行普通的套接字操作. 讓我們通過一個簡單的 DNS 解析的例子來看看怎么連接 Freenode 吧:

int main() {loop = uv_default_loop();struct addrinfo hints;hints.ai_family = PF_INET;hints.ai_socktype = SOCK_STREAM;hints.ai_protocol = IPPROTO_TCP;hints.ai_flags = 0;uv_getaddrinfo_t resolver;fprintf(stderr, "irc.freenode.net is... ");int r = uv_getaddrinfo(loop, &resolver, on_resolved, "irc.freenode.net", "6667", &hints);if (r) {fprintf(stderr, "getaddrinfo call error %s\n", uv_err_name(uv_last_error(loop)));return 1;}return uv_run(loop, UV_RUN_DEFAULT); }

如果 uv_getaddrinfo 返回非零, 表示在建立連接時出錯, 你設置的回調函數不會被調用, 所有的參數將會在uv_getaddrinfo 返回后被立即釋放. 有關hostname, servname 和 hints 結構體的文檔可以在 getaddrinfo 幫助頁面中找到.

在解析回調函數中, 你可以在 struct addrinfo(s) 結構的鏈表中任取一個 IP. 這個例子也演示了如何使用 uv_tcp_connect. 你在回調函數中有必要調用 uv_freeaddrinfo.

void on_resolved(uv_getaddrinfo_t *resolver, int status, struct addrinfo *res) {if (status == -1) {fprintf(stderr, "getaddrinfo callback error %s\n", uv_err_name(uv_last_error(loop)));return;}char addr[17] = {'\0'};uv_ip4_name((struct sockaddr_in*) res->ai_addr, addr, 16);fprintf(stderr, "%s\n", addr);uv_connect_t *connect_req = (uv_connect_t*) malloc(sizeof(uv_connect_t));uv_tcp_t *socket = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));uv_tcp_init(loop, socket);connect_req->data = (void*) socket;uv_tcp_connect(connect_req, socket, *(struct sockaddr_in*) res->ai_addr, on_connect);uv_freeaddrinfo(res); }

網絡接口(Network interfaces)

系統網絡接口信息可以通過調用 uv_interface_addresses 來獲得, 下面的示例程序將打印出機器上所有網絡接口的細節信息, 因此你可以獲知網口的哪些域的信息是可以得到的, 這在你的程序啟動時綁定 IP 很方便.

#include <stdio.h> #include <uv.h>int main() {char buf[512];uv_interface_address_t *info;int count, i;uv_interface_addresses(&info, &count);i = count;printf("Number of interfaces: %d\n", count);while (i--) {uv_interface_address_t interface = info[i];printf("Name: %s\n", interface.name);printf("Internal? %s\n", interface.is_internal ? "Yes" : "No");if (interface.address.address4.sin_family == AF_INET) {uv_ip4_name(&interface.address.address4, buf, sizeof(buf));printf("IPv4 address: %s\n", buf);}else if (interface.address.address4.sin_family == AF_INET6) {uv_ip6_name(&interface.address.address6, buf, sizeof(buf));printf("IPv6 address: %s\n", buf);}printf("\n");}uv_free_interface_addresses(info, count);return 0; }

is_internal 對于回環接口來說為 true. 請注意如果物理網口使用了多個 IPv4/IPv6 地址, 那么它的名稱將會被多次報告, 因為每個地址都會報告一次.

好文要頂 關注我 收藏該文

《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀

總結

以上是生活随笔為你收集整理的libuv 中文编程指南的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。