mxdyeah/nginx-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
nginx-modules/ngx_http_flv_module/ngx_http_flv_live_module.c
mxd 9f28fed00a Upload Modules
2026-05-17 11:34:54 +08:00

2553 lines
68 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) Winshining
*/
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>
#include "ngx_http_flv_live_module.h"
#include "ngx_rtmp_bandwidth.h"
static ngx_rtmp_play_pt next_play;
static ngx_rtmp_close_stream_pt next_close_stream;
ngx_rtmp_play_pt http_flv_live_next_play;
ngx_rtmp_close_stream_pt http_flv_live_next_close_stream;
static ngx_int_t ngx_http_flv_live_init(ngx_conf_t *cf);
static void *ngx_http_flv_live_create_loc_conf(ngx_conf_t *cf);
static char *ngx_http_flv_live_merge_loc_conf(ngx_conf_t *cf,
void *parent, void *child);
static ngx_int_t ngx_http_flv_live_handler(ngx_http_request_t *r);
static void ngx_http_flv_live_cleanup(void *data);
static ngx_int_t ngx_http_flv_live_init_process(ngx_cycle_t *cycle);
static void ngx_http_flv_live_send_tail(ngx_rtmp_session_t *s);
static ngx_int_t ngx_http_flv_live_send_message(ngx_rtmp_session_t *s,
ngx_chain_t *out, ngx_uint_t priority);
static ngx_chain_t *ngx_http_flv_live_meta_message(ngx_rtmp_session_t *,
ngx_chain_t *in);
static ngx_chain_t *ngx_http_flv_live_append_message(ngx_rtmp_session_t *s,
ngx_rtmp_header_t *h, ngx_rtmp_header_t *lh, ngx_chain_t *in);
static void ngx_http_flv_live_free_message(ngx_rtmp_session_t *s,
ngx_chain_t *in);
static ngx_int_t ngx_http_flv_live_join(ngx_rtmp_session_t *s, u_char *name,
unsigned int publisher);
static ngx_chain_t *ngx_http_flv_live_append_shared_bufs(
ngx_rtmp_core_srv_conf_t *cscf, ngx_rtmp_header_t *h, ngx_chain_t *in,
ngx_flag_t chunked);
static void ngx_http_flv_live_close_http_request(ngx_rtmp_session_t *s);
static ngx_int_t ngx_http_flv_live_headers_filter(ngx_rtmp_session_t *s);
static ngx_int_t ngx_http_flv_live_header_filter(ngx_rtmp_session_t *s);
#if (nginx_version <= 1003014)
static void ngx_http_do_free_request(ngx_http_request_t *r, ngx_int_t rc);
static void ngx_http_do_log_request(ngx_http_request_t *r);
#endif
typedef struct ngx_http_header_val_s ngx_http_header_val_t;
typedef ngx_int_t (*ngx_http_set_header_pt)(ngx_http_request_t *r,
ngx_http_header_val_t *hv, ngx_str_t *value);
typedef struct {
ngx_str_t name;
ngx_uint_t offset;
ngx_http_set_header_pt handler;
} ngx_http_set_header_t;
struct ngx_http_header_val_s {
ngx_http_complex_value_t value;
ngx_str_t key;
ngx_http_set_header_pt handler;
ngx_uint_t offset;
#if (nginx_version >= 1007005)
ngx_uint_t always; /* unsigned always:1 */
#endif
};
typedef enum {
NGX_HTTP_EXPIRES_OFF,
} ngx_http_expires_t;
typedef struct {
ngx_http_expires_t expires;
time_t expires_time;
#if (nginx_version >= 1007009)
ngx_http_complex_value_t *expires_value;
#endif
ngx_array_t *headers;
} ngx_http_headers_conf_t;
extern ngx_module_t ngx_http_headers_filter_module;
static u_char ngx_http_server_string[] = "Server: nginx" CRLF;
static u_char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
#if (nginx_version >= 1011010)
static u_char ngx_http_server_build_string[] = "Server: " NGINX_VER_BUILD CRLF;
#endif
static ngx_str_t ngx_http_status_lines[] = {
ngx_string("200 OK"),
ngx_null_string, /* "201 Created" */
ngx_null_string, /* "202 Accepted" */
ngx_null_string, /* "203 Non-Authoritative Information" */
ngx_null_string, /* "204 No Content" */
ngx_null_string, /* "205 Reset Content" */
ngx_null_string, /* "206 Partial Content" */
/* ngx_null_string, */ /* "207 Multi-Status" */
#define NGX_HTTP_LAST_2XX 207
#define NGX_HTTP_OFF_3XX (NGX_HTTP_LAST_2XX - 200)
/* ngx_null_string, */ /* "300 Multiple Choices" */
ngx_string("301 Moved Permanently"),
ngx_string("302 Moved Temporarily"),
ngx_null_string, /* "303 See Other" */
ngx_null_string, /* "304 Not Modified" */
ngx_null_string, /* "305 Use Proxy" */
ngx_null_string, /* "306 unused" */
ngx_string("307 Temporary Redirect"),
#define NGX_HTTP_LAST_3XX 308
#define NGX_HTTP_OFF_4XX (NGX_HTTP_LAST_3XX - 301 + NGX_HTTP_OFF_3XX)
ngx_string("400 Bad Request"),
ngx_null_string, /* "401 Unauthorized" */
ngx_null_string, /* "402 Payment Required" */
ngx_string("403 Forbidden"),
ngx_string("404 Not Found"),
ngx_string("405 Not Allowed"),
ngx_null_string, /* "406 Not Acceptable" */
ngx_null_string, /* "407 Proxy Authentication Required" */
ngx_null_string, /* "408 Request Time-out" */
ngx_null_string, /* "409 Conflict" */
ngx_null_string, /* "410 Gone" */
ngx_null_string, /* "411 Length Required" */
ngx_null_string, /* "412 Precondition Failed" */
ngx_null_string, /* "413 Request Entity Too Large" */
ngx_null_string, /* "414 Request-URI Too Large" */
ngx_null_string, /* "415 Unsupported Media Type" */
ngx_null_string, /* "416 Requested Range Not Satisfiable" */
ngx_null_string, /* "417 Expectation Failed" */
ngx_null_string, /* "418 unused" */
ngx_null_string, /* "419 unused" */
ngx_null_string, /* "420 unused" */
ngx_null_string, /* "421 Misdirected Request" */
/* ngx_null_string, */ /* "422 Unprocessable Entity" */
/* ngx_null_string, */ /* "423 Locked" */
/* ngx_null_string, */ /* "424 Failed Dependency" */
#define NGX_HTTP_LAST_4XX 422
#define NGX_HTTP_OFF_5XX (NGX_HTTP_LAST_4XX - 400 + NGX_HTTP_OFF_4XX)
ngx_string("500 Internal Server Error"),
ngx_null_string, /* "501 Not Implemented" */
ngx_null_string, /* "502 Bad Gateway" */
ngx_string("503 Service Temporarily Unavailable"),
ngx_null_string, /* "504 Gateway Time-out" */
ngx_null_string, /* "505 HTTP Version Not Supported" */
ngx_null_string, /* "506 Variant Also Negotiates" */
ngx_null_string, /* "507 Insufficient Storage" */
/* ngx_null_string, */ /* "508 unused" */
/* ngx_null_string, */ /* "509 unused" */
/* ngx_null_string, */ /* "510 Not Extended" */
#define NGX_HTTP_LAST_5XX 508
};
extern ngx_rtmp_live_proc_handler_t ngx_rtmp_live_proc_handler;
static ngx_rtmp_live_proc_handler_t ngx_http_flv_live_proc_handler = {
NULL,
NULL,
NULL,
NULL,
ngx_http_flv_live_send_message,
ngx_http_flv_live_meta_message,
ngx_http_flv_live_append_message,
ngx_http_flv_live_free_message
};
ngx_rtmp_live_proc_handler_t *ngx_rtmp_live_proc_handlers[] = {
&ngx_rtmp_live_proc_handler,
&ngx_http_flv_live_proc_handler
};
static ngx_int_t ngx_http_flv_live_init_handlers(ngx_cycle_t *cycle);
static ngx_int_t ngx_http_flv_live_request(ngx_rtmp_session_t *s,
ngx_rtmp_header_t *h, ngx_chain_t *in);
static void ngx_http_flv_live_free_request(ngx_rtmp_session_t *s);
static void ngx_http_flv_live_read_handler(ngx_event_t *rev);
static void ngx_http_flv_live_write_handler(ngx_event_t *wev);
static ngx_int_t ngx_http_flv_live_send(ngx_rtmp_session_t *s);
static void ngx_http_flv_live_correct_timestamp(ngx_rtmp_session_t *s,
ngx_flag_t correct);
static ngx_int_t ngx_http_flv_live_preprocess(ngx_http_request_t *r,
ngx_rtmp_connection_t *rconn);
static ngx_rtmp_session_t *ngx_http_flv_live_init_connection(
ngx_http_request_t *r, ngx_rtmp_connection_t *rconn);
static ngx_rtmp_session_t *ngx_http_flv_live_init_session(
ngx_http_request_t *r, ngx_rtmp_addr_conf_t *add_conf);
static ngx_int_t ngx_http_flv_live_connect_init(ngx_rtmp_session_t *s,
ngx_str_t *app, ngx_str_t *stream);
static ngx_http_module_t ngx_http_flv_live_module_ctx = {
NULL,
ngx_http_flv_live_init, /* postconfiguration */
NULL,
NULL,
NULL,
NULL,
ngx_http_flv_live_create_loc_conf, /* create location configuration */
ngx_http_flv_live_merge_loc_conf /* merge location configuration */
};
static ngx_command_t ngx_http_flv_live_commands[] = {
{ ngx_string("flv_live"),
NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_conf_set_flag_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_flv_live_conf_t, flv_live),
NULL },
ngx_null_command
};
ngx_module_t ngx_http_flv_live_module = {
NGX_MODULE_V1,
&ngx_http_flv_live_module_ctx,
ngx_http_flv_live_commands,
NGX_HTTP_MODULE,
NULL,
NULL,
ngx_http_flv_live_init_process,
NULL,
NULL,
NULL,
NULL,
NGX_MODULE_V1_PADDING
};
static ngx_int_t
ngx_http_flv_live_init(ngx_conf_t *cf)
{
ngx_http_handler_pt *h;
ngx_http_core_main_conf_t *cmcf;
cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
/* insert in the NGX_HTTP_CONTENT_PHASE */
h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers);
if (h == NULL) {
return NGX_ERROR;
}
*h = ngx_http_flv_live_handler;
return NGX_OK;
}
static void *
ngx_http_flv_live_create_loc_conf(ngx_conf_t *cf)
{
ngx_http_flv_live_conf_t *conf;
conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_flv_live_conf_t));
if (conf == NULL) {
return NULL;
}
conf->flv_live = NGX_CONF_UNSET;
return (void *) conf;
}
static char *
ngx_http_flv_live_merge_loc_conf(ngx_conf_t *cf,
void *parent, void *child)
{
ngx_http_flv_live_conf_t *prev = parent;
ngx_http_flv_live_conf_t *conf = child;
ngx_conf_merge_value(conf->flv_live, prev->flv_live, 0);
return NGX_CONF_OK;
}
ngx_int_t
ngx_http_flv_live_init_handlers(ngx_cycle_t *cycle)
{
ngx_rtmp_core_main_conf_t *cmcf;
ngx_rtmp_handler_pt *h;
cmcf = ngx_rtmp_cycle_get_module_main_conf(cycle, ngx_rtmp_core_module);
if (cmcf == NULL) {
return NGX_OK;
}
/* rtmp live conf aready exsits, so add additional event handlers */
h = ngx_array_push(&cmcf->events[NGX_HTTP_FLV_LIVE_REQUEST]);
*h = ngx_http_flv_live_request;
next_play = http_flv_live_next_play;
next_close_stream = http_flv_live_next_close_stream;
http_flv_live_next_play = NULL;
http_flv_live_next_close_stream = NULL;
return NGX_OK;
}
static ngx_int_t
ngx_http_flv_live_init_process(ngx_cycle_t *cycle)
{
return ngx_http_flv_live_init_handlers(cycle);
}
/*
* chunk format:
* hex1\r\n
* content1(hex1)\r\n
* hex2\r\n
* content2(hex2)\r\n
* ...
* 0\r\n\r\n
*/
ngx_int_t
ngx_http_flv_live_send_header(ngx_rtmp_session_t *s)
{
ngx_rtmp_core_srv_conf_t *cscf;
ngx_http_core_loc_conf_t *clcf;
ngx_http_request_t *r;
ngx_rtmp_live_ctx_t *live_ctx;
ngx_rtmp_codec_ctx_t *codec_ctx;
ngx_list_part_t *part;
ngx_table_elt_t *e, *header;
u_char *p;
ngx_chain_t cl_flv_hdr, *pkt;
ngx_buf_t buf_flv_hdr;
ngx_uint_t i;
ngx_str_t chunked_flv_header;
ngx_str_t consec_flv_header;
u_char chunked_flv_header_data[18];
ngx_flag_t connection_header;
/**
* |F|L|V|ver|00000101|header_size|0|0|0|0|, ngx_http_flv_module.c
* for more details, please refer to http://www.adobe.com/devnet/f4v.html
**/
u_char flv_header[] = "FLV\x1\0\0\0\0\x9\0\0\0\0";
r = s->data;
r->headers_out.status = NGX_HTTP_OK;
ngx_str_set(&r->headers_out.content_type, "video/x-flv");
/* fill HTTP header 'Connection' according to headers_in */
r->keepalive = 0;
connection_header = 0;
part = &r->headers_in.headers.part;
header = part->elts;
for (i = 0; /* void */; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
header = part->elts;
i = 0;
}
if (header[i].hash == 0) {
continue;
}
if (ngx_strcasecmp(header[i].key.data, (u_char *) "connection") == 0) {
connection_header = 1;
if (ngx_strcasecmp(header[i].value.data, (u_char *) "keep-alive")
== 0)
{
r->keepalive = 1;
}
break;
}
}
if (!connection_header && r->http_version == NGX_HTTP_VERSION_11) {
r->keepalive = 1;
}
live_ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_live_module);
if (live_ctx && !live_ctx->active) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: try to send header when session not active");
return NGX_ERROR;
}
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
codec_ctx = ngx_rtmp_get_module_ctx(s->publisher, ngx_rtmp_codec_module);
if (codec_ctx->video_codec_id != 0) {
flv_header[4] |= 0x1;
}
if (codec_ctx->audio_codec_id != 0
&& codec_ctx->audio_codec_id != NGX_RTMP_AUDIO_UNCOMPRESSED)
{
flv_header[4] |= (0x1 << 2);
}
if (clcf->chunked_transfer_encoding &&
r->http_version == NGX_HTTP_VERSION_11)
{
r->chunked = 1;
p = chunked_flv_header_data;
*p++ = 'd';
*p++ = CR;
*p++ = LF;
ngx_memmove(p, flv_header, 13);
p += 13;
*p++ = CR;
*p++ = LF;
chunked_flv_header.data = chunked_flv_header_data;
chunked_flv_header.len = 18;
buf_flv_hdr.pos = chunked_flv_header.data;
buf_flv_hdr.last = chunked_flv_header.data + chunked_flv_header.len;
} else {
consec_flv_header.data = flv_header;
consec_flv_header.len = 13;
buf_flv_hdr.pos = consec_flv_header.data;
buf_flv_hdr.last = consec_flv_header.data + consec_flv_header.len;
}
e = r->headers_out.expires;
if (e == NULL) {
e = ngx_list_push(&r->headers_out.headers);
if (e == NULL) {
return NGX_ERROR;
}
r->headers_out.expires = e;
e->hash = 1;
ngx_str_set(&e->key, "Expires");
}
e->value.data = (u_char *) "-1";
e->value.len = ngx_strlen("-1");
if (ngx_http_flv_live_headers_filter(s) == NGX_ERROR) {
return NGX_ERROR;
}
buf_flv_hdr.start = buf_flv_hdr.pos;
buf_flv_hdr.end = buf_flv_hdr.last;
cl_flv_hdr.buf = &buf_flv_hdr;
cl_flv_hdr.next = NULL;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
pkt = ngx_rtmp_append_shared_bufs(cscf, NULL, &cl_flv_hdr);
if (pkt == NULL) {
return NGX_ERROR;
}
ngx_http_flv_live_send_message(s, pkt, 0);
ngx_rtmp_free_shared_chain(cscf, pkt);
return NGX_OK;
}
/**
* for adding non-standard HTTP headers
**/
static ngx_int_t
ngx_http_flv_live_headers_filter(ngx_rtmp_session_t *s)
{
ngx_str_t value;
ngx_uint_t i;
#if (nginx_version >= 1007005)
ngx_uint_t safe_status;
#endif
ngx_http_header_val_t *h;
ngx_http_headers_conf_t *conf;
ngx_http_request_t *r;
r = s->data;
conf = ngx_http_get_module_loc_conf(r, ngx_http_headers_filter_module);
/* force */
conf->expires = NGX_HTTP_EXPIRES_OFF;
if (conf->headers == NULL) {
return ngx_http_flv_live_header_filter(s);
}
#if (nginx_version >= 1007005)
switch (r->headers_out.status) {
case NGX_HTTP_OK:
case NGX_HTTP_CREATED:
case NGX_HTTP_NO_CONTENT:
case NGX_HTTP_PARTIAL_CONTENT:
case NGX_HTTP_MOVED_PERMANENTLY:
case NGX_HTTP_MOVED_TEMPORARILY:
case NGX_HTTP_SEE_OTHER:
case NGX_HTTP_NOT_MODIFIED:
case NGX_HTTP_TEMPORARY_REDIRECT:
safe_status = 1;
break;
default:
safe_status = 0;
}
#endif
if (conf->headers) {
h = conf->headers->elts;
for (i = 0; i < conf->headers->nelts; i++) {
#if (nginx_version >= 1007005)
if (!safe_status && !h[i].always) {
continue;
}
#endif
if (ngx_http_complex_value(r, &h[i].value, &value) != NGX_OK) {
return NGX_ERROR;
}
if (h[i].handler(r, &h[i], &value) != NGX_OK) {
return NGX_ERROR;
}
}
}
return ngx_http_flv_live_header_filter(s);
}
static ngx_int_t
ngx_http_flv_live_header_filter(ngx_rtmp_session_t *s)
{
u_char *p;
size_t len;
ngx_str_t *status_line;
ngx_buf_t *b;
ngx_uint_t status, i;
ngx_chain_t out, *pkt;
ngx_list_part_t *part;
ngx_table_elt_t *header;
ngx_http_core_loc_conf_t *clcf;
ngx_rtmp_core_srv_conf_t *cscf;
ngx_http_request_t *r;
r = s->data;
if (r->header_sent) {
return NGX_OK;
}
r->header_sent = 1;
if (r->chunked && r->http_version < NGX_HTTP_VERSION_11) {
ngx_log_error(NGX_LOG_WARN, s->connection->log, 0,
"flv live: chunked only supported by HTTP/1.1");
r->chunked = 0;
}
len = sizeof("HTTP/1.x ") - 1 + sizeof(CRLF) - 1
/* the end of the header */
+ sizeof(CRLF) - 1;
/* status line */
if (r->headers_out.status_line.len) {
len += r->headers_out.status_line.len;
status_line = &r->headers_out.status_line;
#if (NGX_SUPPRESS_WARN)
status = 0;
#endif
} else {
status = r->headers_out.status;
if (status >= NGX_HTTP_OK
&& status < NGX_HTTP_LAST_2XX)
{
/* 2XX */
status -= NGX_HTTP_OK;
status_line = &ngx_http_status_lines[status];
len += ngx_http_status_lines[status].len;
} else if (status >= NGX_HTTP_MOVED_PERMANENTLY
&& status < NGX_HTTP_LAST_3XX)
{
/* 3XX */
status = status - NGX_HTTP_MOVED_PERMANENTLY + NGX_HTTP_OFF_3XX;
status_line = &ngx_http_status_lines[status];
len += ngx_http_status_lines[status].len;
} else if (status >= NGX_HTTP_BAD_REQUEST
&& status < NGX_HTTP_LAST_4XX)
{
/* 4XX */
status = status - NGX_HTTP_BAD_REQUEST
+ NGX_HTTP_OFF_4XX;
status_line = &ngx_http_status_lines[status];
len += ngx_http_status_lines[status].len;
} else if (status >= NGX_HTTP_INTERNAL_SERVER_ERROR
&& status < NGX_HTTP_LAST_5XX)
{
/* 5XX */
status = status - NGX_HTTP_INTERNAL_SERVER_ERROR
+ NGX_HTTP_OFF_5XX;
status_line = &ngx_http_status_lines[status];
len += ngx_http_status_lines[status].len;
} else {
len += NGX_INT_T_LEN + 1 /* SP */;
status_line = NULL;
}
if (status_line && status_line->len == 0) {
status = r->headers_out.status;
len += NGX_INT_T_LEN + 1 /* SP */;
status_line = NULL;
}
}
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
if (r->headers_out.server == NULL) {
#if (nginx_version >= 1011010)
if (clcf->server_tokens == NGX_HTTP_SERVER_TOKENS_ON) {
len += sizeof(ngx_http_server_full_string) - 1;
} else if (clcf->server_tokens == NGX_HTTP_SERVER_TOKENS_BUILD) {
len += sizeof(ngx_http_server_build_string) - 1;
} else {
len += sizeof(ngx_http_server_string) - 1;
}
#else
len += clcf->server_tokens ? sizeof(ngx_http_server_full_string) - 1 :
sizeof(ngx_http_server_string) - 1;
#endif
}
if (r->headers_out.date == NULL) {
len += sizeof("Date: Mon, 28 Sep 1970 06:00:00 GMT" CRLF) - 1;
}
if (r->headers_out.content_type.len) {
len += sizeof("Content-Type: ") - 1
+ r->headers_out.content_type.len + 2;
if (r->headers_out.content_type_len == r->headers_out.content_type.len
&& r->headers_out.charset.len)
{
len += sizeof("; charset=") - 1 + r->headers_out.charset.len;
}
}
if (r->headers_out.content_length == NULL
&& r->headers_out.content_length_n >= 0)
{
len += sizeof("Content-Length: ") - 1 + NGX_OFF_T_LEN + 2;
}
if (r->headers_out.last_modified == NULL
&& r->headers_out.last_modified_time != -1)
{
len += sizeof("Last-Modified: Mon, 28 Sep 1970 06:00:00 GMT" CRLF) - 1;
}
if (r->chunked) {
len += sizeof("Transfer-Encoding: chunked" CRLF) - 1;
}
if (r->keepalive) {
len += sizeof("Connection: keep-alive" CRLF) - 1;
/*
* MSIE and Opera ignore the "Keep-Alive: timeout=<N>" header.
* MSIE keeps the connection alive for about 60-65 seconds.
* Opera keeps the connection alive very long.
* Mozilla keeps the connection alive for N plus about 1-10 seconds.
* Konqueror keeps the connection alive for about N seconds.
*/
if (clcf->keepalive_header) {
len += sizeof("Keep-Alive: timeout=") - 1 + NGX_TIME_T_LEN + 2;
}
} else {
len += sizeof("Connection: close" CRLF) - 1;
}
part = &r->headers_out.headers.part;
header = part->elts;
for (i = 0; /* void */; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
header = part->elts;
i = 0;
}
if (header[i].hash == 0) {
continue;
}
len += header[i].key.len + sizeof(": ") - 1 + header[i].value.len
+ sizeof(CRLF) - 1;
}
b = ngx_create_temp_buf(r->pool, len);
if (b == NULL) {
return NGX_ERROR;
}
/* "HTTP/1.x " */
if (r->http_version == NGX_HTTP_VERSION_10) {
b->last = ngx_cpymem(b->last, "HTTP/1.0 ", sizeof("HTTP/1.x ") - 1);
} else {
b->last = ngx_cpymem(b->last, "HTTP/1.1 ", sizeof("HTTP/1.x ") - 1);
}
/* status line */
if (status_line) {
b->last = ngx_copy(b->last, status_line->data, status_line->len);
} else {
b->last = ngx_sprintf(b->last, "%03ui ", status);
}
*b->last++ = CR; *b->last++ = LF;
if (r->headers_out.server == NULL) {
#if (nginx_version >= 1011010)
if (clcf->server_tokens == NGX_HTTP_SERVER_TOKENS_ON) {
p = ngx_http_server_full_string;
len = sizeof(ngx_http_server_full_string) - 1;
} else if (clcf->server_tokens == NGX_HTTP_SERVER_TOKENS_BUILD) {
p = ngx_http_server_build_string;
len = sizeof(ngx_http_server_build_string) - 1;
} else {
#else
if (clcf->server_tokens) {
p = (u_char *) ngx_http_server_full_string;
len = sizeof(ngx_http_server_full_string) - 1;
} else {
#endif
p = ngx_http_server_string;
len = sizeof(ngx_http_server_string) - 1;
}
b->last = ngx_cpymem(b->last, p, len);
}
if (r->headers_out.date == NULL) {
b->last = ngx_cpymem(b->last, "Date: ", sizeof("Date: ") - 1);
b->last = ngx_cpymem(b->last, ngx_cached_http_time.data,
ngx_cached_http_time.len);
*b->last++ = CR; *b->last++ = LF;
}
if (r->headers_out.content_type.len) {
b->last = ngx_cpymem(b->last, "Content-Type: ",
sizeof("Content-Type: ") - 1);
p = b->last;
b->last = ngx_copy(b->last, r->headers_out.content_type.data,
r->headers_out.content_type.len);
if (r->headers_out.content_type_len == r->headers_out.content_type.len
&& r->headers_out.charset.len)
{
b->last = ngx_cpymem(b->last, "; charset=",
sizeof("; charset=") - 1);
b->last = ngx_copy(b->last, r->headers_out.charset.data,
r->headers_out.charset.len);
/* update r->headers_out.content_type for possible logging */
r->headers_out.content_type.len = b->last - p;
r->headers_out.content_type.data = p;
}
*b->last++ = CR; *b->last++ = LF;
}
if (r->chunked) {
b->last = ngx_cpymem(b->last, "Transfer-Encoding: chunked" CRLF,
sizeof("Transfer-Encoding: chunked" CRLF) - 1);
}
if (r->keepalive) {
b->last = ngx_cpymem(b->last, "Connection: keep-alive" CRLF,
sizeof("Connection: keep-alive" CRLF) - 1);
if (clcf->keepalive_header) {
b->last = ngx_sprintf(b->last, "Keep-Alive: timeout=%T" CRLF,
clcf->keepalive_header);
}
} else {
b->last = ngx_cpymem(b->last, "Connection: close" CRLF,
sizeof("Connection: close" CRLF) - 1);
}
part = &r->headers_out.headers.part;
header = part->elts;
for (i = 0; /* void */; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
header = part->elts;
i = 0;
}
if (header[i].hash == 0) {
continue;
}
b->last = ngx_copy(b->last, header[i].key.data, header[i].key.len);
*b->last++ = ':'; *b->last++ = ' ';
b->last = ngx_copy(b->last, header[i].value.data, header[i].value.len);
*b->last++ = CR; *b->last++ = LF;
}
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"%*s", (size_t) (b->last - b->pos), b->pos);
/* the end of HTTP header */
*b->last++ = CR;
*b->last++ = LF;
r->header_size = b->last - b->pos;
out.buf = b;
out.next = NULL;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
pkt = ngx_rtmp_append_shared_bufs(cscf, NULL, &out);
if (pkt == NULL) {
return NGX_ERROR;
}
ngx_http_flv_live_send_message(s, pkt, 0);
ngx_rtmp_free_shared_chain(cscf, pkt);
return NGX_OK;
}
static void
ngx_http_flv_live_send_tail(ngx_rtmp_session_t *s)
{
ngx_rtmp_core_srv_conf_t *cscf;
ngx_chain_t cl_resp_hdr, *pkt;
ngx_buf_t buf_resp_hdr;
const ngx_str_t response_tail = ngx_string("0" CRLF CRLF);
buf_resp_hdr.pos = response_tail.data;
buf_resp_hdr.last = response_tail.data + response_tail.len;
buf_resp_hdr.start = buf_resp_hdr.pos;
buf_resp_hdr.end = buf_resp_hdr.last;
cl_resp_hdr.buf = &buf_resp_hdr;
cl_resp_hdr.next = NULL;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
pkt = ngx_rtmp_append_shared_bufs(cscf, NULL, &cl_resp_hdr);
ngx_http_flv_live_send_message(s, pkt, 0);
ngx_rtmp_free_shared_chain(cscf, pkt);
}
static ngx_int_t
ngx_http_flv_live_send_message(ngx_rtmp_session_t *s,
ngx_chain_t *out, ngx_uint_t priority)
{
ngx_uint_t nmsg;
nmsg = (s->out_last + s->out_queue - s->out_pos) % s->out_queue + 1;
if (priority > 3) {
priority = 3;
}
/* drop packet?
* Note we always leave 1 slot free */
if (nmsg + priority * s->out_queue / 4 >= s->out_queue) {
ngx_log_debug2(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live: HTTP drop message bufs=%ui, priority=%ui",
nmsg, priority);
return NGX_AGAIN;
}
s->out[s->out_last++] = out;
s->out_last %= s->out_queue;
ngx_rtmp_acquire_shared_chain(out);
ngx_log_debug3(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live: HTTP send nmsg=%ui, priority=%ui #%ui",
nmsg, priority, s->out_last);
if (priority && s->out_buffer && nmsg < s->out_cork) {
return NGX_OK;
}
if (!s->connection->write->active) {
ngx_http_flv_live_write_handler(s->connection->write);
}
return NGX_OK;
}
static ngx_int_t
ngx_http_flv_live_request(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
ngx_chain_t *in)
{
static ngx_rtmp_play_t v;
ngx_int_t rc;
ngx_http_request_t *r;
ngx_http_flv_live_ctx_t *ctx;
r = s->data;
ctx = ngx_http_get_module_ctx(r, ngx_http_flv_live_module);
rc = ngx_http_flv_live_connect_init(s, &ctx->app, &ctx->stream);
if (rc != NGX_OK) {
return NGX_ERROR;
}
if (s->notify_connect) {
return NGX_OK;
}
ngx_memzero(&v, sizeof(ngx_rtmp_play_t));
ngx_memcpy(v.name, ctx->stream.data, ngx_min(ctx->stream.len,
sizeof(v.name) - 1));
ngx_memcpy(v.args, s->args.data, ngx_min(s->args.len,
sizeof(v.args) - 1));
ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
"flv live: name='%s' args='%s' start=%i duration=%i "
"reset=%i silent=%i",
v.name, v.args, (ngx_int_t) v.start,
(ngx_int_t) v.duration, (ngx_int_t) v.reset,
(ngx_int_t) v.silent);
return ngx_rtmp_play(s, &v);
}
/* +--------------+ +-------------+
* | Client | | | Server |
* +------+-------+ | +------+------+
* | Handshaking done |
* | | |
* | | |
* |----------- Command Message(connect) ------->|
* | |
* |<------- Window Acknowledgement Size --------|
* | |
* |<----------- Set Peer Bandwidth -------------|
* | |
* |-------- Window Acknowledgement Size ------->|
* | |
* |<------ User Control Message(StreamBegin) ---|
* | |
* |<------------ Command Message ---------------|
* | (_result- connect response) |
*
* omit the user control message feedback
*/
void
ngx_http_flv_live_set_status(ngx_rtmp_session_t *s, unsigned active)
{
ngx_rtmp_live_ctx_t *ctx;
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_live_module);
ctx->active = active;
ctx->cs[0].active = 0;
ctx->cs[0].dropped = 0;
ctx->cs[1].active = 0;
ctx->cs[1].dropped = 0;
}
static ngx_int_t
ngx_http_flv_live_join(ngx_rtmp_session_t *s, u_char *name,
unsigned int publisher)
{
ngx_rtmp_live_ctx_t *ctx;
ngx_rtmp_live_stream_t **stream;
ngx_rtmp_live_app_conf_t *lacf;
/* only for subscribers */
if (publisher) {
return NGX_DECLINED;
}
lacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_live_module);
if (lacf == NULL) {
return NGX_DECLINED;
}
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_live_module);
if (ctx && ctx->stream) {
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live: already joined");
return NGX_DECLINED;
}
if (ctx == NULL) {
ctx = ngx_palloc(s->connection->pool, sizeof(ngx_rtmp_live_ctx_t));
if (ctx == NULL) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: failed to allocate for ctx");
return NGX_ERROR;
}
ngx_rtmp_set_ctx(s, ctx, ngx_rtmp_live_module);
}
ngx_memzero(ctx, sizeof(*ctx));
ctx->session = s;
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live: join '%s'", name);
stream = ngx_rtmp_live_get_stream(s, name, lacf->idle_streams);
if (stream == NULL ||
!(publisher || (*stream)->publishing || lacf->idle_streams))
{
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: stream not found");
return NGX_ERROR;
}
ctx->stream = *stream;
ctx->publishing = publisher;
ctx->next = (*stream)->ctx;
ctx->protocol = NGX_RTMP_PROTOCOL_HTTP;
(*stream)->ctx = ctx;
if (ctx->stream->pub_ctx) {
s->publisher = ctx->stream->pub_ctx->session;
}
if (lacf->buflen) {
s->out_buffer = 1;
}
ctx->cs[0].csid = NGX_RTMP_CSID_VIDEO;
ctx->cs[1].csid = NGX_RTMP_CSID_AUDIO;
if (!ctx->publishing && ctx->stream->active) {
ngx_http_flv_live_set_status(s, 1);
}
return NGX_OK;
}
ngx_int_t
ngx_http_flv_live_play(ngx_rtmp_session_t *s, ngx_rtmp_play_t *v)
{
ngx_rtmp_live_app_conf_t *lacf;
ngx_http_request_t *r;
r = s->data;
if (r == NULL) {
goto next;
}
lacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_live_module);
if (lacf == NULL || !lacf->live) {
goto next;
}
#if (nginx_version >= 1013001)
/**
* when playing from pull, the downstream requests on the most
* of time return before the upstream requests, flv.js always
* sends HTTP header 'Connection: keep-alive', but Nginx has
* deleted r->blocked in ngx_http_finalize_request, that causes
* ngx_http_set_keepalive to run the cleanup handlers to close
* the connection between downstream and server, so play fails
**/
r->keepalive = 0;
#endif
/* join stream as a subscriber */
if (ngx_http_flv_live_join(s, v->name, 0) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_log_debug4(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live play: name='%s' start=%uD duration=%uD reset=%d",
v->name, (uint32_t) v->start,
(uint32_t) v->duration, (uint32_t) v->reset);
next:
return next_play(s, v);
}
static void
ngx_http_flv_live_close_http_request(ngx_rtmp_session_t *s)
{
ngx_http_request_t *r;
r = s->data;
if (r && r->connection && !r->connection->destroyed) {
if (r->chunked) {
ngx_http_flv_live_send_tail(s);
}
}
}
ngx_int_t
ngx_http_flv_live_close_stream(ngx_rtmp_session_t *s,
ngx_rtmp_close_stream_t *v)
{
ngx_rtmp_live_ctx_t *ctx, **cctx, *unlink;
ngx_http_request_t *r;
ngx_rtmp_live_app_conf_t *lacf;
ngx_rtmp_live_stream_t **stream;
ngx_flag_t passive;
lacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_live_module);
if (lacf == NULL) {
goto next;
}
passive = 0;
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_live_module);
if (ctx == NULL) {
goto next;
}
if (ctx->stream == NULL) {
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live: not joined");
goto next;
}
if (ctx->protocol == NGX_RTMP_PROTOCOL_RTMP) {
/* close RTMP live play */
if (!ctx->publishing) {
goto next;
}
/* close all http flv live streams */
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live: push closed '%s', close live streams subscribed",
ctx->stream->name);
passive = 1;
}
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"flv live: leave '%s'", ctx->stream->name);
if (passive) {
for (cctx = &ctx->stream->ctx; *cctx; /* void */) {
if ((*cctx)->protocol == NGX_RTMP_PROTOCOL_HTTP &&
!lacf->idle_streams)
{
ngx_http_flv_live_close_http_request((*cctx)->session);
if (!(*cctx)->publishing && (*cctx)->stream->active) {
ngx_http_flv_live_set_status((*cctx)->session, 0);
}
ngx_http_flv_live_free_request((*cctx)->session);
ngx_rtmp_finalize_session((*cctx)->session);
unlink = *cctx;
*cctx = (*cctx)->next;
unlink->next = NULL;
} else {
cctx = &(*cctx)->next;
}
}
} else {
for (cctx = &ctx->stream->ctx; *cctx; /* void */) {
if (*cctx == ctx) {
if (!ctx->publishing && ctx->stream->active) {
ngx_http_flv_live_set_status(s, 0);
}
*cctx = ctx->next;
if (ctx->stream->pub_ctx == NULL &&
ctx->stream->ctx == NULL)
{
stream = ngx_rtmp_live_get_stream(s, ctx->stream->name, 0);
if (stream) {
*stream = (*stream)->next;
ctx->stream->next = lacf->free_streams;
lacf->free_streams = ctx->stream;
}
}
ctx->next = NULL;
ctx->stream = NULL;
ngx_http_flv_live_free_request(s);
s->connection->destroyed = 1;
break;
} else {
cctx = &(*cctx)->next;
}
}
}
/**
* close only http requests here, the other
* requests were left for next_close_stream
**/
next:
if (s->notify_connect || s->notify_play) {
r = s->data;
if (r) {
ngx_http_flv_live_free_request(s);
s->connection->destroyed = 1;
}
}
return next_close_stream(s, v);
}
static void
ngx_http_flv_live_free_request(ngx_rtmp_session_t *s)
{
ngx_connection_t *c;
ngx_http_request_t *r;
ngx_http_cleanup_t **cln;
r = s->data;
if (r) {
for (cln = &r->cleanup; *cln; /* void */) {
if ((*cln)->handler == ngx_http_flv_live_cleanup) {
*cln = (*cln)->next;
break;
}
cln = &(*cln)->next;
}
c = r->connection;
#if (nginx_version <= 1003014)
ngx_http_do_free_request(r, 0);
#else
ngx_http_free_request(r, 0);
#endif
#if (NGX_HTTP_SSL)
if (c->ssl) {
ngx_ssl_shutdown(c);
}
#endif
/* for later processing */
c->destroyed = 0;
}
}
#if (nginx_version <= 1003014)
static void
ngx_http_do_free_request(ngx_http_request_t *r, ngx_int_t rc)
{
ngx_log_t *log;
ngx_pool_t *pool;
struct linger linger;
ngx_http_cleanup_t *cln;
ngx_http_log_ctx_t *ctx;
ngx_http_core_loc_conf_t *clcf;
log = r->connection->log;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0, "http close request");
if (r->pool == NULL) {
ngx_log_error(NGX_LOG_ALERT, log, 0, "http request already closed");
return;
}
cln = r->cleanup;
r->cleanup = NULL;
while (cln) {
if (cln->handler) {
cln->handler(cln->data);
}
cln = cln->next;
}
#if (NGX_STAT_STUB)
if (r->stat_reading) {
(void) ngx_atomic_fetch_add(ngx_stat_reading, -1);
}
if (r->stat_writing) {
(void) ngx_atomic_fetch_add(ngx_stat_writing, -1);
}
#endif
if (rc > 0 && (r->headers_out.status == 0 || r->connection->sent == 0)) {
r->headers_out.status = rc;
}
log->action = "logging request";
ngx_http_do_log_request(r);
log->action = "closing request";
if (r->connection->timedout) {
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
if (clcf->reset_timedout_connection) {
linger.l_onoff = 1;
linger.l_linger = 0;
if (setsockopt(r->connection->fd, SOL_SOCKET, SO_LINGER,
(const void *) &linger, sizeof(struct linger)) == -1)
{
ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
"setsockopt(SO_LINGER) failed");
}
}
}
/* the various request strings were allocated from r->pool */
ctx = log->data;
ctx->request = NULL;
r->request_line.len = 0;
r->connection->destroyed = 1;
/*
* Setting r->pool to NULL will increase probability to catch double close
* of request since the request object is allocated from its own pool.
*/
pool = r->pool;
r->pool = NULL;
ngx_destroy_pool(pool);
}
static void
ngx_http_do_log_request(ngx_http_request_t *r)
{
ngx_uint_t i, n;
ngx_http_handler_pt *log_handler;
ngx_http_core_main_conf_t *cmcf;
cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
log_handler = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.elts;
n = cmcf->phases[NGX_HTTP_LOG_PHASE].handlers.nelts;
for (i = 0; i < n; i++) {
log_handler[i](r);
}
}
#endif
static void
ngx_http_flv_live_read_handler(ngx_event_t *rev)
{
ngx_connection_t *c;
ngx_http_request_t *r;
ngx_rtmp_session_t *s;
ngx_int_t n;
ngx_http_flv_live_ctx_t *ctx;
u_char buf[NGX_BUFF_MAX_SIZE];
c = rev->data;
if (c->destroyed) {
return;
}
r = c->data;
ctx = ngx_http_get_module_ctx(r, ngx_http_flv_live_module);
s = ctx->s;
for ( ;; ) {
n = c->recv(c, buf, sizeof(buf));
if (n == NGX_AGAIN) {
ngx_add_timer(c->read, s->timeout);
if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
ngx_rtmp_finalize_session(s);
}
break;
} else if (n == 0 || n == -1) {
ngx_rtmp_finalize_session(s);
break;
}
}
}
static void
ngx_http_flv_live_write_handler(ngx_event_t *wev)
{
ngx_connection_t *c;
ngx_http_request_t *r;
ngx_rtmp_session_t *s;
ngx_int_t n;
ngx_rtmp_live_ctx_t *lctx;
ngx_rtmp_core_srv_conf_t *cscf;
ngx_http_flv_live_ctx_t *ctx;
c = wev->data;
if (c->destroyed) {
return;
}
r = c->data;
ctx = ngx_http_get_module_ctx(r, ngx_http_flv_live_module);
s = ctx->s;
if (wev->timedout) {
ngx_log_error(NGX_LOG_ERR, c->log, NGX_ETIMEDOUT,
"flv live: 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 = ngx_http_flv_live_send(s);
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[s->out_pos] = NULL;
++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;
}
}
lctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_live_module);
if (lctx && !lctx->publishing && !wev->timer_set) {
ngx_add_timer(wev, s->timeout);
}
if (wev->active) {
ngx_del_event(wev, NGX_WRITE_EVENT, 0);
}
ngx_event_process_posted((ngx_cycle_t *) ngx_cycle, &s->posted_dry_events);
}
static ngx_int_t
ngx_http_flv_live_send(ngx_rtmp_session_t *s)
{
ngx_int_t n;
ngx_connection_t *c;
ngx_http_request_t *r;
c = s->connection;
r = s->data;
if (r->chunked) {
if (s->out_chain == s->out[s->out_pos]) {
n = c->send(c, s->out_bpos, s->out_chain->buf->last - s->out_bpos);
if (n == NGX_AGAIN || n == 0 || n < 0) {
return n;
}
if (n != s->out_chain->buf->last - s->out_bpos ||
s->out_chain->next == NULL)
{
return n;
}
s->out_chain = s->out_chain->next;
s->out_bytes += n;
s->out_bpos = s->out_chain->buf->pos;
s->ping_reset = 1;
ngx_rtmp_update_bandwidth(&ngx_rtmp_bw_out, n);
}
}
ngx_http_flv_live_correct_timestamp(s, 1);
n = c->send(c, s->out_bpos, s->out_chain->buf->last - s->out_bpos);
ngx_http_flv_live_correct_timestamp(s, 0);
return n;
}
static void
ngx_http_flv_live_correct_timestamp(ngx_rtmp_session_t *s, ngx_flag_t correct)
{
uint8_t type;
uint32_t timestamp;
u_char *p;
ngx_chain_t *cl;
ngx_buf_t *b;
cl = s->out_chain;
if (cl == NULL) {
return;
}
b = cl->buf;
if (b->start + NGX_RTMP_MAX_CHUNK_HEADER != b->pos) {
type = b->pos[0] & 0x1f;
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, s->connection->log, 0,
"flv live: type=%uD, correct=%uD, offset_timestamp=%uD",
type, correct, s->offset_timestamp);
if (type != NGX_RTMP_MSG_VIDEO && type != NGX_RTMP_MSG_AUDIO) {
return;
}
p = b->pos + 4;
timestamp = ngx_rtmp_n3_to_h4(p);
timestamp |= ((uint32_t) p[3] << 24);
if (correct) {
timestamp -= s->offset_timestamp;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, s->connection->log, 0,
"flv live: correct timestamp=%uD", timestamp);
} else {
timestamp += s->offset_timestamp;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, s->connection->log, 0,
"flv live: recover timestamp=%uD", timestamp);
}
p = b->pos + 4;
ngx_rtmp_h4_to_n3(p, timestamp);
p += 3;
*p++ = (u_char) (timestamp >> 24);
}
}
static ngx_int_t
ngx_http_flv_live_preprocess(ngx_http_request_t *r,
ngx_rtmp_connection_t *rconn)
{
ngx_http_flv_live_ctx_t *ctx;
ngx_listening_t *ls;
struct sockaddr *local_sockaddr;
struct sockaddr_in *ls_sin, *sin;
#if (NGX_HAVE_INET6)
struct sockaddr_in6 *ls_sin6, *sin6;
#endif
ngx_rtmp_in_addr_t *addr;
#if (NGX_HAVE_INET6)
ngx_rtmp_in6_addr_t *addr6;
#endif
ngx_rtmp_port_t *rport;
ngx_str_t arg_app = ngx_string("app");
ngx_str_t arg_stream = ngx_string("stream");
ngx_str_t arg_port = ngx_string("port");
ngx_int_t in_port;
ngx_uint_t i, n;
ngx_flag_t port_match, addr_match;
unsigned short sa_family;
ctx = ngx_http_get_module_ctx(r, ngx_http_flv_live_module);
/**
* if requested args are escaped, for example, urls in the
* history list of vlc for Android (or all mobile platforms)
**/
if (r->args.len == 0 && r->uri.len) {
ngx_http_split_args(r, &r->uri, &r->args);
}
if (ngx_http_arg(r, arg_port.data, arg_port.len, &ctx->port) != NGX_OK) {
/* no port in args */
ctx->port.len = ngx_strlen("1935");
ctx->port.data = ngx_pcalloc(r->pool, ctx->port.len + 1);
if (ctx->port.data == NULL) {
return NGX_ERROR;
}
ngx_memcpy(ctx->port.data, (const void *) "1935", ctx->port.len);
in_port = 1935;
} else {
in_port = ngx_atoi(ctx->port.data, ctx->port.len);
if (in_port == NGX_ERROR || (in_port < 0 || in_port > 65535)) {
return NGX_ERROR;
}
}
in_port = htons(in_port);
port_match = 1;
addr_match = 1;
ls = ngx_cycle->listening.elts;
for (n = 0; n < ngx_cycle->listening.nelts; ++n, ++ls) {
if (ls->handler == ngx_rtmp_init_connection) {
local_sockaddr = r->connection->local_sockaddr;
sa_family = local_sockaddr->sa_family;
if (sa_family != ls->sockaddr->sa_family) {
#if (NGX_HAVE_INET6)
if (ls->sockaddr->sa_family == AF_INET6) {
if (ls->ipv6only) {
#endif
continue;
#if (NGX_HAVE_INET6)
} else {
if (local_sockaddr->sa_family != AF_INET) {
continue;
}
sa_family = AF_INET6;
}
}
#endif
}
switch (sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
ls_sin6 = (struct sockaddr_in6 *) ls->sockaddr;
if (in_port != ls_sin6->sin6_port) {
port_match = 0;
}
break;
#endif
default:
ls_sin = (struct sockaddr_in *) ls->sockaddr;
if (in_port != ls_sin->sin_port) {
port_match = 0;
}
}
if (!port_match) {
port_match = 1;
continue;
}
rport = ls->servers;
if (rport->naddrs > 1) {
/**
* listen xxx.xxx.xxx.xxx:port
* listen port
**/
switch (sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin6 = (struct sockaddr_in6 *) ls->sockaddr;
addr6 = rport->addrs;
/* the last address is "*" */
for (i = 0; i < rport->naddrs - 1; i++) {
if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16)
== 0)
{
break;
}
}
rconn->addr_conf = &addr6[i].conf;
break;
#endif
default:
sin = (struct sockaddr_in *) ls->sockaddr;
addr = rport->addrs;
/* the last address is "*" */
for (i = 0; i < rport->naddrs - 1; i++) {
if (addr[i].addr == sin->sin_addr.s_addr) {
break;
}
}
rconn->addr_conf = &addr[i].conf;
}
} else {
switch (sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin6 = (struct sockaddr_in6 *) ls->sockaddr;
addr6 = rport->addrs;
if (ngx_memcmp(&addr6[0].addr6, &sin6->sin6_addr, 16)) {
addr_match = 0;
} else {
rconn->addr_conf = &addr6[0].conf;
}
break;
#endif
default:
sin = (struct sockaddr_in *) ls->sockaddr;
addr = rport->addrs;
if (addr[0].addr != sin->sin_addr.s_addr) {
addr_match = 0;
} else {
rconn->addr_conf = &addr[0].conf;
}
}
}
if (!addr_match) {
addr_match = 1;
continue;
}
break;
}
}
if (n == ngx_cycle->listening.nelts) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"flv live: failed to find configured port: '%V'", &ctx->port);
return NGX_ERROR;
}
if (ngx_http_arg(r, arg_app.data, arg_app.len, &ctx->app) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"flv live: app args MUST be specified");
return NGX_ERROR;
}
if (ngx_http_arg(r, arg_stream.data, arg_stream.len,
&ctx->stream) != NGX_OK)
{
ctx->stream.data = (u_char *) "";
ctx->stream.len = 0;
}
return NGX_OK;
}
ngx_rtmp_session_t *
ngx_http_flv_live_init_connection(ngx_http_request_t *r,
ngx_rtmp_connection_t *rconn)
{
ngx_rtmp_session_t *s;
ngx_connection_t *c;
void *data;
c = r->connection;
/* the default server configuration for the address:port */
rconn->conf_ctx = rconn->addr_conf->default_server->ctx;
++ngx_rtmp_naccepted;
data = c->data;
c->data = rconn;
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"flv live: *%ui client connected '%V'", c->number, &c->addr_text);
s = ngx_http_flv_live_init_session(r, rconn->addr_conf);
c->data = data;
if (s == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"flv live: failed to init connection for session");
return NULL;
}
/* only auto-pushed connections are
* done through unix socket */
s->auto_pushed = 0;
c->write->handler = ngx_http_flv_live_write_handler;
c->read->handler = ngx_http_flv_live_read_handler;
if (c->write->active) {
if (ngx_del_event(c->write, NGX_WRITE_EVENT, 0) != NGX_OK) {
return NULL;
}
}
return s;
}
static ngx_rtmp_session_t *
ngx_http_flv_live_init_session(ngx_http_request_t *r,
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;
ngx_connection_t *c;
c = r->connection;
s = ngx_pcalloc(c->pool, sizeof(ngx_rtmp_session_t));
if (s == NULL) {
/* let other handlers process */
goto failed;
}
s->rtmp_connection = c->data;
s->main_conf = addr_conf->default_server->ctx->main_conf;
s->srv_conf = addr_conf->default_server->ctx->srv_conf;
s->addr_text = &addr_conf->addr_text;
s->connection = c;
ctx = ngx_palloc(c->pool, sizeof(ngx_rtmp_error_log_ctx_t));
if (ctx == NULL) {
goto failed;
}
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) {
goto failed;
}
s->out_pool = ngx_create_pool(4096, c->log);
if (s->out_pool == NULL) {
goto failed;
}
s->out = ngx_pcalloc(s->out_pool, sizeof(ngx_chain_t *)
* ((ngx_rtmp_core_srv_conf_t *)
addr_conf->default_server->ctx->srv_conf
[ngx_rtmp_core_module.ctx_index])->out_queue);
if (s->out == NULL) {
goto failed;
}
s->in_streams_pool = ngx_create_pool(4096, c->log);
if (s->in_streams_pool == NULL) {
goto failed;
}
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(s->in_streams_pool, sizeof(ngx_rtmp_stream_t)
* cscf->max_streams);
if (s->in_streams == NULL) {
goto failed;
}
#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);
if (ngx_rtmp_fire_event(s, NGX_RTMP_CONNECT, NULL, NULL) != NGX_OK) {
goto failed;
}
s->data = (void *) r;
return s;
failed:
if (s && s->out_pool) {
ngx_destroy_pool(s->out_pool);
s->out_pool = NULL;
}
if (s && s->in_streams_pool) {
ngx_destroy_pool(s->in_streams_pool);
s->in_streams_pool = NULL;
}
return NULL;
}
static ngx_int_t
ngx_http_flv_live_connect_init(ngx_rtmp_session_t *s, ngx_str_t *app,
ngx_str_t *stream)
{
ngx_rtmp_connect_t v;
ngx_connection_t *c;
ngx_http_request_t *r;
u_char name[NGX_RTMP_MAX_NAME];
r = s->data;
c = s->connection;
ngx_memzero(&v, sizeof(ngx_rtmp_connect_t));
ngx_memcpy(v.app, app->data, ngx_min(app->len, sizeof(v.app) - 1));
ngx_memcpy(v.args, r->args.data, ngx_min(r->args.len, sizeof(v.args) - 1));
ngx_memcpy(v.flashver, "flv_live 1.1", ngx_strlen("flv_live 1.1"));
*ngx_snprintf(v.tc_url, NGX_RTMP_MAX_URL, "http://%V/%V",
&r->headers_in.host->value, app) = 0;
#define NGX_RTMP_SET_STRPAR(name) \
s->name.len = ngx_strlen(v.name); \
s->name.data = ngx_palloc(c->pool, s->name.len); \
if (s->name.data == NULL) { \
return NGX_ERROR; \
} \
ngx_memcpy(s->name.data, v.name, s->name.len)
NGX_RTMP_SET_STRPAR(app);
NGX_RTMP_SET_STRPAR(args);
NGX_RTMP_SET_STRPAR(flashver);
NGX_RTMP_SET_STRPAR(tc_url);
#undef NGX_RTMP_SET_STRPAR
ngx_memzero(name, NGX_RTMP_MAX_NAME);
ngx_memcpy(name, stream->data,
ngx_min(stream->len, NGX_RTMP_MAX_NAME - 1));
if (ngx_rtmp_process_request_line(s, name, v.args,
(const u_char *) "flv live connect") != NGX_OK)
{
return NGX_ERROR;
}
if (ngx_rtmp_process_virtual_host(s) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: failed to process virtual host");
return NGX_ERROR;
}
s->stream.len = stream->len;
s->stream.data = ngx_pstrdup(c->pool, stream);
return ngx_rtmp_connect(s, &v);
}
static ngx_chain_t *
ngx_http_flv_live_meta_message(ngx_rtmp_session_t *s, ngx_chain_t *in)
{
ngx_rtmp_core_srv_conf_t *cscf;
ngx_http_request_t *r;
ngx_chain_t *meta, *iter, *out;
u_char *p, *save;
uint8_t fmt;
uint32_t csid;
ngx_int_t thsize;
ngx_rtmp_header_t ch;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
if (cscf == NULL) {
return NULL;
}
r = s->data;
if (r == NULL || (r->connection && r->connection->destroyed)) {
return NULL;
}
/* remove RTMP header in meta */
meta = in;
p = meta->buf->pos;
save = meta->buf->pos;
if (meta->buf->last == p) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: no meta");
return NULL;
}
fmt = (*p >> 6) & 0x03;
if (fmt) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: non-type 0 format chunk message header");
return NULL;
}
csid = *p++ & 0x3f;
if (csid == 0) {
if (meta->buf->last - p < 1) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: incorrect basic header 2");
return NULL;
}
p += 1;
} else if (csid == 1) {
if (meta->buf->last - p < 2) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: incorrect basic header 3");
return NULL;
}
p += 2;
}
thsize = p - meta->buf->pos;
/*
* Chunk Message Header - Type 0
* |timestamp(3B)|msg len(3B)|msg type id(1B)|msg stream id(4B)|
*/
if (meta->buf->last - p <= 11) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"flv live: incorrect chunk message header");
return NULL;
}
p += 11;
meta->buf->pos = p;
for (iter = meta->next; iter; iter = iter->next) {
iter->buf->pos += thsize;
}
ch.timestamp = 0;
ch.type = NGX_RTMP_MSG_AMF_META;
out = ngx_http_flv_live_append_message(s, &ch, NULL, meta);
in->buf->pos = save;
for (iter = meta->next; iter; iter = iter->next) {
iter->buf->pos -= thsize;
}
return out;
}
static ngx_chain_t *
ngx_http_flv_live_append_message(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
ngx_rtmp_header_t *lh, ngx_chain_t *in)
{
ngx_rtmp_core_srv_conf_t *cscf;
ngx_http_request_t *r;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
if (cscf == NULL) {
return NULL;
}
r = s->data;
if (r == NULL || r->connection == NULL || r->connection->destroyed) {
return NULL;
}
if (h->type == NGX_RTMP_MSG_VIDEO || h->type == NGX_RTMP_MSG_AUDIO) {
if (!s->offset_timestamp_set) {
s->offset_timestamp_set = 1;
s->offset_timestamp = h->timestamp;
} else if (h->timestamp == 0) {
s->offset_timestamp = 0;
}
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, s->connection->log, 0,
"flv live: timestamp=%uD, offset_timestamp=%uD",
h->timestamp, s->offset_timestamp);
}
return ngx_http_flv_live_append_shared_bufs(cscf, h, in, r->chunked);
}
/*
* Brief format:
* |Tag|PreviousTagSize|
* Detailed format:
* |Reserved(2b)+Filter(1b)+TagType(5b)|DataLength(3B)|TimeStamp(3B)|
* TimeStampExt(1B)|StreamID(3B)|Data(DataLengthB)|PreviousTagSize|
*/
static ngx_chain_t *
ngx_http_flv_live_append_shared_bufs(ngx_rtmp_core_srv_conf_t *cscf,
ngx_rtmp_header_t *h, ngx_chain_t *in, ngx_flag_t chunked)
{
ngx_chain_t *tag, *chunk_head, *chunk_tail, chunk,
*iter, *last_in, **tail, prev_tag_size;
u_char *pos,
#if !(NGX_WIN32)
chunk_item[ngx_strlen("0000000000000000" CRLF) + 1];
#else
chunk_item[19];
#endif
uint32_t data_size, size;
off_t tag_size;
ngx_buf_t prev_tag_size_buf, chunk_buf;
for (data_size = 0, iter = in, last_in = iter; iter; iter = iter->next) {
last_in = iter;
data_size += (iter->buf->last - iter->buf->pos);
}
tail = &last_in->next;
*tail = &prev_tag_size;
tag_size = data_size + NGX_FLV_TAG_HEADER_SIZE;
prev_tag_size.buf = &prev_tag_size_buf;
prev_tag_size.next = NULL;
prev_tag_size_buf.start = (u_char *) &size;
prev_tag_size_buf.end = prev_tag_size_buf.start + sizeof(uint32_t);
prev_tag_size_buf.pos = prev_tag_size_buf.start;
prev_tag_size_buf.last = prev_tag_size_buf.end;
pos = prev_tag_size_buf.pos;
*(uint32_t *) pos = htonl(tag_size);
pos += 4;
/* ngx_rtmp_alloc_shared_buf returns the memory:
* |4B|sizeof(ngx_chain_t)|sizeof(ngx_buf_t)|NGX_RTMP_MAX_CHUNK_HEADER|
* chunk_size|
* the tag->buf->pos points to the addr of last part of memory
*/
tag = ngx_rtmp_append_shared_bufs(cscf, NULL, in);
if (tag == NULL) {
return NULL;
}
/* it links to the local variable, unlink it */
*tail = NULL;
tag->buf->pos -= NGX_FLV_TAG_HEADER_SIZE;
pos = tag->buf->pos;
/* type, 5bits */
*pos++ = (u_char) (h->type & 0x1f);
/* data length, 3B */
ngx_rtmp_h4_to_n3(pos, data_size);
pos += 3;
/* timestamp, 3B + ext, 1B */
ngx_rtmp_h4_to_n3(pos, h->timestamp);
pos += 3;
*pos++ = (u_char) (h->timestamp >> 24);
/* streamId, 3B, always be 0 */
*pos++ = 0;
*pos++ = 0;
*pos++ = 0;
/* add chunk header and tail */
if (chunked) {
/* 4 is the size of previous tag size itself */
*ngx_sprintf(chunk_item, "%xO" CRLF, tag_size + 4) = 0;
chunk_buf.start = chunk_item;
chunk_buf.pos = chunk_buf.start;
chunk_buf.end = chunk_buf.start + ngx_strlen(chunk_item);
chunk_buf.last = chunk_buf.end;
chunk.buf = &chunk_buf;
chunk.next = NULL;
chunk_head = ngx_rtmp_append_shared_bufs(cscf, NULL, &chunk);
if (chunk_head == NULL) {
return NULL;
}
for (iter = tag, last_in = iter; iter; iter = iter->next) {
last_in = iter;
}
/* save the memory, very likely */
#if !(NGX_WIN32)
if (__builtin_expect(last_in->buf->last + 2 <= last_in->buf->end, 1)) {
#else
if (last_in->buf->last + 2 <= last_in->buf->end) {
#endif
*last_in->buf->last++ = CR;
*last_in->buf->last++ = LF;
} else {
*ngx_sprintf(chunk_item, CRLF) = 0;
chunk_buf.start = chunk_item;
chunk_buf.pos = chunk_buf.start;
chunk_buf.end = chunk_buf.start + ngx_strlen(chunk_item);
chunk_buf.last = chunk_buf.end;
chunk.buf = &chunk_buf;
chunk.next = NULL;
chunk_tail = ngx_rtmp_append_shared_bufs(cscf, NULL, &chunk);
if (chunk_tail == NULL) {
return NULL;
}
tail = &last_in->next;
*tail = chunk_tail;
}
chunk_head->next = tag;
return chunk_head;
}
return tag;
}
static void
ngx_http_flv_live_free_message(ngx_rtmp_session_t *s, ngx_chain_t *in)
{
ngx_rtmp_core_srv_conf_t *cscf;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
if (cscf == NULL) {
return;
}
ngx_rtmp_free_shared_chain(cscf, in);
}
static void
ngx_http_flv_live_close_session_handler(ngx_rtmp_session_t *s)
{
ngx_connection_t *c;
ngx_rtmp_core_srv_conf_t *cscf;
c = s->connection;
cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);
ngx_log_error(NGX_LOG_INFO, c->log, 0, "flv live: close session");
ngx_rtmp_fire_event(s, NGX_RTMP_DISCONNECT, NULL, NULL);
if (s->ping_evt.timer_set) {
ngx_del_timer(&s->ping_evt);
}
if (s->in_old_pool) {
ngx_destroy_pool(s->in_old_pool);
}
if (s->in_pool) {
ngx_destroy_pool(s->in_pool);
}
while (s->out_pos != s->out_last) {
ngx_rtmp_free_shared_chain(cscf, s->out[s->out_pos]);
s->out_pos++;
s->out_pos %= s->out_queue;
}
if (s->in_streams_pool) {
ngx_destroy_pool(s->in_streams_pool);
}
if (s->out_pool) {
ngx_destroy_pool(s->out_pool);
}
}
static void
ngx_http_flv_live_cleanup(void *data)
{
ngx_rtmp_session_t *s;
s = data;
ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
"flv live: close connection");
ngx_http_flv_live_close_session_handler(s);
}
static ngx_int_t
ngx_http_flv_live_handler(ngx_http_request_t *r)
{
ngx_int_t rc;
ngx_http_flv_live_conf_t *hfcf;
ngx_http_cleanup_t *cln;
ngx_http_flv_live_ctx_t *ctx;
ngx_rtmp_session_t *s;
ngx_rtmp_connection_t *rconn;
if (ngx_exiting || ngx_terminate) {
return NGX_HTTP_CLOSE;
}
hfcf = ngx_http_get_module_loc_conf(r, ngx_http_flv_live_module);
if (!hfcf->flv_live) {
return NGX_DECLINED;
}
if (!(r->method & (NGX_HTTP_GET))) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"flv live: HTTP method was not \"GET\"");
return NGX_HTTP_NOT_ALLOWED;
}
if (r->http_version == NGX_HTTP_VERSION_9
#if (NGX_HTTP_V2)
|| r->http_version == NGX_HTTP_VERSION_20
#endif
)
{
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"flv live: HTTP version 0.9 or 2.0 not supported");
return NGX_HTTP_NOT_ALLOWED;
}
if (r->uri.data[r->uri.len - 1] == '/') {
return NGX_DECLINED;
}
rc = ngx_http_discard_request_body(r);
if (rc != NGX_OK) {
return rc;
}
ctx = ngx_http_get_module_ctx(r, ngx_http_flv_live_module);
if (ctx == NULL) {
ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_flv_live_ctx_t));
if (ctx == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
ngx_http_set_ctx(r, ctx, ngx_http_flv_live_module);
}
rconn = ngx_pcalloc(r->pool, sizeof(ngx_rtmp_connection_t));
if (rconn == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (ngx_http_flv_live_preprocess(r, rconn) != NGX_OK) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
s = ngx_http_flv_live_init_connection(r, rconn);
if (s == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
ctx->s = s;
/* live, ranges not allowed */
r->allow_ranges = 0;
r->read_event_handler = ngx_http_test_reading;
cln = ngx_http_cleanup_add(r, 0);
if (cln == NULL) {
return NGX_DECLINED;
}
cln->handler = ngx_http_flv_live_cleanup;
cln->data = s;
if (ngx_rtmp_fire_event(s, NGX_HTTP_FLV_LIVE_REQUEST, NULL, NULL)
!= NGX_OK)
{
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
r->main->count++;
return NGX_DONE;
}
Reference in New Issue View Git Blame Copy Permalink