c语言标准库 SOCKET,[转载] 基于C/C++的WebSocket库
libwebsockets
簡介
libwebsockets 是一個純 C 語言的輕量級 WebSocket庫，它的 CPU、內存占用很小，同時支持作為服務器端/客戶端。其特性包括：支持 ws:// 和 wss:// 協議
可以選擇和 OpenSSL、CyaSSL 或者 WolfSSL 鏈接
輕量和高速，即使在每個線程處理多達250個連接的情況下
支持事件循環、零拷貝。支持 poll()、libev(epoll)、libuv
libwebsockets 提供的 API 相當底層，實現簡單的功能也需要相當冗長的代碼。
構建git clone git clone https://github.com/warmcat/libwebsockets.git
cd libwebsockets
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/home/alex/CPP/lib/libwebsockets ..
make && make install
Echo 示例
CMake 項目配置cmake_minimum_required(VERSION 2.8.9)
project(libws-study C)
include_directories(/home/alex/CPP/lib/libwebsockets/include)
set(CMAKE_CXX_FLAGS "-w -pthread")
set(SF_CLIENT client.c)
set(SF_SERVER server.c)
add_executable(client ${SF_CLIENT})
target_link_libraries(client /home/alex/CPP/lib/libwebsockets/lib/libwebsockets.so)
add_executable(server ${SF_SERVER})
target_link_libraries(server /home/alex/CPP/lib/libwebsockets/lib/libwebsockets.so)
客戶端#include "libwebsockets.h"
#include
static volatile int exit_sig = 0;
#define MAX_PAYLOAD_SIZE 10 * 1024
void sighdl( int sig ) {
lwsl_notice( "%d traped", sig );
exit_sig = 1;
}
/**
* 會話上下文對象，結構根據需要自定義
*/
struct session_data {
int msg_count;
unsigned char buf[LWS_PRE + MAX_PAYLOAD_SIZE];
int len;
};
/**
* 某個協議下的連接發生事件時，執行的回調函數
*
* wsi：指向WebSocket實例的指針
* reason：導致回調的事件
* user 庫為每個WebSocket會話分配的內存空間
* in 某些事件使用此參數，作為傳入數據的指針
* len 某些事件使用此參數，說明傳入數據的長度
*/
int callback( struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len ) {
struct session_data *data = (struct session_data *) user;
switch ( reason ) {
case LWS_CALLBACK_CLIENT_ESTABLISHED: // 連接到服務器后的回調
lwsl_notice( "Connected to server\n" );
break;
case LWS_CALLBACK_CLIENT_RECEIVE: // 接收到服務器數據后的回調，數據為in，其長度為len
lwsl_notice( "Rx: %s\n", (char *) in );
break;
case LWS_CALLBACK_CLIENT_WRITEABLE: // 當此客戶端可以發送數據時的回調
if ( data->msg_count < 3 ) {
// 前面LWS_PRE個字節必須留給LWS
memset( data->buf, 0, sizeof( data->buf ));
char *msg = (char *) &data->buf[ LWS_PRE ];
data->len = sprintf( msg, "你好 %d", ++data->msg_count );
lwsl_notice( "Tx: %s\n", msg );
// 通過WebSocket發送文本消息
lws_write( wsi, &data->buf[ LWS_PRE ], data->len, LWS_WRITE_TEXT );
}
break;
}
return 0;
}
/**
* 支持的WebSocket子協議數組
* 子協議即JavaScript客戶端WebSocket(url, protocols)第2參數數組的元素
* 你需要為每種協議提供回調函數
*/
struct lws_protocols protocols[] = {
{
//協議名稱，協議回調，接收緩沖區大小
"", callback, sizeof( struct session_data ), MAX_PAYLOAD_SIZE,
},
{
NULL, NULL, 0 // 最后一個元素固定為此格式
}
};
int main() {
// 信號處理函數
signal( SIGTERM, sighdl );
// 用于創建vhost或者context的參數
struct lws_context_creation_info ctx_info = { 0 };
ctx_info.port = CONTEXT_PORT_NO_LISTEN;
ctx_info.iface = NULL;
ctx_info.protocols = protocols;
ctx_info.gid = -1;
ctx_info.uid = -1;
// 創建一個WebSocket處理器
struct lws_context *context = lws_create_context( &ctx_info );
char *address = "192.168.0.89";
int port = 9090;
char addr_port[256] = { 0 };
sprintf( addr_port, "%s:%u", address, port & 65535 );
// 客戶端連接參數
struct lws_client_connect_info conn_info = { 0 };
conn_info.context = context;
conn_info.address = address;
conn_info.port = port;
conn_info.ssl_connection = 0;
conn_info.path = "/h264src";
conn_info.host = addr_port;
conn_info.origin = addr_port;
conn_info.protocol = protocols[ 0 ].name;
// 下面的調用觸發LWS_CALLBACK_PROTOCOL_INIT事件
// 創建一個客戶端連接
struct lws *wsi = lws_client_connect_via_info( &conn_info );
while ( !exit_sig ) {
// 執行一次事件循環(Poll)，最長等待1000毫秒
lws_service( context, 1000 );
/**
* 下面的調用的意義是：當連接可以接受新數據時，觸發一次WRITEABLE事件回調
* 當連接正在后臺發送數據時，它不能接受新的數據寫入請求，所有WRITEABLE事件回調不會執行
*/
lws_callback_on_writable( wsi );
}
// 銷毀上下文對象
lws_context_destroy( context );
return 0;
}
服務器static int protocol0_callback( struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len ) {
struct session_data *data = (struct session_data *) user;
switch ( reason ) {
case LWS_CALLBACK_ESTABLISHED: // 當服務器和客戶端完成握手后
break;
case LWS_CALLBACK_RECEIVE: // 當接收到客戶端發來的幀以后
// 判斷是否最后一幀
data->fin = lws_is_final_fragment( wsi );
// 判斷是否二進制消息
data->bin = lws_frame_is_binary( wsi );
// 對服務器的接收端進行流量控制，如果來不及處理，可以控制之
// 下面的調用禁止在此連接上接收數據
lws_rx_flow_control( wsi, 0 );
// 業務處理部分，為了實現Echo服務器，把客戶端數據保存起來
memcpy( &data->buf[ LWS_PRE ], in, len );
data->len = len;
// 需要給客戶端應答時，觸發一次寫回調
lws_callback_on_writable( wsi );
break;
case LWS_CALLBACK_SERVER_WRITEABLE: // 當此連接可寫時
lws_write( wsi, &data->buf[ LWS_PRE ], data->len, LWS_WRITE_TEXT );
// 下面的調用允許在此連接上接收數據
lws_rx_flow_control( wsi, 1 );
break;
}
// 回調函數最終要返回0，否則無法創建服務器
return 0;
}
int main() {
// 信號處理函數
signal( SIGTERM, sighdl );
struct lws_context_creation_info ctx_info = { 0 };
ctx_info.port = 9090;
ctx_info.iface = NULL; // 在所有網絡接口上監聽
ctx_info.protocols = protocols;
ctx_info.gid = -1;
ctx_info.uid = -1;
ctx_info.options = LWS_SERVER_OPTION_VALIDATE_UTF8;
struct lws_context *context = lws_create_context( &ctx_info );
while ( !exit_sig ) {
lws_service( context, 1000 );
}
lws_context_destroy( context );
}
封裝
為了簡化編程復雜度，應該考慮對libwebsockets進行適當封裝。本節給出一個簡單封裝的例子。
客戶端封裝#ifndef LIVE555_WSCLIENT_H
#define LIVE555_WSCLIENT_H
#include "libwebsockets.h"
#ifndef LWS_MAX_PAYLOAD_SIZE
#define LWS_MAX_PAYLOAD_SIZE 1024 * 1024
#endif
#ifndef SPDLOG_CONST
#define SPDLOG_CONST
const auto LOGGER = spdlog::stdout_color_st( "console" );
#endif
/**
* 通用回調函數簽名
*/
typedef void (*lws_callback)( struct lws *wsi, void *user, void *in, size_t len );
// 用戶數據對象
typedef struct lws_user_data {
// 緩沖區
unsigned char *buf;
// 緩沖區有效字節數
int len;
// 用戶自定義數據
void *user;
// 讀寫緩沖區之前需要加鎖
volatile bool locked;
// 指示當前緩沖區的數據的重要性，如果為真，發送之前不得被覆蓋
volatile bool critical;
// 本次數據發送類型
lws_write_protocol type;
// 回調函數
lws_callback esta_callback;
lws_callback recv_callback;
lws_callback writ_callback;
};
void writ_callback_send_buf( struct lws *wsi, void *user, void *in, size_t len ) {
struct lws_user_data *data = (struct lws_user_data *) user;
if ( __sync_bool_compare_and_swap( &data->locked, 0, 1 )) {
unsigned char *buf;
char hex[128]= { 0 };
int writ_count;
int len = data->len;
if ( len == 0 ) goto cleanup;
buf = data->buf + LWS_PRE;
writ_count = lws_write( wsi, buf, len, data->type );
if ( data->type == LWS_WRITE_BINARY ) {
char *phex = hex;
for ( int i = 0; i < 16; i++ ) {
unsigned char c = *buf++;
sprintf( phex, "%02x ", c );
phex += 3;
}
}
LOGGER->debug( "lws_write {} bytes: {}...", writ_count, hex );
cleanup:
data->locked = 0;
data->critical = 0;
data->len = 0;
}
}
static int lws_protocol_0_callback( struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len ) {
struct lws_user_data *data = (struct lws_user_data *) user;
switch ( reason ) {
case LWS_CALLBACK_CLIENT_ESTABLISHED:
if ( data->esta_callback )data->esta_callback( wsi, user, in, len );
break;
case LWS_CALLBACK_CLIENT_RECEIVE:
if ( data->recv_callback )data->recv_callback( wsi, user, in, len );
break;
case LWS_CALLBACK_CLIENT_WRITEABLE:
if ( data->writ_callback )data->writ_callback( wsi, user, in, len );
break;
}
return 0;
}
typedef struct lws_client {
struct lws *wsi;
struct lws_context *context;
lws_user_data *data;
int *cycle;
// 連接參數
char *address;
char *path;
int port;
void (*fill_buf)( lws_client *client, void *buf, int len, lws_write_protocol type );
void (*fire_writable)( lws_client *client );
};
void fill_buf( lws_client *client, void *buf, int len, lws_write_protocol type ) {
lws_user_data *data = client->data;
data->type = type;
data->len = len;
memcpy( data->buf + LWS_PRE, buf, len );
}
void fire_writable( lws_client *client ) {
lws_callback_on_writable( client->wsi );
// 停止當前事件循環等待
lws_cancel_service( client->context );
}
void *lws_service_thread_func( void *arg ) {
lws_client *client = (lws_client *) arg;
struct lws_context_creation_info ctx_info = { 0 };
ctx_info.port = CONTEXT_PORT_NO_LISTEN;
ctx_info.iface = NULL;
const struct lws_protocols protocols[] = {
{
"", lws_protocol_0_callback, sizeof( struct lws_user_data ), LWS_MAX_PAYLOAD_SIZE, 0, 0, LWS_MAX_PAYLOAD_SIZE
},
{
NULL, NULL, 0
}
};
static const struct lws_extension exts[] = {
{
"permessage-deflate",
lws_extension_callback_pm_deflate,
"permessage-deflate; client_no_context_takeover; client_max_window_bits"
},
{ NULL, NULL, NULL /* terminator */ }
};
ctx_info.protocols = protocols;
ctx_info.extensions = exts;
ctx_info.options = LWS_SERVER_OPTION_VALIDATE_UTF8;
ctx_info.gid = -1;
ctx_info.uid = -1;
struct lws_context *context = lws_create_context( &ctx_info );
client->context = context;
char addr_port[256] = { 0 };
sprintf( addr_port, "%s:%u", client->address, client->port & 65535 );
struct lws_client_connect_info conn_info = { 0 };
conn_info.context = context;
conn_info.address = client->address;
conn_info.port = client->port;
conn_info.ssl_connection = 0;
conn_info.path = client->path;
conn_info.host = addr_port;
conn_info.origin = addr_port;
conn_info.protocol = protocols[ 0 ].name;
// 用戶數據對象由調用者提供，因為需要提供回調
conn_info.userdata = client->data;
struct lws *wsi = lws_client_connect_via_info( &conn_info );
client->wsi = wsi;
int *loop_cycle = client->cycle;
int cycle = *loop_cycle;
while ( *loop_cycle >= 0 ) {
lws_service( context, cycle );
}
lws_context_destroy( context );
}
/**
* 連接到WebSocket服務器
* @param address IP地址
* @param path 上下文路徑URL
* @param port 端口
* @param data 用戶數據
* @param loop_cycle 事件循環周期，如果大于等于0則啟動事件循環，后續將其置為-1則導致循環終止
* @return
*/
lws_client *lws_connect( char *address, char *path, int port, lws_user_data *data, int loop_cycle ) {
lws_client *client = (lws_client *) malloc( sizeof( lws_client ));
client->data = data;
client->cycle = (int *) malloc( sizeof( int ));
*client->cycle = loop_cycle;
client->address = address;
client->path = path;
client->port = port;
client->fill_buf = fill_buf;
client->fire_writable = fire_writable;
pthread_t *lws_service_thread = (pthread_t *) malloc( sizeof( pthread_t ));
pthread_create( lws_service_thread, NULL, lws_service_thread_func, client );
return client;
}
#endif
使用客戶端封裝// 創建用戶數據對象
lws_user_data *data = new lws_user_data();
data->buf = new unsigned char[LWS_PRE + LWS_MAX_PAYLOAD_SIZE];
data->writ_callback = writ_callback_send_buf_bin; // 注冊回調
// 創建客戶端
lws_client *ws_client = lws_connect( "192.168.0.89", "/h264src", 9090, data, 10 );
// 發送數據，需要同步
lws_user_data *data = client->data;
// GCC內置CAS語義
if ( __sync_bool_compare_and_swap( &data->locked, 0, 1 )) {
client->fill_buf( client, sink->recvBuf, frameSize );
client->fire_writable( client );
data->locked = 0;
}
常見問題
error on reading from skt : 104 錯誤代碼104的含義是連接被重置，我遇到這個問題的原因是，Spring的WebSocket消息緩沖區大小不足。
WebSocket++
簡介
WebSocket++ 是一個僅僅由頭文件構成的 C++ 庫，它實現了 WebSocket 協議(RFC6455)，通過它，你可以在 C++ 項目中使用 WebSocket 客戶端或者服務器。WebSocket++ 使用兩個可以相互替換的網絡傳輸模塊，其中一個基于 C++ I/O 流，另一個基于 Asio。
WebSocket++ 的主要特性包括：事件驅動的接口
支持 WSS、IPv6
靈活的依賴管理 —— Boost或者C++ 11標準庫
可移植性：Posix/Windows、32/64bit、Intel/ARM/PPC
線程安全
構建git clone https://github.com/zaphoyd/websocketpp.git
cd websocketpp
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/home/alex/CPP/lib/websocketpp ..
make && make install
Echo 示例
CMake 項目配置cmake_minimum_required(VERSION 3.6)
project(websocket__)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_FLAGS "-pthread")
add_definitions(-D_WEBSOCKETPP_CPP11_FUNCTIONAL_)
add_definitions(-D_WEBSOCKETPP_CPP11_THREAD_)
add_definitions(-D_WEBSOCKETPP_CPP11_SYSTEM_ERROR_)
add_definitions(-D_WEBSOCKETPP_CPP11_MEMORY_)
include_directories(/home/alex/CPP/lib/websocketpp/include /home/alex/CPP/lib/boost/1.65.1/include/)
set(SF_CLIENT client.cpp)
add_executable(client ${SF_CLIENT})
target_link_libraries(client /home/alex/CPP/lib/boost/1.65.1/lib/libboost_system.so)
set(SF_SERVER server.cpp)
add_executable(server ${SF_SERVER})
target_link_libraries(server /home/alex/CPP/lib/boost/1.65.1/lib/libboost_system.so)
客戶端#include
#include
#include
typedef websocketpp::client<:config::asio_client> client;
using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;
// 消息指針
typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
// 打開連接時的回調
void on_open( client *c, websocketpp::connection_hdl hdl ) {
std::string msg = "Hello 1";
// 發送文本消息
c->send( hdl, msg, websocketpp::frame::opcode::text );
c->get_alog().write( websocketpp::log::alevel::app, "Tx: " + msg );
}
// 連接失敗時的回調
void on_fail( client *c, websocketpp::connection_hdl hdl ) {
c->get_alog().write( websocketpp::log::alevel::app, "Connection Failed" );
}
// 接收到服務器發來的WebSocket消息后的回調
void on_message( client *c, websocketpp::connection_hdl hdl, message_ptr msg ) {
c->get_alog().write( websocketpp::log::alevel::app, "Rx: " + msg->get_payload());
// 關閉連接，導致事件循環退出
c->close( hdl, websocketpp::close::status::normal, "" );
}
// 關閉連接時的回調
void on_close( client *c, websocketpp::connection_hdl hdl ) {
}
int main( int argc, char *argv[] ) {
client echo_client;
// 調整日志策略
echo_client.clear_access_channels( websocketpp::log::alevel::frame_header );
echo_client.clear_access_channels( websocketpp::log::alevel::frame_payload );
std::string uri = "ws://192.168.0.89:9090/h264src";
try {
// 初始化ASIO ASIO
echo_client.init_asio();
// 注冊回調函數
echo_client.set_open_handler( std::bind( &on_open, &echo_client, ::_1 ));
echo_client.set_fail_handler( std::bind( &on_fail, &echo_client, ::_1 ));
echo_client.set_message_handler( std::bind( &on_message, &echo_client, ::_1, ::_2 ));
echo_client.set_close_handler( std::bind( &on_close, &echo_client, ::_1 ));
// 在事件循環啟動前創建一個連接對象
websocketpp::lib::error_code ec;
client::connection_ptr con = echo_client.get_connection( uri, ec );
echo_client.connect( con );
con->get_handle(); // 連接句柄，發送消息時必須要傳入
// 啟動事件循環(ASIO的io_service)，當前線程阻塞
echo_client.run();
} catch ( const std::exception &e ) {
std::cout << e.what() << std::endl;
} catch ( websocketpp::lib::error_code e ) {
std::cout << e.message() << std::endl;
} catch ( ... ) {
std::cout << "other exception" << std::endl;
}
}
服務器#include
#include
#include
typedef websocketpp::server<:config::asio> server;
typedef websocketpp::config::asio::message_type::ptr message_ptr;
using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;
void on_open( server *s, websocketpp::connection_hdl hdl ) {
// 根據連接句柄獲得連接對象
server::connection_ptr con = s->get_con_from_hdl( hdl );
// 獲得URL路徑
std::string path = con->get_resource();
s->get_alog().write( websocketpp::log::alevel::app, "Connected to path " + path );
}
void on_message( server *s, websocketpp::connection_hdl hdl, message_ptr msg ) {
s->send( hdl, msg->get_payload(), websocketpp::frame::opcode::text );
}
int main() {
server echo_server;
// 調整日志策略
echo_server.set_access_channels( websocketpp::log::alevel::all );
echo_server.clear_access_channels( websocketpp::log::alevel::frame_payload );
try {
echo_server.init_asio();
echo_server.set_open_handler( bind( &on_open, &echo_server, ::_1 ));
echo_server.set_message_handler( bind( &on_message, &echo_server, ::_1, ::_2 ));
// 在所有網絡接口的9090上監聽
echo_server.listen( 9090 );
// 啟動服務器端Accept事件循環
echo_server.start_accept();
// 啟動事件循環(ASIO的io_service)，當前線程阻塞
echo_server.run();
} catch ( websocketpp::exception const &e ) {
std::cout << e.what() << std::endl;
} catch ( ... ) {
std::cout << "other exception" << std::endl;
}
}
總結
以上是生活随笔為你收集整理的c语言标准库 SOCKET,[转载] 基于C/C++的WebSocket库的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Python爬虫自学系列（一）
- 下一篇： s3c2440移植MQTT