概述
在上一篇博文中，我们看到了rtmp的三次握手的过程，以及nginx rtmp模块对于三次握手的实现；根据rtmp协议的定义，我们知道，在完成三次握手之后，可以进行数据的传输；
源码分析
接下来，我们接着上一篇博文继续分析源码；在完成三次握手之后，需要进行的是一些控制类消息的传输，我们看一下，nginx rtmp模块是怎么工作的；在上一篇博文中，我们说了，在完成三次握手之后，当作为服务端的时候，状态机会变为NGX_RTMP_HANDSHAKE_SERVER_DONE，当作为客户端的时候，状态机会变为NGX_RTMP_HANDSHAKE_CLIENT_DONE，翻阅源码，我们会发现，这两个状态，对应的处理函数都为ngx_rtmp_handshake_done，我们看一下在这个函数中做了什么是事情：
static void ngx_rtmp_handshake_done(ngx_rtmp_session_t *s)
{
ngx_rtmp_free_handshake_buffers(s); //释放握手分配的数据存储空间
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: done");
//发送一个握手消息完成的消息，该消息为自定义的消息，在nginx rtmp模块的子模块中，当由模块注册了该消息的话，就会做相应的处理
if (ngx_rtmp_fire_event(s, NGX_RTMP_HANDSHAKE_DONE,
NULL, NULL) != NGX_OK)
{
ngx_rtmp_finalize_session(s);
return;
}
//RTMP模块的主消息处理方法
ngx_rtmp_cycle(s);
}
上面是握手完成之后的状态机的处理方法；在上面的方法中中可以看到，在状态机完成之后，需要释放为握手分配的空间，并且发送一个通知给子模块，让子模块取做相应的处理，接着就是调用rtmp主程序的方法；接下来，让我们看一下ngx_rtmp_cycle方法：
void ngx_rtmp_cycle(ngx_rtmp_session_t *s)
{
ngx_connection_t *c;
//获取session对应的连接结构体
c = s->connection;
c->read->handler = ngx_rtmp_recv; //为该连接对象设置接受网络数据的回调函数
c->write->handler = ngx_rtmp_send; //为该连接结构体设置发网络数据的回调函数
s->ping_evt.data = c; //为该session设置ping事件的句柄
s->ping_evt.log = c->log; //设置log
s->ping_evt.handler = ngx_rtmp_ping; //当由ping事件产生的时候的处理句柄
ngx_rtmp_reset_ping(s); //充值session的ping状态
ngx_rtmp_recv(c->read); //在接受网络事件的句柄上，接收数据
}
在该方法中，需要注意，在完成握手之后，为该句柄的更改了网络事件的回调方法，所以在以握手完成之后，当产生接受数据的网络事件，会调用ngx_rtmp_recv方法，当产生发送数据的网络事件，会调用ngx_rtmp_send方法，并且需要定时的发送保活事件，也就是上面代码注释中的ping事件；接下来，我们依次介绍着三个事件，
ping事件处理方式
首先我们介绍一下ping事件，他主要涉及到上面的ngx_rtmp_reset_ping和ngx_rtmp_ping这两个方法；
//ping事件重置方法
void ngx_rtmp_reset_ping(ngx_rtmp_session_t *s)
{
ngx_rtmp_core_srv_conf_t *cscf;
//获取到rtmp的core配置文件，也就是配置项中，rtmp{}域的配置文件
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
if (cscf->ping == 0) { //当配置文件中说明不需要ping事件的话，则直接返回
return;
}
s->ping_active = 0; //设置ping状态
s->ping_reset = 0; //设置是否需要进行ping
ngx_add_timer(&s->ping_evt, cscf->ping);//将ping事件添加到定时器中,s->ping_evt指向的就是ngx_rtmp_ping方法，当定时事件产生之后，就会回调该方法
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"ping: wait %Mms", cscf->ping);
}
//ping事件处理方法
static void ngx_rtmp_ping(ngx_event_t *pev)
{
ngx_connection_t *c;
ngx_rtmp_session_t *s;
ngx_rtmp_core_srv_conf_t *cscf;
c = pev->data; //获取到事件对应的连接句柄
s = c->data; //获取到事件的session
//获取server{}域的配置文件
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
/* i/o event has happened; no need to ping */
if (s->ping_reset) { //当不需要ping的时候
ngx_rtmp_reset_ping(s);
return;
}
if (s->ping_active) { //检测ping的当前状态
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"ping: unresponded");
ngx_rtmp_finalize_session(s);
return;
}
if (cscf->busy) {
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"ping: not busy between pings");
ngx_rtmp_finalize_session(s);
return;
}
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"ping: schedule %Mms", cscf->ping_timeout);
//发送ping消息
if (ngx_rtmp_send_ping_request(s, (uint32_t)ngx_current_msec) != NGX_OK) {
ngx_rtmp_finalize_session(s);
return;
}
//设置ping状态，并加入状态机
s->ping_active = 1;
ngx_add_timer(pev, cscf->ping_timeout);
}
上面这两个方法是ping事件的整个处理方式，ping事件的存在是为了保证在长时间，与客户端之间没有消息传递的情况下，保持连接的活跃；
网络数据发送事件
接下来，我们看一下发送事件的初始方法ngx_rtmp_send，当由数据需要发送给该session对应的用户的时候，就会调用这个方法
static void ngx_rtmp_send(ngx_event_t *wev)
{
ngx_connection_t *c;
ngx_rtmp_session_t *s;
ngx_int_t n;
ngx_rtmp_core_srv_conf_t *cscf;
//写事件对应的连接句柄
c = wev->data;
s = c->data; //连接句柄对应的sesion
if (c->destroyed) { //判断连接句柄状态
return;
}
if (wev->timedout) { //检测发送数据是否超时
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"client timed out");
c->timedout = 1;
ngx_rtmp_finalize_session(s);
return;
}
if (wev->timer_set) { //重置定时器
ngx_del_timer(wev);
}
if (s->out_chain == NULL && s->out_pos != s->out_last) {//获取本本次需要发送的数据
s->out_chain = s->out[s->out_pos];
s->out_bpos = s->out_chain->buf->pos;
}
while (s->out_chain) {//获取到本次需要发送的数据之后，发送数据到网络句柄中
n = c->send(c, s->out_bpos, s->out_chain->buf->last - s->out_bpos);
if (n == NGX_AGAIN || n == 0) {
//数据发送完成之后，需要重置发送定时器，设置去除写数据事件标志
ngx_add_timer(c->write, s->timeout);
if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
ngx_rtmp_finalize_session(s);
}
return;
}
//数据发送失败
if (n < 0) {
ngx_rtmp_finalize_session(s);
return;
}
//更新网络数据统计
s->out_bytes += n;
s->ping_reset = 1;
ngx_rtmp_update_bandwidth(&ngx_rtmp_bw_out, n);
s->out_bpos += n;
if (s->out_bpos == s->out_chain->buf->last) {
s->out_chain = s->out_chain->next;
if (s->out_chain == NULL) {
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
ngx_rtmp_free_shared_chain(cscf, s->out[s->out_pos]);
++s->out_pos;
s->out_pos %= s->out_queue;
if (s->out_pos == s->out_last) {
break;
}
//获取下次发送的数据
s->out_chain = s->out[s->out_pos];
}
s->out_bpos = s->out_chain->buf->pos;
}
}
if (wev->active) { //当前写事件处于活跃状态，删除事件
ngx_del_event(wev, NGX_WRITE_EVENT, 0);
}
ngx_event_process_posted((ngx_cycle_t *) ngx_cycle, &s->posted_dry_events);
}
上面这个是写事件的处理方法，在整个方法中需要注意发送数据的获取，s->out_chain是当前需要发送的数据， s->out_bpos指向的是当前需要发送的数据的开始位置，s->out存储的是所有需要发送的数据，是一个数组；
网络数据接收事件
接下来我们看一下接受网络数据事件的处理方法ngx_rtmp_recv
static void
ngx_rtmp_recv(ngx_event_t *rev)
{
ngx_int_t n;
ngx_connection_t *c;
ngx_rtmp_session_t *s;
ngx_rtmp_core_srv_conf_t *cscf;
ngx_rtmp_header_t *h;
ngx_rtmp_stream_t *st, *st0;
ngx_chain_t *in, *head;
ngx_buf_t *b;
u_char *p, *pp, *old_pos;
size_t size, fsize, old_size;
uint8_t fmt, ext;
uint32_t csid, timestamp;
c = rev->data;
s = c->data;
b = NULL;
old_pos = NULL;
old_size = 0;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
if (c->destroyed) {
return;
}
//当由网络事件到达的时候，持续处理，知道网络事件处理结束
for( ;; ) {
//获取当前流ID(csID)的信息，s->in_csid对应于协议中的csID
st = &s->in_streams[s->in_csid];
/* allocate new buffer */
if (st->in == NULL) {//为这路流分配数据空间
st->in = ngx_rtmp_alloc_in_buf(s);
if (st->in == NULL) {
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"in buf alloc failed");
ngx_rtmp_finalize_session(s);
return;
}
}
h = &st->hdr;
in = st->in;
b = in->buf;
if (old_size) {
//如果存在老数据，就需要进行数据对其，这样是为了内存复用；也就是说这次并不是第一次处理这路流的数据，上一次处理还剩下部分为处理的数据
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
"reusing formerly read data: %d", old_size);
b->pos = b->start;
b->last = ngx_movemem(b->pos, old_pos, old_size);
if (s->in_chunk_size_changing) {
ngx_rtmp_finalize_set_chunk_size(s);
}
} else {
if (old_pos) {
b->pos = b->last = b->start;
}
//接受网络中的数据
n = c->recv(c, b->last, b->end - b->last);
if (n == NGX_ERROR || n == 0) {
ngx_rtmp_finalize_session(s);
return;
}
if (n == NGX_AGAIN) {
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_rtmp_finalize_session(s);
}
return;
}
//数据到达，则不需要在使用ping事件来保活，所以设置ping重置
s->ping_reset = 1;
ngx_rtmp_update_bandwidth(&ngx_rtmp_bw_in, n);//更新网络数据
b->last += n;
s->in_bytes += n;
if (s->in_bytes >= 0xf0000000) {//未处理的数据太多了，需要重置
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, c->log, 0,
"resetting byte counter");
s->in_bytes = 0;
s->in_last_ack = 0;
}
if (s->ack_size && s->in_bytes - s->in_last_ack >= s->ack_size) {
//检测是否需要发送ack消息，这个是基于接受数据字节长度设置的
s->in_last_ack = s->in_bytes;
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
"sending RTMP ACK(%uD)", s->in_bytes);
if (ngx_rtmp_send_ack(s, s->in_bytes)) {
ngx_rtmp_finalize_session(s);
return;
}
}
}
old_pos = NULL;
old_size = 0;
/* parse headers 开始进行数据解析，这个是解析rtmp包头*/
if (b->pos == b->start) { //当可用数据指针位置正好处于buff的开始的时候，说明整个数据包还没有进行处理，需要解析包头
p = b->pos;
/* chunk basic header */
fmt = (*p >> 6) & 0x03; //前两个bit为chunk type
csid = *p++ & 0x3f; //获取csid
if (csid == 0) { //说明csid占用1byte[64~256+64]
if (b->last - p < 1)
continue;
csid = 64;
csid += *(uint8_t*)p++;
} else if (csid == 1) {//csid占用2byte,
if (b->last - p < 2)
continue;
csid = 64;
csid += *(uint8_t*)p++;
csid += (uint32_t)256 * (*(uint8_t*)p++);
}
ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
"RTMP bheader fmt=%d csid=%D",
(int)fmt, csid);
if (csid >= (uint32_t)cscf->max_streams) {//csid值大于这个nginx-rtmp实例能处理的最大值
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"RTMP in chunk stream too big: %D >= %D",
csid, cscf->max_streams);
ngx_rtmp_finalize_session(s);
return;
}
/* link orphan */
if (s->in_csid == 0) { //为0，说明这个是本次网络事件的第一个数据包，设置流相关的参数
/* unlink from stream #0 */
st->in = st->in->next;
/* link to new stream */
s->in_csid = csid;
st = &s->in_streams[csid];//将数据加入到csid对饮的链表中去
if (st->in == NULL) {
in->next = in;
} else {
in->next = st->in->next;
st->in->next = in;
}
st->in = in;
h = &st->hdr;
h->csid = csid;
}
//时间获取
ext = st->ext;
timestamp = st->dtime;
if (fmt <= 2 ) {
if (b->last - p < 3)
continue;
/* timestamp:
* big-endian 3b -> little-endian 4b */
pp = (u_char*)×tamp;
pp[2] = *p++;
pp[1] = *p++;
pp[0] = *p++;
pp[3] = 0;
ext = (timestamp == 0x00ffffff); //判断事件是否在扩展字段中
if (fmt <= 1) {
if (b->last - p < 4)
continue;
/* size:
* big-endian 3b -> little-endian 4b
* type:
* 1b -> 1b*/
pp = (u_char*)&h->mlen;
pp[2] = *p++;
pp[1] = *p++;
pp[0] = *p++;
pp[3] = 0;
h->type = *(uint8_t*)p++;
if (fmt == 0) {
if (b->last - p < 4)
continue;
/* stream:
* little-endian 4b -> little-endian 4b */
pp = (u_char*)&h->msid;
pp[0] = *p++;
pp[1] = *p++;
pp[2] = *p++;
pp[3] = *p++;
}
}
}
/* extended header 扩展头*/
if (ext) {
if (b->last - p < 4)
continue;
pp = (u_char*)×tamp;
pp[3] = *p++;
pp[2] = *p++;
pp[1] = *p++;
pp[0] = *p++;
}
if (st->len == 0) {
/* Messages with type=3 should
* never have ext timestamp field
* according to standard.
* However that's not always the case
* in real life */
st->ext = (ext && cscf->publish_time_fix);
if (fmt) {
st->dtime = timestamp;
} else {
h->timestamp = timestamp;
st->dtime = 0;
}
}
ngx_log_debug8(NGX_LOG_DEBUG_RTMP, c->log, 0,
"RTMP mheader fmt=%d %s (%d) "
"time=%uD+%uD mlen=%D len=%D msid=%D",
(int)fmt, ngx_rtmp_message_type(h->type), (int)h->type,
h->timestamp, st->dtime, h->mlen, st->len, h->msid);
/* header done 头部处理完成，剩余的数据都是body的，这个地方是修改未处理数据的指针*/
b->pos = p;
if (h->mlen > cscf->max_message) {
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"too big message: %uz", cscf->max_message);
ngx_rtmp_finalize_session(s);
return;
}
}
size = b->last - b->pos;
fsize = h->mlen - st->len;
if (size < ngx_min(fsize, s->in_chunk_size))
continue;
/* buffer is ready */
//如果整个message中的数据长度大于chunk的size，说明当前帧还有数据没有接受完，需要调内存空间，继续接收数据
if (fsize > s->in_chunk_size) {
/* collect fragmented chunks */
st->len += s->in_chunk_size;
b->last = b->pos + s->in_chunk_size;
old_pos = b->last;
old_size = size - s->in_chunk_size;
} else {
/* handle! 针对于当前数据，已经接收完成，现在需要调用到各个子模块中去，进行处理*/
head = st->in->next;
st->in->next = NULL;
b->last = b->pos + fsize;
old_pos = b->last;
old_size = size - fsize;
st->len = 0;
h->timestamp += st->dtime;
//解析完成之后，根据MessageTypeID进行数据分发，分发到对应的子模块中去
if (ngx_rtmp_receive_message(s, h, head) != NGX_OK) {
ngx_rtmp_finalize_session(s);
return;
}
if (s->in_chunk_size_changing) {
/* copy old data to a new buffer */
if (!old_size) {
ngx_rtmp_finalize_set_chunk_size(s);
}
} else {
/* add used bufs to stream #0 */
st0 = &s->in_streams[0];
st->in->next = st0->in;
st0->in = head;
st->in = NULL;
}
}
s->in_csid = 0;
}
}
上面是针对于整个网络接收事件的处理，在接收数据的同时，完成了rtmp协议的解析，流对应位置的存储等流程，具体的请查阅上面代码的注释部分；在解析完成之后，会调用ngx_rtmp_receive_message方法，对请求进行分发处理。
扫一扫
407
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
