diff --git a/ngx_rtmp_exec_module.c b/ngx_rtmp_exec_module.c index 1c26bcd..658d665 100644 --- a/ngx_rtmp_exec_module.c +++ b/ngx_rtmp_exec_module.c @@ -16,12 +16,17 @@ static ngx_rtmp_publish_pt next_publish; static ngx_rtmp_close_stream_pt next_close_stream; +static ngx_int_t ngx_rtmp_exec_init_process(ngx_cycle_t *cycle); static ngx_int_t ngx_rtmp_exec_postconfiguration(ngx_conf_t *cf); +static void * ngx_rtmp_exec_create_main_conf(ngx_conf_t *cf); +static char * ngx_rtmp_exec_init_main_conf(ngx_conf_t *cf, void *conf); static void * ngx_rtmp_exec_create_app_conf(ngx_conf_t *cf); static char * ngx_rtmp_exec_merge_app_conf(ngx_conf_t *cf, - void *parent, void *child); + void *parent, void *child); static char * ngx_rtmp_exec_exec(ngx_conf_t *cf, ngx_command_t *cmd, - void *conf); + void *conf); +static char * ngx_rtmp_exec_exec_init(ngx_conf_t *cf, ngx_command_t *cmd, + void *conf); #define NGX_RTMP_EXEC_RESPAWN 0x01 @@ -30,41 +35,49 @@ static char * ngx_rtmp_exec_exec(ngx_conf_t *cf, ngx_command_t *cmd, typedef struct { ngx_str_t cmd; - ngx_array_t args; /* ngx_str_t */ + ngx_array_t args; /* ngx_str_t */ } ngx_rtmp_exec_conf_t; typedef struct { - ngx_array_t execs; /* ngx_rtmp_exec_conf_t */ - ngx_msec_t respawn_timeout; - ngx_flag_t respawn; - ngx_int_t kill_signal; -} ngx_rtmp_exec_app_conf_t; - - -typedef struct { - ngx_rtmp_session_t *session; - size_t index; + ngx_rtmp_exec_conf_t *conf; + ngx_log_t *log; + ngx_rtmp_session_t *session; /* NULL for init execs */ unsigned active:1; - int pid; + ngx_pid_t pid; + ngx_pid_t *save_pid; int pipefd; ngx_connection_t dummy_conn; /*needed by ngx_xxx_event*/ ngx_event_t read_evt, write_evt; ngx_event_t respawn_evt; + ngx_msec_t respawn_timeout; } ngx_rtmp_exec_t; +typedef struct { + ngx_array_t confs; /* ngx_rtmp_exec_conf_t */ + ngx_array_t execs; /* ngx_rtmp_exec_t */ + ngx_msec_t respawn_timeout; +} ngx_rtmp_exec_main_conf_t; + + +typedef struct { + ngx_array_t confs; /* ngx_rtmp_exec_conf_t */ + ngx_int_t kill_signal; + ngx_flag_t respawn; +} ngx_rtmp_exec_app_conf_t; + + typedef struct { u_char name[NGX_RTMP_MAX_NAME]; - ngx_rtmp_exec_t *execs; + ngx_array_t execs; } ngx_rtmp_exec_ctx_t; static char *ngx_rtmp_exec_kill_signal(ngx_conf_t *cf, ngx_command_t *cmd, void *conf); -static ngx_int_t ngx_rtmp_exec_kill(ngx_rtmp_session_t *s, ngx_rtmp_exec_t *e, - ngx_int_t term); -static ngx_int_t ngx_rtmp_exec_run(ngx_rtmp_session_t *s, size_t n); +static ngx_int_t ngx_rtmp_exec_kill(ngx_rtmp_exec_t *e, ngx_int_t kill_signal); +static ngx_int_t ngx_rtmp_exec_run(ngx_rtmp_exec_t *e); static ngx_command_t ngx_rtmp_exec_commands[] = { @@ -75,6 +88,13 @@ static ngx_command_t ngx_rtmp_exec_commands[] = { NGX_RTMP_APP_CONF_OFFSET, 0, NULL }, + + { ngx_string("exec_init"), + NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_1MORE, + ngx_rtmp_exec_exec_init, + NGX_RTMP_MAIN_CONF_OFFSET, + 0, + NULL }, { ngx_string("respawn"), NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1, @@ -86,8 +106,8 @@ static ngx_command_t ngx_rtmp_exec_commands[] = { { ngx_string("respawn_timeout"), NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1, ngx_conf_set_msec_slot, - NGX_RTMP_APP_CONF_OFFSET, - offsetof(ngx_rtmp_exec_app_conf_t, respawn_timeout), + NGX_RTMP_MAIN_CONF_OFFSET, + offsetof(ngx_rtmp_exec_main_conf_t, respawn_timeout), NULL }, { ngx_string("exec_kill_signal"), @@ -104,8 +124,8 @@ static ngx_command_t ngx_rtmp_exec_commands[] = { static ngx_rtmp_module_t ngx_rtmp_exec_module_ctx = { NULL, /* preconfiguration */ ngx_rtmp_exec_postconfiguration, /* postconfiguration */ - NULL, /* create main configuration */ - NULL, /* init main configuration */ + ngx_rtmp_exec_create_main_conf, /* create main configuration */ + ngx_rtmp_exec_init_main_conf, /* init main configuration */ NULL, /* create server configuration */ NULL, /* merge server configuration */ ngx_rtmp_exec_create_app_conf, /* create app configuration */ @@ -120,7 +140,7 @@ ngx_module_t ngx_rtmp_exec_module = { NGX_RTMP_MODULE, /* module type */ NULL, /* init master */ NULL, /* init module */ - NULL, /* init process */ + ngx_rtmp_exec_init_process, /* init process */ NULL, /* init thread */ NULL, /* exit thread */ NULL, /* exit process */ @@ -163,6 +183,64 @@ static ngx_rtmp_eval_t * ngx_rtmp_exec_eval_p[] = { }; +static void * +ngx_rtmp_exec_create_main_conf(ngx_conf_t *cf) +{ + ngx_rtmp_exec_main_conf_t *emcf; + + emcf = ngx_pcalloc(cf->pool, sizeof(ngx_rtmp_exec_main_conf_t)); + if (emcf == NULL) { + return NULL; + } + + emcf->respawn_timeout = NGX_CONF_UNSET_MSEC; + + if (ngx_array_init(&emcf->confs, cf->pool, 1, + sizeof(ngx_rtmp_exec_conf_t)) != NGX_OK) + { + return NULL; + } + + return emcf; +} + + +static char * +ngx_rtmp_exec_init_main_conf(ngx_conf_t *cf, void *conf) +{ + ngx_rtmp_exec_main_conf_t *emcf = conf; + ngx_rtmp_exec_conf_t *ec; + ngx_rtmp_exec_t *e; + ngx_uint_t n; + + if (emcf->respawn_timeout == NGX_CONF_UNSET_MSEC) { + emcf->respawn_timeout = 5000; + } + + if (ngx_array_init(&emcf->execs, cf->pool, emcf->confs.nelts, + sizeof(ngx_rtmp_exec_t)) != NGX_OK) + { + return NGX_CONF_ERROR; + } + + e = ngx_array_push_n(&emcf->execs, emcf->confs.nelts); + if (e == NULL) { + return NGX_CONF_ERROR; + } + + ec = emcf->confs.elts; + + for (n = 0; n < emcf->confs.nelts; ++n, ++e, ++ec) { + ngx_memzero(e, sizeof(*e)); + e->conf = ec; + e->log = &cf->cycle->new_log; + e->respawn_timeout = emcf->respawn_timeout; + } + + return NGX_CONF_OK; +} + + static void * ngx_rtmp_exec_create_app_conf(ngx_conf_t *cf) { @@ -174,11 +252,10 @@ ngx_rtmp_exec_create_app_conf(ngx_conf_t *cf) } eacf->respawn = NGX_CONF_UNSET; - eacf->respawn_timeout = NGX_CONF_UNSET; eacf->kill_signal = NGX_CONF_UNSET; - if (ngx_array_init(&eacf->execs, cf->pool, 1, - sizeof(ngx_rtmp_exec_conf_t)) != NGX_OK) + if (ngx_array_init(&eacf->confs, cf->pool, 1, + sizeof(ngx_rtmp_exec_conf_t)) != NGX_OK) { return NULL; } @@ -196,17 +273,15 @@ ngx_rtmp_exec_merge_app_conf(ngx_conf_t *cf, void *parent, void *child) ngx_rtmp_exec_conf_t *ec, *pec; ngx_conf_merge_value(conf->respawn, prev->respawn, 1); - ngx_conf_merge_msec_value(conf->respawn_timeout, prev->respawn_timeout, - 5000); ngx_conf_merge_value(conf->kill_signal, prev->kill_signal, SIGKILL); - if (prev->execs.nelts) { - ec = ngx_array_push_n(&conf->execs, prev->execs.nelts); + if (prev->confs.nelts) { + ec = ngx_array_push_n(&conf->confs, prev->confs.nelts); if (ec == NULL) { return NGX_CONF_ERROR; } - pec = prev->execs.elts; - for (n = 0; n < prev->execs.nelts; ++n, ++ec, ++pec) { + pec = prev->confs.elts; + for (n = 0; n < prev->confs.nelts; ++n, ++ec, ++pec) { *ec = *pec; } } @@ -215,61 +290,106 @@ ngx_rtmp_exec_merge_app_conf(ngx_conf_t *cf, void *parent, void *child) } +static ngx_int_t +ngx_rtmp_exec_init_process(ngx_cycle_t *cycle) +{ + ngx_rtmp_core_main_conf_t *cmcf = ngx_rtmp_core_main_conf; + ngx_rtmp_core_srv_conf_t **cscf; + ngx_rtmp_conf_ctx_t *cctx; + ngx_rtmp_exec_main_conf_t *emcf; + ngx_rtmp_exec_t *e; + ngx_uint_t n; + /* ngx_pid_t *pid;*/ + + if (cmcf->servers.nelts == 0) { + return NGX_ERROR; + } + + /* execs are always started by the first worker */ + if (ngx_process_slot) { + return NGX_OK; + } + + cscf = cmcf->servers.elts; + cctx = (*cscf)->ctx; + emcf = cctx->main_conf[ngx_rtmp_exec_module.ctx_index]; + + /* When worker is restarted, child process (ffmpeg) will + * not be terminated if it's connected to another + * (still alive) worker. That leads to starting + * another instance of exec_init process. + * We need to kill previously started processes. + */ +/* + pid = emcf->pids; + for (n = 0; n < emcf->execs.nelts; ++n, ++pid) { + if (*pid == NGX_INVALID_PID) { + continue; + } + + kill(*pid, SIGKILL); + *pid = NGX_INVALID_PID; + } +*/ + /* TODO: kill all processes started by the previous + * instance of this worker. Need shared object with + * all pids. + */ + + e = emcf->execs.elts; + for (n = 0; n < emcf->execs.nelts; ++n, ++e) { + ngx_rtmp_exec_run(e); + } + + return NGX_OK; +} + + static void ngx_rtmp_exec_respawn(ngx_event_t *ev) { - ngx_rtmp_exec_t *e; - - e = ev->data; - ngx_rtmp_exec_run(e->session, e->index); + ngx_rtmp_exec_run((ngx_rtmp_exec_t *) ev->data); } static void ngx_rtmp_exec_child_dead(ngx_event_t *ev) { - ngx_connection_t *dummy_conn; - ngx_rtmp_exec_t *e; - ngx_rtmp_session_t *s; - ngx_rtmp_exec_app_conf_t *eacf; + ngx_connection_t *dummy_conn = ev->data; + ngx_rtmp_exec_t *e; - dummy_conn = ev->data; e = dummy_conn->data; - s = e->session; - eacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_exec_module); - ngx_log_debug2(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: child %ui exited; %s", - (ngx_int_t)e->pid, - eacf->respawn ? "respawning" : "ignoring"); + ngx_log_debug2(NGX_LOG_DEBUG_RTMP, e->log, 0, + "exec: child %ui exited; %s", (ngx_int_t) e->pid, + e->respawn_timeout == NGX_CONF_UNSET_MSEC ? "respawning" : + "ignoring"); - ngx_rtmp_exec_kill(s, e, 0); + ngx_rtmp_exec_kill(e, 0); - if (!eacf->respawn) { + if (e->respawn_timeout == NGX_CONF_UNSET_MSEC) { return; } - if (eacf->respawn_timeout == 0) { - ngx_rtmp_exec_run(s, e->index); + if (e->respawn_timeout == 0) { + ngx_rtmp_exec_run(e); return; } - ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: shedule respawn %Mmsec", eacf->respawn_timeout); + ngx_log_debug1(NGX_LOG_DEBUG_RTMP, e->log, 0, + "exec: shedule respawn %Mmsec", e->respawn_timeout); + e->respawn_evt.data = e; - e->respawn_evt.log = s->connection->log; + e->respawn_evt.log = e->log; e->respawn_evt.handler = ngx_rtmp_exec_respawn; - ngx_add_timer(&e->respawn_evt, eacf->respawn_timeout); + + ngx_add_timer(&e->respawn_evt, e->respawn_timeout); } static ngx_int_t -ngx_rtmp_exec_kill(ngx_rtmp_session_t *s, ngx_rtmp_exec_t *e, ngx_int_t term) +ngx_rtmp_exec_kill(ngx_rtmp_exec_t *e, ngx_int_t kill_signal) { - ngx_rtmp_exec_app_conf_t *eacf; - - eacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_exec_module); - if (e->respawn_evt.timer_set) { ngx_del_timer(&e->respawn_evt); } @@ -282,23 +402,26 @@ ngx_rtmp_exec_kill(ngx_rtmp_session_t *s, ngx_rtmp_exec_t *e, ngx_int_t term) return NGX_OK; } - ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: terminating child %ui", - (ngx_int_t)e->pid); + ngx_log_debug1(NGX_LOG_DEBUG_RTMP, e->log, 0, + "exec: terminating child %ui", + (ngx_int_t) e->pid); e->active = 0; close(e->pipefd); + if (e->save_pid) { + *e->save_pid = NGX_INVALID_PID; + } - if (!term) { + if (kill_signal == 0) { return NGX_OK; } - if (kill(e->pid, eacf->kill_signal) == -1) { - ngx_log_error(NGX_LOG_INFO, s->connection->log, ngx_errno, - "exec: kill failed pid=%i", (ngx_int_t)e->pid); + if (kill(e->pid, kill_signal) == -1) { + ngx_log_error(NGX_LOG_INFO, e->log, ngx_errno, + "exec: kill failed pid=%i", (ngx_int_t) e->pid); } else { - ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: killed pid=%i", (ngx_int_t)e->pid); + ngx_log_debug1(NGX_LOG_DEBUG_RTMP, e->log, 0, + "exec: killed pid=%i", (ngx_int_t) e->pid); } return NGX_OK; @@ -306,34 +429,32 @@ ngx_rtmp_exec_kill(ngx_rtmp_session_t *s, ngx_rtmp_exec_t *e, ngx_int_t term) static ngx_int_t -ngx_rtmp_exec_run(ngx_rtmp_session_t *s, size_t n) +ngx_rtmp_exec_run(ngx_rtmp_exec_t *e) { #if !(NGX_WIN32) - ngx_rtmp_exec_app_conf_t *eacf; - ngx_rtmp_exec_ctx_t *ctx; - int pid, fd, maxfd; + ngx_pid_t pid; + int fd, maxfd; int pipefd[2]; int ret; ngx_rtmp_exec_conf_t *ec; - ngx_rtmp_exec_t *e; ngx_str_t *arg, a; char **args; + ngx_uint_t n; - eacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_exec_module); - ec = (ngx_rtmp_exec_conf_t *)eacf->execs.elts + n; + ec = e->conf; - ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_exec_module); - e = ctx->execs + n; + ngx_log_debug1(NGX_LOG_DEBUG_RTMP, e->log, 0, + "exec: starting child '%V'", &ec->cmd); - ngx_memzero(e, sizeof(*e)); - - ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: starting child '%V'", - &ec->cmd); + if (e->active) { + ngx_log_debug1(NGX_LOG_DEBUG_RTMP, e->log, 0, + "exec: already active '%V'", &ec->cmd); + return NGX_OK; + } if (pipe(pipefd) == -1) { - ngx_log_error(NGX_LOG_INFO, s->connection->log, ngx_errno, - "exec: pipe failed"); + ngx_log_error(NGX_LOG_INFO, e->log, ngx_errno, + "exec: pipe failed"); return NGX_ERROR; } @@ -346,8 +467,8 @@ ngx_rtmp_exec_run(ngx_rtmp_session_t *s, size_t n) if (ret == -1) { close(pipefd[0]); close(pipefd[1]); - ngx_log_error(NGX_LOG_INFO, s->connection->log, ngx_errno, - "exec: fcntl failed"); + ngx_log_error(NGX_LOG_INFO, e->log, ngx_errno, + "exec: fcntl failed"); return NGX_ERROR; } @@ -356,8 +477,8 @@ ngx_rtmp_exec_run(ngx_rtmp_session_t *s, size_t n) case -1: close(pipefd[0]); close(pipefd[1]); - ngx_log_error(NGX_LOG_INFO, s->connection->log, ngx_errno, - "exec: fork failed"); + ngx_log_error(NGX_LOG_INFO, e->log, ngx_errno, + "exec: fork failed"); return NGX_ERROR; case 0: @@ -379,19 +500,22 @@ ngx_rtmp_exec_run(ngx_rtmp_session_t *s, size_t n) dup2(fd, STDOUT_FILENO); dup2(fd, STDERR_FILENO); - args = ngx_palloc(s->connection->pool, - (ec->args.nelts + 2) * sizeof(char *)); + args = ngx_alloc((ec->args.nelts + 2) * sizeof(char *), e->log); if (args == NULL) { exit(1); } arg = ec->args.elts; - args[0] = (char *)ec->cmd.data; + args[0] = (char *) ec->cmd.data; for (n = 0; n < ec->args.nelts; ++n, ++arg) { - ngx_rtmp_eval(s, arg, ngx_rtmp_exec_eval_p, &a); + if (e->session == NULL) { + a = *arg; + } else { + ngx_rtmp_eval(e->session, arg, ngx_rtmp_exec_eval_p, &a); + } args[n + 1] = (char *) a.data; } args[n + 1] = NULL; - if (execvp((char *)ec->cmd.data, args) == -1) { + if (execvp((char *) ec->cmd.data, args) == -1) { exit(1); } break; @@ -399,11 +523,12 @@ ngx_rtmp_exec_run(ngx_rtmp_session_t *s, size_t n) default: /* parent */ close(pipefd[1]); - e->session = s; - e->index = n; e->active = 1; e->pid = pid; e->pipefd = pipefd[0]; + if (e->save_pid) { + *e->save_pid = pid; + } e->dummy_conn.fd = e->pipefd; e->dummy_conn.data = e; @@ -412,17 +537,17 @@ ngx_rtmp_exec_run(ngx_rtmp_session_t *s, size_t n) e->read_evt.data = &e->dummy_conn; e->write_evt.data = &e->dummy_conn; - e->read_evt.log = s->connection->log; + e->read_evt.log = e->log; e->read_evt.handler = ngx_rtmp_exec_child_dead; if (ngx_add_event(&e->read_evt, NGX_READ_EVENT, 0) != NGX_OK) { - ngx_log_error(NGX_LOG_INFO, s->connection->log, ngx_errno, - "exec: failed to add child control event"); + ngx_log_error(NGX_LOG_INFO, e->log, ngx_errno, + "exec: failed to add child control event"); } - ngx_log_debug2(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: child '%V' started pid=%ui", - &ec->cmd, (ngx_uint_t)pid); + ngx_log_debug2(NGX_LOG_DEBUG_RTMP, e->log, 0, + "exec: child '%V' started pid=%i", + &ec->cmd, (ngx_int_t) pid); break; } #endif /* NGX_WIN32 */ @@ -444,16 +569,16 @@ ngx_rtmp_exec_close_stream(ngx_rtmp_session_t *s, ngx_rtmp_close_stream_t *v) } ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_exec_module); - if (ctx == NULL || ctx->execs == NULL) { + if (ctx == NULL || ctx->execs.nelts == 0) { goto next; } ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: delete %uz command(s)", eacf->execs.nelts); + "exec: delete %uz command(s)", ctx->execs.nelts); - e = ctx->execs; - for (n = 0; n < eacf->execs.nelts; ++n, ++e) { - ngx_rtmp_exec_kill(s, e, 1); + e = ctx->execs.elts; + for (n = 0; n < ctx->execs.nelts; ++n, ++e) { + ngx_rtmp_exec_kill(e, eacf->kill_signal); } next: @@ -464,13 +589,16 @@ next: static ngx_int_t ngx_rtmp_exec_publish(ngx_rtmp_session_t *s, ngx_rtmp_publish_t *v) { + ngx_rtmp_exec_main_conf_t *emcf; ngx_rtmp_exec_app_conf_t *eacf; + ngx_rtmp_exec_t *e; ngx_rtmp_exec_conf_t *ec; ngx_rtmp_exec_ctx_t *ctx; size_t n; + emcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_exec_module); eacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_exec_module); - if (eacf == NULL || eacf->execs.nelts == 0) { + if (eacf == NULL || eacf->confs.nelts == 0) { goto next; } @@ -479,23 +607,44 @@ ngx_rtmp_exec_publish(ngx_rtmp_session_t *s, ngx_rtmp_publish_t *v) } ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_exec_module); + if (ctx == NULL) { ctx = ngx_pcalloc(s->connection->pool, sizeof(ngx_rtmp_exec_ctx_t)); if (ctx == NULL) { return NGX_ERROR; } + ngx_rtmp_set_ctx(s, ctx, ngx_rtmp_exec_module); - ctx->execs = ngx_pcalloc(s->connection->pool, eacf->execs.nelts - * sizeof(ngx_rtmp_exec_t)); + + if (ngx_array_init(&ctx->execs, s->connection->pool, eacf->confs.nelts, + sizeof(ngx_rtmp_exec_t)) != NGX_OK) + { + return NGX_ERROR; + } + + e = ngx_array_push_n(&ctx->execs, eacf->confs.nelts); + if (e == NULL) { + return NGX_ERROR; + } + + ec = eacf->confs.elts; + for (n = 0; n < eacf->confs.nelts; ++n, ++e, ++ec) { + e->conf = ec; + e->log = s->connection->log; + e->session = s; + e->respawn_timeout = (eacf->respawn ? emcf->respawn_timeout : + NGX_CONF_UNSET_MSEC); + } } + ngx_memcpy(ctx->name, v->name, NGX_RTMP_MAX_NAME); ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, - "exec: run %uz command(s)", eacf->execs.nelts); + "exec: run %uz command(s)", ctx->execs.nelts); - ec = eacf->execs.elts; - for (n = 0; n < eacf->execs.nelts; ++n, ++ec) { - ngx_rtmp_exec_run(s, n); + e = ctx->execs.elts; + for (n = 0; n < ctx->execs.nelts; ++n, ++e) { + ngx_rtmp_exec_run(e); } next: @@ -515,7 +664,7 @@ ngx_rtmp_exec_exec(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) eacf = ngx_rtmp_conf_get_module_app_conf(cf, ngx_rtmp_exec_module); value = cf->args->elts; - ec = ngx_array_push(&eacf->execs); + ec = ngx_array_push(&eacf->confs); if (ec == NULL) { return NGX_CONF_ERROR; } @@ -528,7 +677,46 @@ ngx_rtmp_exec_exec(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) nargs = cf->args->nelts - 2; if (ngx_array_init(&ec->args, cf->pool, nargs, - sizeof(ngx_str_t)) != NGX_OK) + sizeof(ngx_str_t)) != NGX_OK) + { + return NGX_CONF_ERROR; + } + + s = ngx_array_push_n(&ec->args, nargs); + for (n = 2; n < cf->args->nelts; ++n, ++s) { + *s = value[n]; + } + + return NGX_CONF_OK; +} + + +static char * +ngx_rtmp_exec_exec_init(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) +{ + ngx_rtmp_exec_main_conf_t *emcf = conf; + + ngx_str_t *value; + size_t n, nargs; + ngx_str_t *s; + ngx_rtmp_exec_conf_t *ec; + + value = cf->args->elts; + + ec = ngx_array_push(&emcf->confs); + if (ec == NULL) { + return NGX_CONF_ERROR; + } + + ec->cmd = value[1]; + + if (cf->args->nelts == 2) { + return NGX_CONF_OK; + } + + nargs = cf->args->nelts - 2; + if (ngx_array_init(&ec->args, cf->pool, nargs, + sizeof(ngx_str_t)) != NGX_OK) { return NGX_CONF_ERROR; }