1. 点播的配置
假设配置文件 nginx.conf 中对 rtmp 配置如下：
# 创建的子进程数
worker_processes 1;
#error_log logs/error.log;
error_log stderr debug;
#error_log logs/error.log info;
#pid logs/nginx.pid;
#关闭以守护进程方式运行，方便进行调试
daemon off;
master_process on;
events {
worker_connections 1024;
}
rtmp {
server {
listen 1935; # rtmp传输端口
chunk_size 4096; # 数据传输块大小
application vod {
play /home/xxx/samba/nginx/vod; # 视频文件存放位置
}
}
}
2. handshake 过程
2.1 ngx_rtmp_init_connection
void ngx_rtmp_init_connection(ngx_connection_t *c)
{
ngx_uint_t i;
ngx_rtmp_port_t *port;
struct sockaddr *sa;
struct sockaddr_in *sin;
ngx_rtmp_in_addr_t *addr;
ngx_rtmp_session_t *s;
ngx_rtmp_addr_conf_t *addr_conf;
ngx_int_t unix_socket;
#if (NGX_HAVE_INET6)
struct sockaddr_in6 *sin6;
ngx_rtmp_in6_addr_t *addr6;
#endif
/* rtmp 连接的计数值加 1 */
++ngx_rtmp_naccepted;
/* find the server configuration for the address:port */
/* AF_INET only */
port = c->listening->servers;
unix_socket = 0;
if (port->naddrs > 1) {
/*
* There are several addresses on this port and one of them
* is the "*:port" wildcard so getsockname() is needed to determine
* the server address.
*
* AcceptEx() already gave this address.
*/
if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
ngx_rtmp_close_connection(c);
return;
}
sa = c->local_sockaddr;
switch (sa->sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin6 = (struct sockaddr_in6 *) sa;
addr6 = port->addrs;
/* the last address is "*" */
for (i = 0; i < port->naddrs - 1; i++) {
if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) {
break;
}
}
addr_conf = &addr6[i].conf;
break;
#endif
case AF_UNIX:
unix_socket = 1;
/* fall through */
default: /* AF_INET */
sin = (struct sockaddr_in *) sa;
addr = port->addrs;
/* the last address is "*" */
for (i = 0; i < port->naddrs - 1; i++) {
if (addr[i].addr == sin->sin_addr.s_addr) {
break;
}
}
addr_conf = &addr[i].conf;
break;
}
} else {
switch (c->local_sockaddr->sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
addr6 = port->addrs;
addr_conf = &addr6[0].conf;
break;
#endif
case AF_UNIX:
unix_socket = 1;
/* fall through */
default: /* AF_INET */
addr = port->addrs;
addr_conf = &addr[0].conf;
break;
}
}
ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%ui client connected '%V'",
c->number, &c->addr_text);
/* 创建并初始化一个 rtmp 会话 */
s = ngx_rtmp_init_session(c, addr_conf);
if (s == NULL) {
return;
}
/* only auto-pushed connections are
* done through unix socket */
s->auto_pushed = unix_socket;
/* 检测是否是开启了代理服务 */
if (addr_conf->proxy_protocol) {
ngx_rtmp_proxy_protocol(s);
} else {
/* 开始 rtmp 的握手过程 */
ngx_rtmp_handshake(s);
}
}
2.2 ngx_rtmp_init_session
ngx_rtmp_session_t *ngx_rtmp_init_session(ngx_connection_t *c, ngx_rtmp_addr_conf_t *addr_conf)
{
ngx_rtmp_session_t *s;
ngx_rtmp_core_srv_conf_t *cscf;
ngx_rtmp_error_log_ctx_t *ctx;
/* 为该会话分配内存 */
s = ngx_pcalloc(c->pool, sizeof(ngx_rtmp_session_t) +
sizeof(ngx_chain_t *) * ((ngx_rtmp_core_srv_conf_t *)
addr_conf->ctx-> srv_conf[ngx_rtmp_core_module
.ctx_index])->out_queue);
if (s == NULL) {
ngx_rtmp_close_connection(c);
return NULL;
}
/* 指向 server{} 下所属的 ngx_rtmp_conf_ctx_t 下的 main_conf 指针数组 */
s->main_conf = addr_conf->ctx->main_conf;
/* 指向 server{} 下所属的 ngx_rtmp_conf_ctx_t 下的 srv_conf 指针数组 */
s->srv_conf = addr_conf->ctx->srv_conf;
s->addr_text = &addr_conf->addr_text;
/* 将 c->data 指向该会话结构体首地址 */
c->data = s;
s->connection = c;
ctx = ngx_palloc(c->pool, sizeof(ngx_rtmp_error_log_ctx_t));
if (ctx == NULL) {
ngx_rtmp_close_connection(c);
return NULL;
}
ctx->client = &c->addr_text;
ctx->session = s;
c->log->connection = c->number;
c->log->handler = ngx_rtmp_log_error;
c->log->data = ctx;
c->log->action = NULL;
c->log_error = NGX_ERROR_INFO;
s->ctx = ngx_pcalloc(c->pool, sizeof(void *) * ngx_rtmp_max_module);
if (s->ctx == NULL) {
ngx_rtmp_close_connection(c);
return NULL;
}
/* 获取 server{} 下创建的 ngx_rtmp_core_module 模块创建的
* ngx_rtmp_core_srv_conf_t 配置项结构体，该结构体也对应着
* 当前这个server{}，因此也就保存着当前 server{} 下所有的
* 配置项 */
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
/* 输出队列的个数 */
s->out_queue = cscf->out_queue;
s->out_cork = cscf->out_cork;
s->in_streams = ngx_pcalloc(c->pool, sizeof(ngx_rtmp_stream_t)
* cscf->max_streams);
if (s->in_streams == NULL) {
ngx_rtmp_close_connection(c);
return NULL;
}
#if (nginx_version >= 1007005)
ngx_queue_init(&s->posted_dry_events);
#endif
s->epoch = ngx_current_msec;
s->timeout = cscf->timeout;
s->buflen = cscf->buflen;
/* 设置 */
ngx_rtmp_set_chunk_size(s, NGX_RTMP_DEFAULT_CHUNK_SIZE);
/* 遍历 events 数组中保存的每个 RTMP 模块的 NGX_RTMP_CONNECT 事件，
* 这里仅有 TMP_LIMIT_MODULE 设置了该事件 */
if (ngx_rtmp_fire_event(s, NGX_RTMP_CONNECT, NULL, NULL) != NGX_OK) {
ngx_rtmp_finalize_session(s);
return NULL;
}
return s;
}
2.2.1 ngx_rtmp_set_chunk_size
ngx_int_t ngx_rtmp_set_chunk_size(ngx_rtmp_session_t *s, ngx_uint_t size)
{
ngx_rtmp_core_srv_conf_t *cscf;
ngx_chain_t *li, *fli, *lo, *flo;
ngx_buf_t *bi, *bo;
ngx_int_t n;
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"setting chunk_size=%ui", size);
if (size > NGX_RTMP_MAX_CHUNK_SIZE) {
ngx_log_error(NGX_LOG_ALERT, s->connection->log, 0,
"too big RTMP chunk size:%ui", size);
return NGX_ERROR;
}
/* 获取 server{} 所属的 ngx_rtmp_conf_ctx_t 的 srv_conf[0]，即对应的
* ngx_rtmp_core_module 的srv级别配置结构体，也对应该 server{} 的 配置结构体 */
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
s->in_old_pool = s->in_pool;
/* 设置 rtmp 块的大小 */
s->in_chunk_size = size;
s->in_pool = ngx_create_pool(4096, s->connection->log);
/* copy existing chunk data */
if (s->in_old_pool) {
s->in_chunk_size_changing = 1;
s->in_streams[0].in = NULL;
for(n = 1; n < cscf->max_streams; ++n) {
/* stream buffer is circular
* for all streams except for the current one
* (which caused this chunk size change);
* we can simply ignore it */
li = s->in_streams[n].in;
if (li == NULL || li->next == NULL) {
s->in_streams[n].in = NULL;
continue;
}
/* move from last to the first */
li = li->next;
fli = li;
lo = ngx_rtmp_alloc_in_buf(s);
if (lo == NULL) {
return NGX_ERROR;
}
flo = lo;
for ( ;; ) {
bi = li->buf;
bo = lo->buf;
if (bo->end - bo->last >= bi->last - bi->pos) {
bo->last = ngx_cpymem(bo->last, bi->pos,
bi->last - bi->pos);
li = li->next;
if (li == fli) {
lo->next = flo;
s->in_streams[n].in = lo;
break;
}
continue;
}
bi->pos += (ngx_cpymem(bo->last, bi->pos,
bo->end - bo->last) - bo->last);
lo->next = ngx_rtmp_alloc_in_buf(s);
lo = lo->next;
if (lo == NULL) {
return NGX_ERROR;
}
}
}
}
return NGX_OK;
}
该函数主要是设置 s->in_chunk_size（即 rtmp 块大小） 的大小，并为 s->in_pool 重新分配一个 4096 大小的内存池，
最后检测旧的内存池中是否有块数据，有则拷贝过来。
2.2.2 ngx_rtmp_fire_event
ngx_int_t ngx_rtmp_fire_event(ngx_rtmp_session_t *s, ngx_uint_t evt,
ngx_rtmp_header_t *h, ngx_chain_t *in)
{
ngx_rtmp_core_main_conf_t *cmcf;
ngx_array_t *ch;
ngx_rtmp_handler_pt *hh;
size_t n;
/* 获取 server{} 所属的 ngx_rtmp_conf_ctx_t 的 main_conf[0]，即对应的
* ngx_rtmp_core_module 的main级别配置结构体 */
cmcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_core_module);
/* 根据 evt 的值在events数组中找到对应的存储着
* 所有 RTMP 对这类 evt 事件的回调方法，该回调
* 方法一般是在每个 RTMP 模块的 postconfiguration
* 方法中添加的 */
ch = &cmcf->events[evt];
hh = ch->elts;
for(n = 0; n < ch->nelts; ++n, ++hh) {
if (*hh && (*hh)(s, h, in) != NGX_OK) {
return NGX_ERROR;
}
}
return NGX_OK;
}
该函数主要是找到所有 RTMP 模块在 postconfiguration 方法中根据 evt 值保存在 events 数组中的回调函数，然后
一一调用它们，没有找到则返回。
2.2.3 NGX_RTMP_CONNECT 事件
该事件只有 ngx_rtmp_limit_module 模块设置有回调函数：
static ngx_int_t ngx_rtmp_limit_postconfiguration(ngx_conf_t *cf)
{
ngx_rtmp_core_main_conf_t *cmcf;
ngx_rtmp_handler_pt *h;
...
cmcf = ngx_rtmp_conf_get_module_main_conf(cf, ngx_rtmp_core_module);
h = ngx_array_push(&cmcf->events[NGX_RTMP_CONNECT]);
*h = ngx_rtmp_limit_connect;
...
}
因此，在 ngx_rtmp_fire_event 方法中调用的对应 NGX_RTMP_CONNECT 事件的回调方法为 ngx_rtmp_limit_connect:
static ngx_int_t ngx_rtmp_limit_connect(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
ngx_chain_t *in)
{
ngx_rtmp_limit_main_conf_t *lmcf;
ngx_slab_pool_t *shpool;
ngx_shm_zone_t *shm_zone;
uint32_t *nconn, n;
ngx_int_t rc;
/* 获取 server{} 所属的 ngx_rtmp_conf_ctx_t 的 main_conf 指针数组中
* ngx_rtmp_limit_module 对应的序号的 main 级别配置结构体 */
lmcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_limit_module);
/* 检测 nginx.conf 配置文件中是否设置了 max_connections 配置项，若没有
* 则直接返回 */
if (lmcf->max_conn == NGX_CONF_UNSET) {
return NGX_OK;
}
/* 下面是在配置文件有 max_connections 配置项的情况下检测当前的
* 连接数是否大于 max_connections 的值 */
shm_zone = lmcf->shm_zone;
shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
nconn = shm_zone->data;
ngx_shmtx_lock(&shpool->mutex);
n = ++*nconn;
ngx_shmtx_unlock(&shpool->mutex);
rc = n > (ngx_uint_t) lmcf->max_conn ? NGX_ERROR : NGX_OK;
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"limit: inc conection counter: %uD", n);
if (rc != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"limit: too many connections: %uD > %i",
n, lmcf->max_conn);
}
return rc;
}
2.3 ngx_rtmp_handshake
在没有开启代理服务的情况下，初始化完一个 ngx_rtmp_session_t 后，直接进行 rtmp 的 handshake 过程。
void ngx_rtmp_handshake(ngx_rtmp_session_t *s)
{
ngx_connection_t *c;
c = s->connection;
/* 设置当前连接的读写事件回调方法 */
c->read->handler = ngx_rtmp_handshake_recv;
c->write->handler = ngx_rtmp_handshake_send;
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: start server handshake");
/* 分配 handshake 过程的数据缓存 */
s->hs_buf = ngx_rtmp_alloc_handshake_buffer(s);
/* 初始化当前 handshake 的阶段 */
s->hs_stage = NGX_RTMP_HANDSHAKE_SERVER_RECV_CHALLENGE;
/* 开始读取客户端发来的 C0，C1 数据 */
ngx_rtmp_handshake_recv(c->read);
}
该函数主要设置读写事件的回调函数，分配 handhshake 过程的数据缓存空间，并初始化当前 handshake 阶段。
2.4 ngx_rtmp_handshake_recv
/* RTMP handshake :
*
* =peer1= =peer2=
* challenge ----> (.....[digest1]......) ----> 1537 bytes
* response <---- (...........[digest2]) <---- 1536 bytes
*
*
* - both packets contain random bytes except for digests
* - digest1 position is calculated on random packet bytes
* - digest2 is always at the end of the packet
*
* digest1: HMAC_SHA256(packet, peer1_partial_key)
* digest2: HMAC_SHA256(packet, HMAC_SHA256(digest1, peer2_full_key))
*/
/* Handshake keys */
static u_char
ngx_rtmp_server_key[] = {
'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
'F', 'l', 'a', 's', 'h', ' ', 'M', 'e', 'd', 'i', 'a', ' ',
'S', 'e', 'r', 'v', 'e', 'r', ' ',
'0', '0', '1',
0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1,
0x02, 0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB,
0x93, 0xB8, 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
};
static u_char
ngx_rtmp_client_key[] = {
'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
'F', 'l', 'a', 's', 'h', ' ', 'P', 'l', 'a', 'y', 'e', 'r', ' ',
'0', '0', '1',
0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1,
0x02, 0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB,
0x93, 0xB8, 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
};
static const u_char
ngx_rtmp_server_version[4] = {
0x0D, 0x0E, 0x0A, 0x0D
};
static const u_char
ngx_rtmp_client_version[4] = {
0x0C, 0x00, 0x0D, 0x0E
};
static ngx_str_t ngx_rtmp_server_full_key
= { sizeof(ngx_rtmp_server_key), ngx_rtmp_server_key };
static ngx_str_t ngx_rtmp_server_partial_key
= { 36, ngx_rtmp_server_key };
static ngx_str_t ngx_rtmp_client_full_key
= { sizeof(ngx_rtmp_client_key), ngx_rtmp_client_key };
static ngx_str_t ngx_rtmp_client_partial_key
= { 30, ngx_rtmp_client_key };
static void ngx_rtmp_handshake_recv(ngx_event_t *rev)
{
ssize_t n;
ngx_connection_t *c;
ngx_rtmp_session_t *s;
ngx_buf_t *b;
c = rev->data;
s = c->data;
/* 检测该连接是否已经被销毁了 */
if (c->destroyed) {
return;
}
/* 检测该读事件是否已经超时 */
if (rev->timedout) {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"handshake: recv: client timed out");
c->timedout = 1;
ngx_rtmp_finalize_session(s);
return;
}
/*
* 每次调用recv没有接收到客户端的数据时，都会把该事件添加到epoll的
* 读事件中，同时将该事件也添加到定时器中，并设置该读事件的回调函数为
* ngx_rtmp_handshake_recv方法，因此，当监听到客户端发送的数据而再次
* 调用该方法时，需要将该事件从定时器中移除。
*/
if (rev->timer_set) {
ngx_del_timer(rev);
}
/* b 指向 handshake 的数据缓存首地址 */
b = s->hs_buf;
/* 当 handshake 的缓存未满时 */
while (b->last != b->end) {
/* 调用 c->recv 指向的回调函数接收数据，实际调用的是
* ngx_unix_recv 方法 */
n = c->recv(c, b->last, b->end - b->last);
if (n == NGX_ERROR || n == 0) {
ngx_rtmp_finalize_session(s);
return;
}
/* 若返回值为 NGX_AGAIN，则将该读事件再次添加到定时器中，并将
* 也添加到 epoll 等监控机制中 */
if (n == NGX_AGAIN) {
ngx_add_timer(rev, s->timeout);
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_rtmp_finalize_session(s);
}
return;
}
/* 若成功接收到数据，则更新 b->last 指针 */
b->last += n;
}
/* 将该读事件从 epoll 等事件监控机制中删除 */
if (rev->active) {
ngx_del_event(rev, NGX_READ_EVENT, 0);
}
/* 接收到客户端发来的数据后，更新当前 handshake 阶段 */
++s->hs_stage;
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: stage %ui", s->hs_stage);
switch (s->hs_stage) {
/* 服务端发送 S0、S1 阶段 */
case NGX_RTMP_HANDSHAKE_SERVER_SEND_CHALLENGE:
/*
* 此时接收到包应是 client 发来的 RTMP complex handshake 的 C0 和 C1 包.
* 因此解析 C0+C1，并进行验证. */
if (ngx_rtmp_handshake_parse_challenge(s,
&ngx_rtmp_client_partial_key,
&ngx_rtmp_server_full_key) != NGX_OK)
{
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"handshake: error parsing challenge");
ngx_rtmp_finalize_session(s);
return;
}
if (s->hs_old) {
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: old-style challenge");
s->hs_buf->pos = s->hs_buf->start;
s->hs_buf->last = s->hs_buf->end;
}
/* 解析完客户端发送来的 C0 和 C1 并进行验证成功后，接着构建 S0+S1，
* 发送给客户端. */
else if (ngx_rtmp_handshake_create_challenge(s,
ngx_rtmp_server_version,
&ngx_rtmp_server_partial_key) != NGX_OK)
{
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"handshake: error creating challenge");
ngx_rtmp_finalize_session(s);
return;
}
/* 发送 S0+S1，然后该函数接着构建 S2 并发送 */
ngx_rtmp_handshake_send(c->write);
break;
/* 服务端握手结束阶段 */
case NGX_RTMP_HANDSHAKE_SERVER_DONE:
/* 这里表示接收到了客户端发来的 handshake 过程的最后一个packet C2 */
ngx_rtmp_handshake_done(s);
break;
/* 作为客户端接受响应阶段 */
case NGX_RTMP_HANDSHAKE_CLIENT_RECV_RESPONSE:
if (ngx_rtmp_handshake_parse_challenge(s,
&ngx_rtmp_server_partial_key,
&ngx_rtmp_client_full_key) != NGX_OK)
{
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"handshake: error parsing challenge");
ngx_rtmp_finalize_session(s);
return;
}
s->hs_buf->pos = s->hs_buf->last = s->hs_buf->start + 1;
ngx_rtmp_handshake_recv(c->read);
break;
/* 作为客户端发送响应阶段 */
case NGX_RTMP_HANDSHAKE_CLIENT_SEND_RESPONSE:
if (ngx_rtmp_handshake_create_response(s) != NGX_OK) {
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"handshake: response error");
ngx_rtmp_finalize_session(s);
return;
}
ngx_rtmp_handshake_send(c->write);
break;
}
}
2.5 ngx_rtmp_handshake_parse_challenge
/*
* RTMP Complex handshake:
*
* 抓包知：C0+C1共1537 bytes，C0 1 byte，C1 1536 bytes.
*
* C0: 1byte，即rtmp的版本号"x03"
*
* C1和S1包含两部分数据：key和digest，分别为如下：
* - time: 4 bytes
* - version: 4 bytes
* - key: 764 bytes
* - digest: 764 bytes
*
* key和digest的顺序是不确定的，也有可能是:(nginx-rtmp中是如下的顺序)
* - time: 4 bytes
* - version: 4 bytes
* - digest: 764 bytes
* - key: 764 bytes
*
* 764 bytes key 结构：
* - random-data: (offset) bytes
* - key-data: 128 bytes
* - random-data: (764 - offset - 128 - 4) bytes
* - offset: 4 bytes
*
* 764 bytes digest结构：
* - offset: 4 bytes
* - random-data: (offset) bytes
* - digest-data: 32 bytes
* - random-data: (764 - 4 - offset - 32) bytes
*/
static ngx_int_t ngx_rtmp_handshake_parse_challenge(ngx_rtmp_session_t *s,
ngx_str_t *peer_key, ngx_str_t *key)
{
ngx_buf_t *b;
u_char *p;
ngx_int_t offs;
/* C0或S0: 第一个字节必须是 RTMP 协议的版本号"03" */
b = s->hs_buf;
if (*b->pos != 'x03') {
ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
"handshake: unexpected RTMP version: %i",
(ngx_int_t)*b->pos);
return NGX_ERROR;
}
/* 接下来是 C1 或 S1 */
/* 版本号之后是客户端的 epoch 时间 */
++b->pos;
s->peer_epoch = 0;
ngx_rtmp_rmemcpy(&s->peer_epoch, b->pos, 4);
/* 再接下来的四字节是客户端的版本号 */
p = b->pos + 4;
ngx_log_debug5(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: peer version=%i.%i.%i.%i epoch=%uD",
(ngx_int_t)p[3], (ngx_int_t)p[2],
(ngx_int_t)p[1], (ngx_int_t)p[0],
(uint32_t)s->peer_epoch);
if (*(uint32_t *)p == 0) {
s->hs_old = 1;
return NGX_OK;
}
/* 找到key和digest，进行验证 */
offs = ngx_rtmp_find_digest(b, peer_key, 772, s->connection->log);
if (offs == NGX_ERROR) {
offs = ngx_rtmp_find_digest(b, peer_key, 8, s->connection->log);
}
if (offs == NGX_ERROR) {
ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
"handshake: digest not found");
s->hs_old = 1;
return NGX_OK;
}
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: digest found at pos=%i", offs);
/* 这里 b->pos 和 b->last 分别指向找到 digest-data 数据区的起始和结尾地址 */
b->pos += offs;
b->last = b->pos + NGX_RTMP_HANDSHAKE_KEYLEN;
/* 下面是计算服务器的 digest */
s->hs_digest = ngx_palloc(s->connection->pool, NGX_RTMP_HANDSHAKE_KEYLEN);
if (ngx_rtmp_make_digest(key, b, NULL, s->hs_digest, s->connection->log)
!= NGX_OK)
{
return NGX_ERROR;
}
return NGX_OK;
}
2.5.1 ngx_rtmp_find_digest
/* 当 base 为 772 时，此时假设 C1 数据的结构如下：
* - time: 4 bytes
* - version: 4 bytes
* - key: 764 bytes
* - digest: 764 bytes
* 此时查找 digest，base 为 772，即跳过 C1 数据的 time、version、keys 这前三部分共 772 字节的数据，
* 从 digest 数据开始查找真正的 digest-data.
*
* 当 base 为 8 时，此时假设 C1 数据的结构如下：
* - time: 4 bytes
* - version: 4 bytes
* - digest: 764 bytes
* - key: 764 bytes
* 此时查找 digest，base 为 8，即跳过 C1 数据的 time、version 这前两部分共 8 字节的数据，
* 从 digest 数据开始查找真正的 digest-data.
*
* 764 bytes digest结构：
* - offset: 4 bytes
* - random-data: (offset) bytes
* - digest-data: 32 bytes
* - random-data: (764 - 4 - offset - 32 = 728 - offset) bytes
*
* 参考上面的digest结构，查找算法是：将 digest 数据开始的前 4 字节相加得到 offs，即 offset 值，
* 然后将 offs 除以 728 后取余数，再加上 base + 4，得出 digest-data 的在 C1 数据中的偏移值
*
*/
static ngx_int_t ngx_rtmp_find_digest(ngx_buf_t *b, ngx_str_t *key, size_t base, ngx_log_t *log)
{
size_t n, offs;
u_char digest[NGX_RTMP_HANDSHAKE_KEYLEN];
u_char *p;
offs = 0;
/* 将 digest 数据开始的前 4 字节的值相加 得到 offset */
for (n = 0; n < 4; ++n) {
offs += b->pos[base + n];
}
offs = (offs % 728) + base + 4;
/* p 指向 digest-data 的起始地址 */
p = b->pos + offs;
if (ngx_rtmp_make_digest(key, b, p, digest, log) != NGX_OK) {
return NGX_ERROR;
}
/* 校验计算出来的 digest 与 p 指向的 digest-data 是否相同，相同表示校验
* 成功，即找到了正确的 digest-data 的偏移值 */
if (ngx_memcmp(digest, p, NGX_RTMP_HANDSHAKE_KEYLEN) == 0) {
return offs;
}
return NGX_ERROR;
}
2.5.2 ngx_rtmp_make_digest
static ngx_int_t ngx_rtmp_make_digest(ngx_str_t *key, ngx_buf_t *src,
u_char *skip, u_char *dst, ngx_log_t *log)
{
static HMAC_CTX *hmac;
unsigned int len;
if (hmac == NULL) {
#if OPENSSL_VERSION_NUMBER < 0x10100000L
static HMAC_CTX shmac;
hmac = &shmac;
/* 初始化 hmac，在计算 MAC 之前必须调用此函数 */
HMAC_CTX_init(hmac);
#else
hmac = HMAC_CTX_new();
if (hmac == NULL) {
return NGX_ERROR;
}
#endif
}
/* 初始化 hmac 数据，在 hmac 中复制 EVP_256() 方法，密钥数据，
* 密钥数据长度len，最后一个参数为 NULL */
HMAC_Init_ex(hmac, key->data, key->len, EVP_sha256(), NULL);
if (skip && src->pos <= skip && skip <= src->last) {
if (skip != src->pos) {
/* 将数据块加入到计算结果中，数据缓冲区 src->pos，数据长度skip - src->pos */
HMAC_Update(hmac, src->pos, skip - src->pos);
}
if (src->last != skip + NGX_RTMP_HANDSHAKE_KEYLEN) {
HMAC_Update(hmac, skip + NGX_RTMP_HANDSHAKE_KEYLEN,
src->last - skip - NGX_RTMP_HANDSHAKE_KEYLEN);
}
} else {
HMAC_Update(hmac, src->pos, src->last - src->pos);
}
/* 计算出的 MAC 数据放置在 dst 中，用户需要保证 dst 数据有足够长的空间，长度为 len */
HMAC_Final(hmac, dst, &len);
return NGX_OK;
}
散列消息鉴别码，简称 HMAC，是一种基于消息鉴别码 MAC（Message Authentication Code）的鉴别机制。使用 HMAC 时，
消息通讯的双方，通过验证消息中加入的鉴别密钥 K 来鉴别消息的真伪.
2.6 ngx_rtmp_handshake_create_challenge
/*
* RTMP complex handshake: S0+S1
*
* 抓包知，S0 1 byte，S1和S2都为1536 bytes
*
* S0: 1 byte，为rtmp版本号"x03"
*
* S1: 1536 bytes (key和digest有些会调换一下)
* - time: 4 bytes
* - version: 4 bytes
* - key: 764 bytes
* - digest: 764 bytes
*
* 该函数仅构建了 S0+S1 共1537字节
*/
static ngx_int_t ngx_rtmp_handshake_create_challenge(ngx_rtmp_session_t *s,
const u_char version[4], ngx_str_t *key)
{
ngx_buf_t *b;
b = s->hs_buf;
b->last = b->pos = b->start;
/* S0: 1 byte */
*b->last++ = 'x03';
/* S1 */
/* - time: 4 bytes */
b->last = ngx_rtmp_rcpymem(b->last, &s->epoch, 4);
/* - version: 4 bytes */
b->last = ngx_cpymem(b->last, version, 4);
/* 之后的缓存先填满随机数据 */
ngx_rtmp_fill_random_buffer(b);
++b->pos; // 先略过 S0
/* 写入服务器的 digest-data */
if (ngx_rtmp_write_digest(b, key, 0, s->connection->log) != NGX_OK) {
return NGX_ERROR;
}
--b->pos; // 再恢复到指向 S0 位置
return NGX_OK;
}
2.6.1 ngx_rtmp_write_digest
/* 在 Nginx-rtmp 中 S1 的数据结构使用如下:
* - time: 4 bytes
* - version: 4 bytes
* - digest: 764 bytes
* - key: 764 bytes
*
* 764 bytes digest 结构：
* - offset: 4 bytes
* - random-data: (offset) bytes
* - digest-data: 32 bytes
* - random-data: (764 - 4 - offset - 32 = 728 - offset) bytes
*/
static ngx_int_t ngx_rtmp_write_digest(ngx_buf_t *b, ngx_str_t *key, size_t base,
ngx_log_t *log)
{
size_t n, offs;
u_char *p;
offs = 0;
/* 将 b->pos[8] ~ b->pos[11] 这四个值相加得到 offset */
for (n = 8; n < 12; ++n) {
offs += b->pos[base + n];
}
offs = (offs % 728) + base + 12;
p = b->pos + offs;
/* 生成 digest 并存放在 p 指向的位置 */
if (ngx_rtmp_make_digest(key, b, p, p, log) != NGX_OK) {
return NGX_ERROR;
}
return NGX_OK;
}
2.7 ngx_rtmp_handshake_send
static void ngx_rtmp_handshake_send(ngx_event_t *wev)
{
ngx_int_t n;
ngx_connection_t *c;
ngx_rtmp_session_t *s;
ngx_buf_t *b;
c = wev->data;
s = c->data;
if (c->destroyed) {
return;
}
if (wev->timedout) {
ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
"handshake: send: client timed out");
c->timedout = 1;
ngx_rtmp_finalize_session(s);
return;
}
/* 将 wev 写事件从定时器中移除 */
if (wev->timer_set) {
ngx_del_timer(wev);
}
b = s->hs_buf;
/* 当 handshake 缓存中有数据时 */
while(b->pos != b->last) {
/* 调用 c->send 指向的回调函数(即 ngx_unix_send 方法)发送数据 */
n = c->send(c, b->pos, b->last - b->pos);
if (n == NGX_ERROR) {
ngx_rtmp_finalize_session(s);
return;
}
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;
}
b->pos += n;
}
/* 若 wev 写事件为活跃的，则将其从 epoll 等事件监控机制中移除 */
if (wev->active) {
ngx_del_event(wev, NGX_WRITE_EVENT, 0);
}
/* 更新当前 handshake 阶段 */
++s->hs_stage;
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: stage %ui", s->hs_stage);
switch (s->hs_stage) {
case NGX_RTMP_HANDSHAKE_SERVER_SEND_RESPONSE:
if (s->hs_old) {
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: old-style response");
s->hs_buf->pos = s->hs_buf->start + 1;
s->hs_buf->last = s->hs_buf->end;
}
/* 这里构建 S2 */
else if (ngx_rtmp_handshake_create_response(s) != NGX_OK) {
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"handshake: response error");
ngx_rtmp_finalize_session(s);
return;
}
/* 发送 S2 */
ngx_rtmp_handshake_send(wev);
break;
case NGX_RTMP_HANDSHAKE_SERVER_RECV_RESPONSE:
s->hs_buf->pos = s->hs_buf->last = s->hs_buf->start + 1;
ngx_rtmp_handshake_recv(c->read);
break;
case NGX_RTMP_HANDSHAKE_CLIENT_RECV_CHALLENGE:
s->hs_buf->pos = s->hs_buf->last = s->hs_buf->start;
ngx_rtmp_handshake_recv(c->read);
break;
case NGX_RTMP_HANDSHAKE_CLIENT_DONE:
ngx_rtmp_handshake_done(s);
break;
}
}
2.8 ngx_rtmp_handshake_create_response
/*
* RTMP complex handshake: C2/S2
* S2: 前 1504 bytes数据随机生成（前 8 bytes需要注意），然后对 1504 bytes 数据进行HMACsha256
* 得到digest，将digest放到最后的32bytes。
*
* 1536 bytes C2/S2 结构
* random-data: 1504 bytes
* digest-data: 32 bytes
*/
static ngx_int_t ngx_rtmp_handshake_create_response(ngx_rtmp_session_t *s)
{
ngx_buf_t *b;
u_char *p;
ngx_str_t key;
b = s->hs_buf;
b->pos = b->last = b->start + 1;
ngx_rtmp_fill_random_buffer(b);
if (s->hs_digest) {
/* p 指向最后的 32 bytes 的首地址处 */
p = b->last - NGX_RTMP_HANDSHAKE_KEYLEN;
key.data = s->hs_digest;
key.len = NGX_RTMP_HANDSHAKE_KEYLEN;
/* 将生成的 digest 放置到 s2 数据的最后 32 bytes 中 */
if (ngx_rtmp_make_digest(&key, b, p, p, s->connection->log) != NGX_OK) {
return NGX_ERROR;
}
}
return NGX_OK;
}
2.9 ngx_rtmp_handshake_done
static void ngx_rtmp_handshake_done(ngx_rtmp_session_t *s)
{
/* 释放 handshake 过程使用的缓存 hs_buf，其实，主要是将其
* 插入到 ngx_rtmp_core_srv_conf_t 的 free_hs 成员所持的
* 链表表头 */
ngx_rtmp_free_handshake_buffers(s);
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"handshake: done");
/* 在 events 数组中查找是否有 RTMP 模块设置有 NGX_RTMP_HANDSHAKE_DONE 的回调
* 方法，有则一一调用，否则不做任何处理 */
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_relay_module 模块设置了 NGX_RTMP_HANDSHAKE_DONE 的回调方法：
static ngx_int_t ngx_rtmp_relay_postconfiguration(ngx_conf_t *cf)
{
ngx_rtmp_core_main_conf_t *cmcf;
ngx_rtmp_handler_pt *h;
...
cmcf = ngx_rtmp_conf_get_module_main_conf(cf, ngx_rtmp_core_module);
h = ngx_array_push(&cmcf->events[NGX_RTMP_HANDSHAKE_DONE]);
*h = ngx_rtmp_relay_handshake_done;
...
}
2.9.1 ngx_rtmp_relay_handshake_done
static ngx_int_t ngx_rtmp_relay_handshake_done(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
ngx_chain_t *in)
{
ngx_rtmp_relay_ctx_t *ctx;
/* 获取 ngx_rtmp_relay_module 模块的上下文结构体 */
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_relay_module);
/* 若 relay 为 0，则直接返回，这里是为 0，因为没有使用 relay 模块的相关功能 */
if (ctx == NULL || !s->relay) {
return NGX_OK;
}
return ngx_rtmp_relay_send_connect(s);
}
S -> C: S0 + S1 + S2
以上就是 nginx-rtmp 握手的全过程。