libnice库下载地址:
https://github.com/libnice/libnice
注:本篇中不清楚的概念的可以参考“WebRtc音视频实时通信–基本术语 ”WebRtc音视频实时通信–基本术语
libnice库是基于ICE协议实现的一套通信连接库。
主要功能是实现p2p连接及媒体数据流发送接收。其类似于webrtc源码中自带的libjingo。我们可在我们的项目中使用libnice库来实现端到端的ICE连接和数据流发送接收。以及candidates(候选地址)和SDP(媒体描述文件)的相互交换。
libnice库是基于glibc语言的,跨平台,在linux和手机端都可使用,但需依赖于glib库。
在libnice源码中包含一个examples文件目录。其中包含3个示例,分别为:
如其名日,最简单的一个使用libnice库实现P2P连接通信的示例。示例功能为
假设有AB两端想实现P2P连接:
-->A端通过访问STUN服务器获取所有candidates候选地址,
B端通过访问STUN服务器获取所有candidates候选地址,
-->2端都将各自收集到的所有候选地址复制给另一端
-->向对端发送文本数据。
类似于simple_example,只是以多线程方式实现
功能类似于前2个示例,但candidates候选地址不是直接发送给对端的,而是置于sdp文件中发送给对方的,本示例主要演示SDP文件的使用。
通过将以上示例中的文本数据的发送转换成采集到的音视频数据包,便实现了流媒体数据交互。
/*
* Example using libnice to negotiate a UDP connection between two clients,
* possibly on the same network or behind different NATs and/or stateful
* firewalls.
*
* Build:
* gcc -o simple-example simple-example.c `pkg-config --cflags --libs nice`
*
* 分别作为发送端和接收端启动示例,由(0,1)标识, 在启动示例时,输入STUN服务器地址
* $(host -4 -t A stun.stunprotocol.org | awk '{ print $4 }')
* Run two clients, one controlling and one controlled:
* simple-example 0 $(host -4 -t A stun.stunprotocol.org | awk '{ print $4 }')
* simple-example 1 $(host -4 -t A stun.stunprotocol.org | awk '{ print $4 }')
*/
#include
#include
#include
#include
#include
#include
static GMainLoop *gloop;
static GIOChannel* io_stdin;
static guint stream_id;
static const gchar *candidate_type_name[] = {"host", "srflx", "prflx", "relay"};
static const gchar *state_name[] = {"disconnected", "gathering", "connecting",
"connected", "ready", "failed"};
static int print_local_data(NiceAgent *agent, guint stream_id,
guint component_id);
static int parse_remote_data(NiceAgent *agent, guint stream_id,
guint component_id, char *line);
static void cb_candidate_gathering_done(NiceAgent *agent, guint stream_id,
gpointer data);
static void cb_new_selected_pair(NiceAgent *agent, guint stream_id,
guint component_id, gchar *lfoundation,
gchar *rfoundation, gpointer data);
static void cb_component_state_changed(NiceAgent *agent, guint stream_id,
guint component_id, guint state,
gpointer data);
static void cb_nice_recv(NiceAgent *agent, guint stream_id, guint component_id,
guint len, gchar *buf, gpointer data);
static gboolean stdin_remote_info_cb (GIOChannel *source, GIOCondition cond,
gpointer data);
static gboolean stdin_send_data_cb (GIOChannel *source, GIOCondition cond,
gpointer data);
int
main(int argc, char *argv[])
{
NiceAgent *agent; //创建一个Libnice Agent实例对象,一个agent可理解为一个连接通道
gchar *stun_addr = NULL; //STUN服务器地址
guint stun_port = 0; //STUN服务器端口
gboolean controlling;
// Parse arguments 解析输入参数以获取STUN服务器地址信息和当前端角色(控制或被控制)
if (argc > 4 || argc < 2 || argv[1][1] != '\0') {
fprintf(stderr, "Usage: %s 0|1 stun_addr [stun_port]\n", argv[0]);
return EXIT_FAILURE;
}
controlling = argv[1][0] - '0';
if (controlling != 0 && controlling != 1) {
fprintf(stderr, "Usage: %s 0|1 stun_addr [stun_port]\n", argv[0]);
return EXIT_FAILURE;
}
if (argc > 2) {
stun_addr = argv[2];
if (argc > 3)
stun_port = atoi(argv[3]);
else
stun_port = 3478;
g_debug("Using stun server '[%s]:%u'\n", stun_addr, stun_port);
}
g_networking_init();
gloop = g_main_loop_new(NULL, FALSE);
#ifdef G_OS_WIN32
io_stdin = g_io_channel_win32_new_fd(_fileno(stdin));
#else
io_stdin = g_io_channel_unix_new(fileno(stdin));
#endif
// Create the nice agent创建一个连接对象,并指定所遵循的ICE协议
agent = nice_agent_new(g_main_loop_get_context (gloop),
NICE_COMPATIBILITY_RFC5245);
if (agent == NULL)
g_error("Failed to create agent");
// Set the STUN settings and controlling mode
if (stun_addr) {
g_object_set(agent, "stun-server", stun_addr, NULL);
g_object_set(agent, "stun-server-port", stun_port, NULL);
}
g_object_set(agent, "controlling-mode", controlling, NULL);
// Connect to the signals
// 为agent绑定事件响应,本端候选地址全部收集完成时调用方法cb_candidate_gathering_done
g_signal_connect(agent, "candidate-gathering-done",
G_CALLBACK(cb_candidate_gathering_done), NULL);
// 为agent绑定事件响应,本端在接收到对端的连接候选地址,在尝试连接后,
// 发现一个新的可通信的连接地址对时,调用方法cb_new_selected_pair
// 一个可选地址对由本端一个候选地址和对端的一个候选地址组成
g_signal_connect(agent, "new-selected-pair",
G_CALLBACK(cb_new_selected_pair), NULL);
// 为agent绑定事件响应,当通道的连接状态发生变化时回调方法cb_component_state_changed
// 一个agent可包含多个component,可视为多路复用一个链路
g_signal_connect(agent, "component-state-changed",
G_CALLBACK(cb_component_state_changed), NULL);
// Create a new stream with one component
stream_id = nice_agent_add_stream(agent, 1);
if (stream_id == 0)
g_error("Failed to add stream");
// Attach to the component to receive the data
// Without this call, candidates cannot be gathered
// 为agent绑定事件响应,当agent链路的1号通道(component)接口有数据包到来时,
// 回调方法cb_nice_recv
nice_agent_attach_recv(agent, stream_id, 1,
g_main_loop_get_context (gloop), cb_nice_recv, NULL);
// Start gathering local candidates
if (!nice_agent_gather_candidates(agent, stream_id))
g_error("Failed to start candidate gathering");
g_debug("waiting for candidate-gathering-done signal...");
// Run the mainloop. Everything else will happen asynchronously
// when the candidates are done gathering.
g_main_loop_run (gloop);
g_main_loop_unref(gloop);
g_object_unref(agent);
g_io_channel_unref (io_stdin);
return EXIT_SUCCESS;
}
static void
cb_candidate_gathering_done(NiceAgent *agent, guint _stream_id,
gpointer data)
{
g_debug("SIGNAL candidate gathering done\n");
// Candidate gathering is done. Send our local candidates on stdout
printf("Copy this line to remote client:\n");
printf("\n ");
print_local_data(agent, _stream_id, 1);
printf("\n");
// Listen on stdin for the remote candidate list
printf("Enter remote data (single line, no wrapping):\n");
g_io_add_watch(io_stdin, G_IO_IN, stdin_remote_info_cb, agent);
printf("> ");
fflush (stdout);
}
static gboolean
stdin_remote_info_cb (GIOChannel *source, GIOCondition cond,
gpointer data)
{
NiceAgent *agent = data;
gchar *line = NULL;
int rval;
gboolean ret = TRUE;
if (g_io_channel_read_line (source, &line, NULL, NULL, NULL) ==
G_IO_STATUS_NORMAL) {
// Parse remote candidate list and set it on the agent
rval = parse_remote_data(agent, stream_id, 1, line);
if (rval == EXIT_SUCCESS) {
// Return FALSE so we stop listening to stdin since we parsed the
// candidates correctly
ret = FALSE;
g_debug("waiting for state READY or FAILED signal...");
} else {
fprintf(stderr, "ERROR: failed to parse remote data\n");
printf("Enter remote data (single line, no wrapping):\n");
printf("> ");
fflush (stdout);
}
g_free (line);
}
return ret;
}
static void
cb_component_state_changed(NiceAgent *agent, guint _stream_id,
guint component_id, guint state,
gpointer data)
{
g_debug("SIGNAL: state changed %d %d %s[%d]\n",
_stream_id, component_id, state_name[state], state);
if (state == NICE_COMPONENT_STATE_CONNECTED) {
NiceCandidate *local, *remote;
// Get current selected candidate pair and print IP address used
if (nice_agent_get_selected_pair (agent, _stream_id, component_id,
&local, &remote)) {
gchar ipaddr[INET6_ADDRSTRLEN];
nice_address_to_string(&local->addr, ipaddr);
printf("\nNegotiation complete: ([%s]:%d,",
ipaddr, nice_address_get_port(&local->addr));
nice_address_to_string(&remote->addr, ipaddr);
printf(" [%s]:%d)\n", ipaddr, nice_address_get_port(&remote->addr));
}
// Listen to stdin and send data written to it
printf("\nSend lines to remote (Ctrl-D to quit):\n");
g_io_add_watch(io_stdin, G_IO_IN, stdin_send_data_cb, agent);
printf("> ");
fflush (stdout);
} else if (state == NICE_COMPONENT_STATE_FAILED) {
g_main_loop_quit (gloop);
}
}
static gboolean
stdin_send_data_cb (GIOChannel *source, GIOCondition cond,
gpointer data)
{
NiceAgent *agent = data;
gchar *line = NULL;
if (g_io_channel_read_line (source, &line, NULL, NULL, NULL) ==
G_IO_STATUS_NORMAL) {
// 文本数据发送
nice_agent_send(agent, stream_id, 1, strlen(line), line);
g_free (line);
printf("> ");
fflush (stdout);
} else {
nice_agent_send(agent, stream_id, 1, 1, "\0");
// Ctrl-D was pressed.
g_main_loop_quit (gloop);
}
return TRUE;
}
static void
cb_new_selected_pair(NiceAgent *agent, guint _stream_id,
guint component_id, gchar *lfoundation,
gchar *rfoundation, gpointer data)
{
g_debug("SIGNAL: selected pair %s %s", lfoundation, rfoundation);
}
static void
cb_nice_recv(NiceAgent *agent, guint _stream_id, guint component_id,
guint len, gchar *buf, gpointer data)
{
if (len == 1 && buf[0] == '\0')
g_main_loop_quit (gloop);
printf("%.*s", len, buf);
fflush(stdout);
}
// 解析收集到的自已的或接收到的对方的candidate候选地址.一个候选地址主要由编号,优先级
// ,IP地址,端口号,网络类型等几个元素组成
static NiceCandidate *
parse_candidate(char *scand, guint _stream_id)
{
NiceCandidate *cand = NULL;
NiceCandidateType ntype;
gchar **tokens = NULL;
guint i;
tokens = g_strsplit (scand, ",", 5);
for (i = 0; tokens[i]; i++);
if (i != 5)
goto end;
for (i = 0; i < G_N_ELEMENTS (candidate_type_name); i++) {
if (strcmp(tokens[4], candidate_type_name[i]) == 0) {
ntype = i;
break;
}
}
if (i == G_N_ELEMENTS (candidate_type_name))
goto end;
cand = nice_candidate_new(ntype);
cand->component_id = 1;
cand->stream_id = _stream_id;
cand->transport = NICE_CANDIDATE_TRANSPORT_UDP;
strncpy(cand->foundation, tokens[0], NICE_CANDIDATE_MAX_FOUNDATION);
cand->foundation[NICE_CANDIDATE_MAX_FOUNDATION - 1] = 0;
cand->priority = atoi (tokens[1]);
if (!nice_address_set_from_string(&cand->addr, tokens[2])) {
g_message("failed to parse addr: %s", tokens[2]);
nice_candidate_free(cand);
cand = NULL;
goto end;
}
nice_address_set_port(&cand->addr, atoi (tokens[3]));
end:
g_strfreev(tokens);
return cand;
}
static int
print_local_data (NiceAgent *agent, guint _stream_id, guint component_id)
{
int result = EXIT_FAILURE;
gchar *local_ufrag = NULL;
gchar *local_password = NULL;
gchar ipaddr[INET6_ADDRSTRLEN];
GSList *cands = NULL, *item;
if (!nice_agent_get_local_credentials(agent, _stream_id,
&local_ufrag, &local_password))
goto end;
cands = nice_agent_get_local_candidates(agent, _stream_id, component_id);
if (cands == NULL)
goto end;
printf("%s %s", local_ufrag, local_password);
for (item = cands; item; item = item->next) {
NiceCandidate *c = (NiceCandidate *)item->data;
nice_address_to_string(&c->addr, ipaddr);
// (foundation),(prio),(addr),(port),(type)
printf(" %s,%u,%s,%u,%s",
c->foundation,
c->priority,
ipaddr,
nice_address_get_port(&c->addr),
candidate_type_name[c->type]);
}
printf("\n");
result = EXIT_SUCCESS;
end:
if (local_ufrag)
g_free(local_ufrag);
if (local_password)
g_free(local_password);
if (cands)
g_slist_free_full(cands, (GDestroyNotify)&nice_candidate_free);
return result;
}
static int
parse_remote_data(NiceAgent *agent, guint _stream_id,
guint component_id, char *line)
{
GSList *remote_candidates = NULL;
gchar **line_argv = NULL;
const gchar *ufrag = NULL;
const gchar *passwd = NULL;
int result = EXIT_FAILURE;
int i;
line_argv = g_strsplit_set (line, " \t\n", 0);
for (i = 0; line_argv && line_argv[i]; i++) {
if (strlen (line_argv[i]) == 0)
continue;
// first two args are remote ufrag and password
if (!ufrag) {
ufrag = line_argv[i];
} else if (!passwd) {
passwd = line_argv[i];
} else {
// Remaining args are serialized canidates (at least one is required)
NiceCandidate *c = parse_candidate(line_argv[i], _stream_id);
if (c == NULL) {
g_message("failed to parse candidate: %s", line_argv[i]);
goto end;
}
remote_candidates = g_slist_prepend(remote_candidates, c);
}
}
if (ufrag == NULL || passwd == NULL || remote_candidates == NULL) {
g_message("line must have at least ufrag, password, and one candidate");
goto end;
}
if (!nice_agent_set_remote_credentials(agent, _stream_id, ufrag, passwd)) {
g_message("failed to set remote credentials");
goto end;
}
// Note: this will trigger the start of negotiation.
if (nice_agent_set_remote_candidates(agent, _stream_id, component_id,
remote_candidates) < 1) {
g_message("failed to set remote candidates");
goto end;
}
result = EXIT_SUCCESS;
end:
if (line_argv != NULL)
g_strfreev(line_argv);
if (remote_candidates != NULL)
g_slist_free_full(remote_candidates, (GDestroyNotify)&nice_candidate_free);
return result;
}
在代码示例的最上方有编译运行说明。
本例仅简单的实现文本字符串的发送和接收,但借助libnice实现了P2P的连接方式,即使2端都处于局域网下也可正常通信,因示例不完善,需要手动复制一端的candidate候选地址给另一端。正式使用应同时搭建 SIP信令服务器来完成候选地址的交换。
-双方都得到对方的地址后,会进行地址间的挨个匹对,当发现一对可用的地址对时,视为连接成功。同时通道的连接状态会发生变化 connecting—-> connected —-> ready…