/* Find the value of the URL parameter with the specified name */ static ngx_int_t find_arg(ngx_pool_t *pool, ngx_str_t name, ngx_str_t args, ngx_str_t *value) { u_char *start = args.data; u_char *end = start + args.len; size_t name_len = name.len; while (start < end) { if (start + name_len + 1 < end) { /* if enough room for "name=" */ if ((ngx_strncmp(name.data, start, name_len) == 0) && (start[name_len] == (u_char)'=')) { u_char *arg_end; u_char *unescaped; start += (name_len + 1); /* skip past the "name=" */ arg_end = ngx_strlchr(start, end, (u_char)'&'); /* find terminating '&' */ if (arg_end == NULL) { arg_end = end; } unescaped = (u_char *)ngx_palloc(pool, arg_end - start); value->data = unescaped; ngx_unescape_uri(&unescaped, &start, arg_end - start, NGX_UNESCAPE_URI); value->len = unescaped - value->data; return NGX_OK; } } start = ngx_strlchr(start, end, (u_char)'&'); if (start == NULL) { break; } start++; } value->data = NULL; value->len = 0; return NGX_DECLINED; }
static ngx_int_t ngx_http_eval_parse_param(ngx_http_request_t *r, ngx_http_eval_ctx_t *ctx, ngx_str_t *param) { u_char *p, *src, *dst; ngx_str_t name; ngx_str_t value; p = (u_char *) ngx_strchr(param->data, '='); if(p == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "eval: invalid param \"%V\"", param); return NGX_ERROR; } name.data = param->data; name.len = p - param->data; value.data = p + 1; value.len = param->len - (p - param->data) - 1; src = dst = value.data; ngx_unescape_uri(&dst, &src, value.len, NGX_UNESCAPE_URI); value.len = dst - value.data; ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "eval param: \"%V\"=\"%V\"", &name, &value); return ngx_http_eval_set_variable_value(r, ctx, &name, &value); }
static ngx_int_t ngx_extra_var_original_uri(ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) { ngx_str_t uri, args; u_char *src, *dst, *p; ngx_uint_t flags; uri = r->unparsed_uri; ngx_str_null(&args); flags = 0; if (NGX_OK != ngx_http_parse_unsafe_uri(r, &uri, &args, &flags)) { v->not_found = 1; return NGX_OK; } p = ngx_pnalloc(r->pool, uri.len); if (p == NULL) { return NGX_ERROR; } src = uri.data; dst = p; ngx_unescape_uri(&dst, &src, uri.len, 0); v->len = dst - p; v->valid = 1; v->no_cacheable = 0; v->not_found = 0; v->data = p; return NGX_OK; }
static ngx_int_t ngx_captcha_get_request_parameter_value( ngx_http_request_t *r, u_char *buffer, ngx_str_t *name, ngx_str_t *value ) { u_char *p = NULL; u_char *v = NULL; u_char *last = NULL; value->data = NULL; value->len = 0; if ( buffer == NULL ) { return NGX_ERROR; } ngx_log_debug( NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "searching for %s (%d)", name->data, name->len ); last = buffer + ngx_strlen( buffer ) ; for ( p = buffer; p < last; p++ ) { // we need '=' after name, so drop one char from last p = ngx_strlcasestrn(p, last - 1, name->data, name->len - 1); if ( p == NULL ) { return NGX_ERROR; } if ((p == buffer || *(p - 1) == '&') && *(p + name->len) == '=') { size_t val_len = 0; size_t dst_len = 0; v = p + name->len + 1; p = ngx_strlchr(p, last, '&'); if (p == NULL) { p = last; } val_len = (p-v); /* Allocate buffer for request parameter value */ value->data = ngx_pcalloc(r->pool, val_len + 1); if ( value->data == NULL ) { ngx_log_debug( NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "--->> BOOOM" ); return NGX_ERROR; } /* Unescape parameter value */ dst_len = (size_t)value->data; ngx_unescape_uri(&value->data, &v, val_len, NGX_UNESCAPE_URI); dst_len = (size_t) value->data - dst_len; *(value->data) = '\0'; value->data -= dst_len; value->len = dst_len; return NGX_OK; } } return ( (value->data == NULL) ? NGX_ERROR: NGX_OK ); }
/* text will be modified */ static void ngx_mail_zmauth_unescape(ngx_str_t *text) { u_char *src, *dst; size_t len; src = text->data; dst = text->data; ngx_unescape_uri(&dst, &src, text->len, NGX_UNESCAPE_URI); len = (text->data + text->len) - src; if (len) { dst = ngx_copy(dst, src, len); } text->len = dst - text->data; }
ngx_int_t ngx_http_qrcode_set_content(ngx_http_request_t *r, ngx_str_t *val, ngx_array_t *compiled_args, ngx_int_t urlencode) { ngx_str_t *arg; u_char *p; arg = compiled_args->elts; *val = arg[0]; if (urlencode == 1) { p = ngx_pcalloc(r->pool, arg->len); val->data = p; ngx_unescape_uri(&p, &arg->data, arg->len, 0); val->len = p - val->data; } return NGX_OK; }
//解析url中的参数,主要处理 http get 请求 inline ngx_str_t ngx_parser_http_request(ngx_http_request_t *r) { ngx_str_t value; // args is data=xxxxx // 第二个参数是HTTP GET的key名,key名的长度,第四个参数是想存这个value的变量的指针 if (NGX_OK != ngx_http_arg(r, (u_char*)"data", 4, &value)) { ngx_str_t res = ngx_null_string; return res; } ngx_str_t sentence; u_char* dst, *src; dst = (u_char*)ngx_pcalloc(r->pool, 1024);//解码后字词空间 src = value.data; sentence.data = dst; // 解析url 编码 ngx_unescape_uri(&dst, &src, value.len, 0); sentence.len = dst - sentence.data; //ngx_log_error(NGX_LOG_EMERG, r->connection->log, 0, " data=%s", sentence.data); return sentence; }
static ngx_int_t ngx_http_xss_header_filter(ngx_http_request_t *r) { ngx_http_xss_ctx_t *ctx; ngx_http_xss_loc_conf_t *xlcf; ngx_str_t callback; u_char *p, *src, *dst; if (r != r->main) { ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "xss skipped in subrequests"); return ngx_http_next_header_filter(r); } xlcf = ngx_http_get_module_loc_conf(r, ngx_http_xss_filter_module); if (!xlcf->get_enabled) { return ngx_http_next_header_filter(r); } if (r->method != NGX_HTTP_GET) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "xss skipped due to the unmatched request method: %V", &r->method_name); return ngx_http_next_header_filter(r); } if (xlcf->check_status) { if (r->headers_out.status != NGX_HTTP_OK && r->headers_out.status != NGX_HTTP_CREATED) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "xss skipped due to unmatched response status " "\"%ui\"", r->headers_out.status); return ngx_http_next_header_filter(r); } } if (xlcf->callback_arg.len == 0) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "xss: xss_get is enabled but no xss_callback_arg " "specified"); return ngx_http_next_header_filter(r); } if (ngx_http_test_content_type(r, &xlcf->input_types) == NULL) { ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "xss skipped due to unmatched Content-Type response " "header"); return ngx_http_next_header_filter(r); } if (ngx_http_arg(r, xlcf->callback_arg.data, xlcf->callback_arg.len, &callback) != NGX_OK) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "xss skipped: no GET argument \"%V\" specified in " "the request", &xlcf->callback_arg); return ngx_http_next_header_filter(r); } p = ngx_palloc(r->pool, callback.len); if (p == NULL) { return NGX_ERROR; } src = callback.data; dst = p; ngx_unescape_uri(&dst, &src, callback.len, NGX_UNESCAPE_URI_COMPONENT); if (src != callback.data + callback.len) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "xss: unescape uri: input data not consumed completely"); return NGX_ERROR; } callback.data = p; callback.len = dst - p; if (ngx_http_xss_test_callback(callback.data, callback.len) != NGX_OK) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "xss: bad callback argument: \"%V\"", &callback); return ngx_http_next_header_filter(r); } ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_xss_ctx_t)); if (ctx == NULL) { return NGX_ERROR; } /* * set by ngx_pcalloc(): * * ctx->callback = { 0, NULL }; * ctx->before_body_sent = 0; */ ctx->callback = callback; ngx_http_set_ctx(r, ctx, ngx_http_xss_filter_module); r->headers_out.content_type = xlcf->output_type; r->headers_out.content_type_len = xlcf->output_type.len; r->headers_out.content_type_lowcase = NULL; ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "xss output Content-Type header \"%V\"", &xlcf->output_type); ngx_http_clear_content_length(r); ngx_http_clear_accept_ranges(r); if (xlcf->override_status && r->headers_out.status >= NGX_HTTP_SPECIAL_RESPONSE) { r->headers_out.status = NGX_HTTP_OK; } return ngx_http_next_header_filter(r); }
static ngx_int_t ngx_http_xss_header_filter(ngx_http_request_t *r) { ngx_http_xss_ctx_t *ctx; ngx_http_xss_conf_t *conf; ngx_str_t callback; u_char *p, *src, *dst; if (r->headers_out.status != NGX_HTTP_OK || r != r->main) { dd("skipped: status not 200 or in subrequest"); return ngx_http_next_header_filter(r); } conf = ngx_http_get_module_loc_conf(r, ngx_http_xss_filter_module); if ( ! conf->get_enabled || r->method != NGX_HTTP_GET) { dd("skipped: get_enabled disabled or the current method is not GET"); return ngx_http_next_header_filter(r); } if (conf->callback_arg.len == 0) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "xss: xss_get is enabled but no xss_callback_arg specified"); return ngx_http_next_header_filter(r); } if (ngx_http_test_content_type(r, &conf->input_types) == NULL) { dd("skipped: content type test not passed"); return ngx_http_next_header_filter(r); } if (ngx_http_arg(r, conf->callback_arg.data, conf->callback_arg.len, &callback) != NGX_OK) { dd("skipped: no callback arg found in the current request: %.*s", conf->callback_arg.len, conf->callback_arg.data); return ngx_http_next_header_filter(r); } p = ngx_palloc(r->pool, callback.len); if (p == NULL) { return NGX_ERROR; } src = callback.data; dst = p; ngx_unescape_uri(&dst, &src, callback.len, NGX_UNESCAPE_URI_COMPONENT); if (src != callback.data + callback.len) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "xss: unescape uri: input data not consumed completely"); return NGX_ERROR; } callback.data = p; callback.len = dst - p; if (ngx_http_xss_test_callback((char *) callback.data, callback.len) != NGX_OK) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "xss: bad callback argument: \"%V\"", &callback); return ngx_http_next_header_filter(r); } ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_xss_ctx_t)); if (ctx == NULL) { return NGX_ERROR; } /* * set by ngx_pcalloc(): * * ctx->callback = { 0, NULL }; * conf->before_body_sent = 0; */ ctx->callback = callback; ngx_http_set_ctx(r, ctx, ngx_http_xss_filter_module); r->headers_out.content_type = conf->output_type; r->headers_out.content_type_len = conf->output_type.len; ngx_http_clear_content_length(r); ngx_http_clear_accept_ranges(r); return ngx_http_next_header_filter(r); }
static const char * ngx_rtmp_control_relay_handler(ngx_http_request_t *r, ngx_rtmp_session_t *s, ngx_rtmp_core_srv_conf_t *cscf, ngx_rtmp_core_app_conf_t **cacf) { ngx_rtmp_control_ctx_t *ctx; ngx_url_t *u; ngx_str_t name, decoded; ngx_rtmp_relay_target_t *target, **t; u_char *dst; ngx_rtmp_relay_app_conf_t *racf; u_char is_pull, is_static = 1, start; ngx_event_t *e; ngx_rtmp_relay_static_t *rs; static ngx_rtmp_control_event_chain_t *evt_chain = NULL, *evt_last; ngx_rtmp_control_event_chain_t *evt_cur, *evt_prv; racf = (*cacf)->app_conf[ngx_rtmp_relay_module.ctx_index]; target = ngx_pcalloc(cscf->pool, sizeof(*target)); if (target == NULL) { return "unable to allocate memory"; } ngx_memzero(target, sizeof(*target)); target->tag = &ngx_rtmp_relay_module; target->data = target; ctx = ngx_http_get_module_ctx(r, ngx_rtmp_control_module); if (ctx->method.len == sizeof("start") - 1 && ngx_strncmp(ctx->method.data, "start", ctx->method.len) == 0) { start = 1; } else if (ctx->method.len == sizeof("stop") - 1 && ngx_strncmp(ctx->method.data, "stop", ctx->method.len) == 0) { start = 0; } else { return "Undefined method"; } if (ngx_http_arg(r, (u_char *) "name", sizeof("name") - 1, &name) == NGX_OK) { target->name.data = ngx_pnalloc(cscf->pool, name.len + 1); target->name.len = name.len; ngx_memcpy(target->name.data, name.data, name.len); } if (start == 0) { if (s) { ngx_rtmp_control_drop_handler(r, s, cscf, cacf); } for (evt_prv = NULL, evt_cur = evt_chain; evt_cur;) { e = &evt_cur->event; rs = e ? e->data : NULL; ngx_log_debug(NGX_LOG_DEBUG_RTMP, r->connection->log, 0, "control: matching name='%*s' candidate='%*s'", target->name.len, target->name.data, rs && rs->target ? rs->target->name.len : 0, rs && rs->target ? rs->target->name.data : NULL); if(!rs) { if(evt_prv) { evt_prv->next = evt_cur->next; } else { evt_chain = evt_cur->next; } if(!evt_cur->next) { evt_last = evt_prv; } evt_prv = evt_cur->next; ngx_pfree(cscf->pool, evt_cur); evt_cur = evt_prv; continue; } if (rs->cctx.main_conf == (void **)cscf->ctx->main_conf && rs->cctx.srv_conf == (void **)cscf->ctx->srv_conf && rs->cctx.app_conf == (void **)cacf && rs->target->name.len == target->name.len && ngx_strncmp(rs->target->name.data, target->name.data, target->name.len) == 0) { ngx_log_debug(NGX_LOG_DEBUG_RTMP, r->connection->log, 0, "control: stopped url='%*s'", rs->target->url.url.len, rs->target->url.url.data); ngx_pfree(cscf->pool, e->data); e->data = NULL; if(evt_prv) { evt_prv->next = evt_cur->next; } else { evt_chain = evt_cur->next; } if(!evt_cur->next) { evt_last = evt_prv; } evt_prv = evt_cur->next; ngx_pfree(cscf->pool, evt_cur); evt_cur = evt_prv; continue; } evt_prv = evt_cur; evt_cur = evt_cur->next; } return NGX_CONF_OK; } if (ngx_http_arg(r, (u_char *) "push", sizeof("push") - 1, &name) == NGX_OK) { is_pull = 0; } else if (ngx_http_arg(r, (u_char *) "pull", sizeof("pull") - 1, &name) == NGX_OK) { is_pull = 1; } else { return "unknown relay type"; } dst = ngx_pnalloc(cscf->pool, name.len); if (dst == NULL) { return "unable to allocate memory"; } decoded.data = dst; ngx_unescape_uri(&dst, &name.data, name.len, 0); decoded.len = dst - decoded.data; if (ngx_strncasecmp(decoded.data, (u_char *) "rtmp://", 7)) { ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, "control: relay %s '%*s'", (is_pull ? "from" : "to" ), decoded.len, decoded.data); return "invalid relay url"; } ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "control: %*s relay from '%*s'", ctx->method.len, ctx->method.data, decoded.len, decoded.data); u = &target->url; u->url.data = decoded.data + 7; u->url.len = decoded.len - 7; u->default_port = 1935; u->uri_part = 1; if (ngx_parse_url(cscf->pool, u) != NGX_OK) { ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, "control: %s failed '%*s'", (is_pull ? "pull" : "push" ), decoded.len, decoded.data); return "invalid relay url"; } if (u->uri.len > 0 && ngx_rtmp_parse_relay_str(cscf->pool, target, &is_static) != NGX_OK) { ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, "control: %s failed with args '%*s'", (is_pull ? "pull" : "push" ), &u->uri.len, &u->uri.data); return "invalid relay args"; } if (u->uri.len == 0) { ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, "control: %s has no remote url '%*s'", (is_pull ? "pull" : "push" ), decoded.len, decoded.data); return "no relay url"; } if (is_static) { if (!is_pull) { ngx_log_error(NGX_LOG_EMERG, r->connection->log, 0, "static push is not allowed"); return NGX_CONF_ERROR; } if (target->name.len == 0) { ngx_log_error(NGX_LOG_EMERG, r->connection->log, 0, "stream name missing in static pull " "declaration"); return NGX_CONF_ERROR; } if (evt_chain == NULL) { evt_chain = ngx_pcalloc(cscf->pool, sizeof(*evt_chain)); if (evt_chain == NULL) { return "unable to allocate memory"; } ngx_memzero(evt_chain, sizeof(*evt_chain)); evt_last = evt_chain; } else { evt_last->next = ngx_pcalloc(cscf->pool, sizeof(*evt_chain)); if (evt_last->next == NULL) { return "unable to allocate memory"; } ngx_memzero(evt_last->next, sizeof(*evt_chain)); evt_last = evt_last->next; } e = &evt_last->event; rs = ngx_pcalloc(cscf->pool, sizeof(ngx_rtmp_relay_static_t)); if (rs == NULL) { return "unable to allocate memory"; } rs->target = target; rs->cctx.main_conf = (void **)cscf->ctx->main_conf; rs->cctx.srv_conf = (void **)cscf->ctx->srv_conf; rs->cctx.app_conf = (void **)cacf; e->data = rs; e->log = r->connection->log; e->handler = ngx_rtmp_relay_static_pull_reconnect; ngx_rtmp_relay_static_pull_reconnect(e); } else if (is_pull) { t = ngx_array_push(&racf->pulls); if (t == NULL) { return NGX_CONF_ERROR; } *t = target; } else { t = ngx_array_push(&racf->pushes); if (t == NULL) { return NGX_CONF_ERROR; } *t = target; } return NGX_CONF_OK; }
static ngx_int_t hexin_http_percn_post_handler(ngx_http_request_t *r) { ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "进入 hexin_http_percn_post_handler 方法.."); hexin_http_percn_loc_conf_t *plcf; hexin_http_percn_ctx_t *ctx; ngx_http_variable_value_t *receivers, *common, *block_size; u_char *buf, *unescapebuf; ngx_int_t rc; plcf = ngx_http_get_module_loc_conf(r, hexin_http_percn_module); ctx = ngx_http_get_module_ctx(r, hexin_http_percn_module); //获得分割所依据的字段值,并获得所以子请求通用的Form参数 receivers = ngx_http_get_indexed_variable(r, plcf->receivers_index); common = ngx_http_get_indexed_variable(r, plcf->common_index); ctx->common = common; ctx->receivers_complete_val_len = receivers->len; ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "接收者为: %v, ----- 通用体: %v", receivers, common); buf = ngx_pnalloc(r->pool, receivers->len); if(buf == NULL) { ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "分配 buf 内存失败!"); return NGX_ERROR; } ngx_memcpy(buf, receivers->data, receivers->len); ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "URL 解码前: %s", buf); //进行URI 解码 unescapebuf = ngx_pnalloc(r->pool, receivers->len); ngx_unescape_uri(&unescapebuf, &buf, receivers->len, NGX_ESCAPE_ARGS); ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "URL 解码后: %s", buf); //获取分割的尺寸大小 block_size = ngx_http_get_indexed_variable(r, plcf->block_size_index); ngx_int_t block_size_int = ngx_atoi(block_size->data, block_size->len); ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "推送块尺寸为: %d", block_size_int); //以','为分割符进行切割 并循环创建子请求 char *p, *brkt; ngx_int_t count = 1; size_t len = 0; size_t fla_len = 0; u_char* next = receivers->data; for (p = strtok_r( (char *)buf, ",", &brkt); p; p = strtok_r(NULL, ",", &brkt)) { len += ngx_strlen(p); fla_len++; if((count++) % (block_size_int) == 0) { //获得块长度 u_char* part ; size_t mem_len = len + 3 * fla_len; //分配块内存 并拷贝内存赋值 part = ngx_pnalloc(r->pool, mem_len - 3); ngx_memcpy(part, next, mem_len -3); next = next + mem_len; ctx->receivers_part_val_len = mem_len - 3; ctx->receivers_part_val = part; //================= hexin_http_percn_subrequest_t *parsed_sr; ngx_http_request_t *sr; /* subrequest object */ rc = hexin_http_percn_create_subrequest(r, &parsed_sr); if (rc != NGX_OK) { return rc; } ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "创建子查询."); rc = ngx_http_subrequest(r, parsed_sr->location, NULL, &sr, NULL, 0); if (rc != NGX_OK) { return NGX_ERROR; } ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "创建子查询结束, 开始调整参数."); rc = hexin_http_percn_adjust_subrequest(sr, parsed_sr); if (rc != NGX_OK) { return rc; } //================= len = 0; fla_len = 0; } } //剩余请求 if(len != 0) { u_char* part ; size_t mem_len = len + 3 * fla_len; part = ngx_pnalloc(r->pool, mem_len - 3); ngx_memcpy(part, next, mem_len -3); ctx->receivers_part_val_len = mem_len - 3; ctx->receivers_part_val = part; //================= hexin_http_percn_subrequest_t *parsed_sr; ngx_http_request_t *sr; /* subrequest object */ rc = hexin_http_percn_create_subrequest(r, &parsed_sr); if (rc != NGX_OK) { return rc; } rc = ngx_http_subrequest(r, parsed_sr->location, NULL, &sr, NULL, 0); if (rc != NGX_OK) { return NGX_ERROR; } rc = hexin_http_percn_adjust_subrequest(sr, parsed_sr); if (rc != NGX_OK) { return rc; } //================= len = 0; } ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, " hexin_http_percn_post_handler 方法 结束.."); return NGX_OK; }
static CWX_KEY_VALUE* ngx_http_cwinux_parse_args(ngx_str_t* args, ngx_pool_t* pool) { CWX_KEY_VALUE* head = NULL; CWX_KEY_VALUE* tail = NULL; char const *begin = NULL; char const *mid = NULL; char const *end =NULL; CWX_KEY_VALUE* key_value = NULL; unsigned int key_len = 0; unsigned int data_len = 0; u_char* src, *dst; size_t len = args->len; begin = (char*)args->data; mid = ngx_cwinux_strchr(begin, len, '='); while(mid){ key_value = (CWX_KEY_VALUE*)ngx_pcalloc(pool, sizeof(CWX_KEY_VALUE)); //get key while(*begin == '&') begin++; key_len = mid - begin; key_value->m_key = (char*)ngx_pcalloc(pool, key_len+1); key_value->m_lowerkey = (char*)ngx_pcalloc(pool, key_len+1); memcpy(key_value->m_key, begin, key_len); key_value->m_key[key_len] = 0x00; src = (u_char*)key_value->m_key; dst = (u_char*)key_value->m_key; ngx_unescape_uri(&dst, &src, key_len, 0); *dst = 0; ngx_cwinux_trim(key_value->m_key); ngx_strlow((u_char*)key_value->m_lowerkey, (u_char*)key_value->m_key, strlen(key_value->m_key)); //get data mid++; end = strchr(mid, '&'); if (0 == end) data_len = args->len - ((u_char*)mid - args->data); else data_len = end - mid; key_value->m_value = (char*)ngx_pcalloc(pool, data_len+1); memcpy(key_value->m_value, mid, data_len); key_value->m_value[data_len] = 0x00; src = (u_char*)key_value->m_value; dst = (u_char*)key_value->m_value; ngx_unescape_uri(&dst, &src, data_len, 0); *dst = 0; //add to the key_value->m_next = NULL; if (!head){ head = tail = key_value; }else{ tail->m_next = key_value; tail = key_value; } if (end){ len -= (end+1 - begin); begin = end+1; mid = ngx_cwinux_strchr(begin, len, '='); }else{ break; } } return head; }
/* * Called when the full body has been received. Even if the body is sent in * multiple chunks, this will be called only once when everything has * been received. */ void ngx_http_rrd_body_received(ngx_http_request_t *r) { ngx_log_t *log = r->connection->log; ngx_chain_t *body_chain = r->request_body->bufs; /* Use the content length as a max for our value. */ u_char* copy_idx; /* In theory I should check for the size of the body to avoid loading * too much stuff in memory. However this is already handled by nginx * client_max_body_size. If the admin thinks it's taking too much memory * he/she should use client_max_body_size. */ u_char* rrd_value = copy_idx = ngx_palloc(r->pool, r->headers_in.content_length_n); if (NULL == rrd_value) { ngx_log_error(NGX_LOG_ALERT, log, 0, "Alloc problem @ngx_http_rrd_body_received/1"); return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); } u_char* p; /* TODO: rewrite this to first READ in mem, then look for = and urldecode*/ ngx_int_t looking_for_eq = 1; /* Needed for pipelined requests in HTTP/1.1 which can all be in one buf. */ ngx_int_t left_in_contentlength = r->headers_in.content_length_n; do { ngx_buf_t *temp_buf; if (body_chain->buf->in_file) { ngx_buf_t * file_buf = body_chain->buf; /* Read it first in mem. This is unfortunately blocking. * TODO : non-blocking. HttpUploadModule ? */ temp_buf = ngx_create_temp_buf(r->pool, ngx_buf_size(file_buf)); if (NULL == temp_buf) { ngx_log_error(NGX_LOG_ALERT, log, 0, "Alloc problem @ngx_http_rrd_body_received/2"); return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); } ssize_t read_n; read_n = ngx_read_file(file_buf->file, temp_buf->start, ngx_buf_size(file_buf), 0); if (read_n < 0) { /* Problem already logged by read_file. */ return ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); } else { temp_buf->last = temp_buf->start + read_n; } } else { temp_buf = body_chain->buf; } p = temp_buf->start; while (p!=temp_buf->last && looking_for_eq && left_in_contentlength>0) { if ('=' == *(p++)) { looking_for_eq = 0; } left_in_contentlength--; } if (!looking_for_eq) { u_char *dst = copy_idx; u_char *src = p; /* * This won't work if buffer boundary is in the middle of a * percent-encoded string (which is unlikely to happen I would * say. Should try to unit test this situation. */ /* We'll copy only what's left in buffer or what's left in * content-length. */ size_t size_to_copy; if (left_in_contentlength < temp_buf->last - p) { size_to_copy = left_in_contentlength; } else { size_to_copy = temp_buf->last - p; } ngx_unescape_uri(&dst, &src, size_to_copy, 0); left_in_contentlength -= size_to_copy; copy_idx = dst; } body_chain = body_chain->next; } while (NULL != body_chain); *copy_idx = '\x0'; ngx_http_rrd_loc_conf_t *rrd_conf; rrd_conf = ngx_http_get_module_loc_conf(r, ngx_http_rrd_module); int rrd_rc; ngx_log_debug(NGX_LOG_DEBUG_HTTP, log, 0, "rrd_update_r (%s, NULL, 1, %s)", rrd_conf->db_name_cstyle, rrd_value); rrd_clear_error(); rrd_rc = rrd_update_r(rrd_conf->db_name_cstyle, NULL, 1, (const char **)&rrd_value); ngx_log_debug(NGX_LOG_DEBUG_HTTP, log, 0, "rrd_update_r returned: %d", rrd_rc); ngx_int_t rc; if (rrd_rc < 0) { char * rrd_err = rrd_get_error(); ngx_log_error(NGX_LOG_ALERT, log, 0, "Problem on rrd_update_r: %s", rrd_err); rc = ngx_http_rrd_outprintf(r, NGX_HTTP_INTERNAL_SERVER_ERROR, "Problem (%s) updating %s with %s.", rrd_err, rrd_conf->db_name_cstyle, &rrd_value); } else { rc = ngx_http_rrd_outprintf(r, NGX_HTTP_OK, "Updated %s. You make the rock-n-roll go round, Robin.", rrd_conf->db_name_cstyle); } ngx_http_finalize_request(r, rc); }
static ngx_str_t* ngx_http_graphicsmagick_get_command(ngx_http_request_t *r) { u_char *dst, *src; size_t len; u_char *p, *start_p; ngx_uint_t i; ngx_list_part_t *part; ngx_table_elt_t *header; ngx_str_t *ret; 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].key.len == ngx_http_graphicsmagick_command_header.len && ngx_strncmp(header[i].key.data, ngx_http_graphicsmagick_command_header.data, header[i].key.len) == 0) { ret = ngx_pcalloc(r->pool, sizeof(ngx_str_t)); ret->data = header[i].value.data; ret->len = header[i].value.len; return ret; } } /* not found, check as a reaquest arg */ if (r->args.len) { p = (u_char *) ngx_strstr(r->args.data, "X-ImageMagick-Convert"); if (p) { start_p = p += 22; while (p < r->args.data + r->args.len) { if (*p++ != '&') { continue; } } ret = ngx_pcalloc(r->pool, sizeof(ngx_str_t)); ret->data = start_p; ret->len = p - start_p; dst = ret->data; src = ret->data; ngx_unescape_uri(&dst, &src, ret->len, NGX_UNESCAPE_URI); len = (ret->data + ret->len) - src; if (len) { dst = ngx_copy(dst, src, len); } ret->len = dst - ret->data; return ret; } } return NULL; }
static ngx_int_t ngx_lua_http_btt_parse_args(ngx_http_request_t *r, ngx_btt_ctx_t *ctx) { size_t nlen, vlen; u_char *p, *last, *name, *val, *dst, *src; ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "lua http btt parse args"); if (r->args.len == 0) { ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, "invalid uri \"%V\"", &r->args); return NGX_ERROR; } p = r->args.data; last = p + r->args.len; for ( /* void */ ; p < last; p++) { name = p; p = ngx_strlchr(p, last, '&'); if (p == NULL) { p = last; } val = ngx_strlchr(name, p, '='); if (val == NULL) { val = p; } nlen = val - name; vlen = (++val < p) ? p - val : 0; dst = ngx_pnalloc(r->pool, vlen); if (dst == NULL) { return NGX_ERROR; } src = val; val = dst; ngx_unescape_uri(&dst, &src, vlen, 0); vlen = dst - val; ngx_log_debug4(NGX_LOG_ALERT, r->connection->log, 0, "%*s=%*s", nlen, name, vlen, val); /* * BT Client: * * BitComet: localip, natmapped, port_type * NetTransport: supportcrypto * uTorrent: corrupt * XunLei: ip */ switch (nlen) { case 2: if (ngx_strncmp(name, "ip", nlen) == 0) { ctx->internal_ip = ngx_inet_addr(val, vlen); if (ctx->internal_ip == INADDR_NONE) { goto invalid; } break; } break; case 3: if (ngx_strncmp(name, "key", nlen) == 0) { ngx_memcpy(ctx->key, val, vlen); break; } break; case 4: if (ngx_strncmp(name, "port", nlen) == 0) { ctx->internal_port = (in_port_t) ngx_atoi(val, vlen); if (ctx->internal_port == NGX_ERROR) { goto invalid; } break; } if (ngx_strncmp(name, "left", nlen) == 0) { ctx->left = ngx_atoof(val, vlen); if (ctx->left == NGX_ERROR) { goto invalid; } break; } break; case 5: if (ngx_strncmp(name, "event", nlen) == 0) { if (ngx_strncmp(val, "none", sizeof("none") - 1) == 0) { ctx->event = NGX_BTT_EVENT_NONE; } else if (ngx_strncmp(val, "completed", sizeof("completed") - 1) == 0) { ctx->event = NGX_BTT_EVENT_COMPLETED; } else if (ngx_strncmp(val, "started", sizeof("started") - 1) == 0) { ctx->event = NGX_BTT_EVENT_STARTED; } else if (ngx_strncmp(val, "stopped", sizeof("stopped") - 1) == 0) { ctx->event = NGX_BTT_EVENT_STOPPED; } else { goto invalid; } break; } break; case 7: if (ngx_strncmp(name, "peer_id", nlen) == 0) { ngx_memcpy(ctx->peer_id, val, vlen); break; } if (ngx_strncmp(name, "localip", nlen) == 0) { ctx->internal_ip = ngx_inet_addr(val, vlen); if (ctx->internal_ip == INADDR_NONE) { goto invalid; } break; } if (ngx_strncmp(name, "numwant", nlen) == 0) { ctx->numwant = ngx_atoi(val, vlen); if (ctx->numwant == NGX_ERROR) { goto invalid; } break; } if (ngx_strncmp(name, "compact", nlen) == 0) { ctx->compact = ngx_atoi(val, vlen); if (ctx->compact == NGX_ERROR) { goto invalid; } break; } if (ngx_strncmp(name, "corrupt", nlen) == 0) { ctx->corrupt = ngx_atoi(val, vlen); if (ctx->corrupt == NGX_ERROR) { goto invalid; } break; } break; case 8: if (ngx_strncmp(name, "uploaded", nlen) == 0) { ctx->uploaded = ngx_atoof(val, vlen); if (ctx->uploaded == NGX_ERROR) { goto invalid; } break; } break; case 9: if (ngx_strncmp(name, "info_hash ", nlen) == 0) { ngx_memcpy(ctx->info_hash, val, vlen); break; } if (ngx_strncmp(name, "natmapped ", nlen) == 0) { ctx->natmapped = ngx_atoi(val, vlen); if (ctx->natmapped == NGX_ERROR) { goto invalid; } break; } if (ngx_strncmp(name, "port_type", nlen) == 0) { ngx_memcpy(ctx->port_type, val, vlen); break; } break; case 10: if (ngx_strncmp(name, "downloaded", nlen) == 0) { ctx->downloaded = ngx_atoof(val, vlen); if (ctx->downloaded == NGX_ERROR) { goto invalid; } break; } if (ngx_strncmp(name, "no_peer_id ", nlen) == 0) { ctx->no_peer_id = ngx_atoi(val, vlen); if (ctx->no_peer_id == NGX_ERROR) { goto invalid; } break; } break; case 13: if (ngx_strncmp(name, "supportcrypto", nlen) == 0) { ctx->supportcrypto = ngx_atoi(val, vlen); if (ctx->supportcrypto == NGX_ERROR) { goto invalid; } break; } break; default: break; } } return NGX_OK; invalid: ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, "invalid value \"%*s\" of the key \"%*s\"", nlen, name, vlen, val); return NGX_ERROR; }
ngx_int_t ngx_lcb_process(ngx_http_request_t *r) { lcb_error_t err = LCB_NOT_SUPPORTED; ngx_http_variable_value_t *vv; ngx_str_t key, val; enum ngx_lcb_cmd opcode; ngx_http_core_loc_conf_t *clcf; ngx_lcb_connection_t *conn; lcb_cas_t cas = 0; lcb_uint32_t flags = 0, exptime = 0; ngx_int_t need_free_value = 0; clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module); conn = ngx_http_get_couchbase_connection(clcf->name); if (conn == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "couchbase: connection not found: \"%V\"", &clcf->name); return NGX_HTTP_INTERNAL_SERVER_ERROR; } /* setup command: use variable or fallback to HTTP method */ vv = ngx_http_get_indexed_variable(r, ngx_lcb_cmd_idx); if (vv == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (vv->not_found || vv->len == 0) { if (r->method & (NGX_HTTP_GET | NGX_HTTP_HEAD)) { opcode = ngx_lcb_cmd_get; } else if (r->method == NGX_HTTP_POST) { opcode = ngx_lcb_cmd_add; } else if (r->method == NGX_HTTP_PUT) { opcode = ngx_lcb_cmd_set; } else if (r->method == NGX_HTTP_DELETE) { opcode = ngx_lcb_cmd_delete; } else { ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, "ngx_memc: $memc_cmd variable requires explicit " "assignment for HTTP request method %V", &r->method_name); ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); return NGX_HTTP_BAD_REQUEST; } } else { if (ngx_strncmp(vv->data, "get", 3) == 0) { opcode = ngx_lcb_cmd_get; } else if (ngx_strncmp(vv->data, "add", 3) == 0) { opcode = ngx_lcb_cmd_add; } else if (ngx_strncmp(vv->data, "replace", 7) == 0) { opcode = ngx_lcb_cmd_replace; } else if (ngx_strncmp(vv->data, "set", 3) == 0) { opcode = ngx_lcb_cmd_set; } else if (ngx_strncmp(vv->data, "append", 6) == 0) { opcode = ngx_lcb_cmd_append; } else if (ngx_strncmp(vv->data, "prepend", 7) == 0) { opcode = ngx_lcb_cmd_prepend; } else if (ngx_strncmp(vv->data, "delete", 6) == 0) { opcode = ngx_lcb_cmd_delete; } else { ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, "ngx_memc: unknown $couchbase_cmd \"%v\"", vv); ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); return NGX_HTTP_BAD_REQUEST; } } /* setup key: use variable or fallback to URI */ vv = ngx_http_get_indexed_variable(r, ngx_lcb_key_idx); if (vv == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (vv->not_found || vv->len == 0) { size_t loc_len; loc_len = r->valid_location ? clcf->name.len : 0; key.data = r->uri.data + loc_len; key.len = r->uri.len - loc_len; } else { u_char *dst, *src; key.data = ngx_palloc(r->pool, vv->len); if (key.data == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } dst = key.data; src = vv->data; ngx_unescape_uri(&dst, &src, vv->len, 0); *dst = 0; key.len = dst - key.data; } /* setup value: use variable or fallback to HTTP body */ ngx_str_null(&val); if (opcode >= ngx_lcb_cmd_add && opcode <= ngx_lcb_cmd_prepend) { vv = ngx_http_get_indexed_variable(r, ngx_lcb_val_idx); if (vv == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (vv->not_found || vv->len == 0) { if (r->request_body == NULL || r->request_body->bufs == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "neither the \"$couchbase_value\" variable " "nor the request body is available"); ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); return NGX_HTTP_BAD_REQUEST; } else { /* copy body to the buffer */ ngx_chain_t *cl; u_char *p; val.len = 0; for (cl = r->request_body->bufs; cl; cl = cl->next) { val.len += ngx_buf_size(cl->buf); } p = val.data = ngx_palloc(r->pool, val.len); if (p == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } for (cl = r->request_body->bufs; cl; cl = cl->next) { p = ngx_copy(p, cl->buf->pos, cl->buf->last - cl->buf->pos); } vv = NULL; } } else { u_char *dst, *src; val.data = ngx_palloc(r->pool, vv->len); if (val.data == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } need_free_value = 1; dst = val.data; src = vv->data; ngx_unescape_uri(&dst, &src, vv->len, 0); *dst = 0; val.len = dst - val.data; } } /* setup CAS value */ vv = ngx_http_get_indexed_variable(r, ngx_lcb_cas_idx); if (vv == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (!vv->not_found && vv->len > 0) { if (ngx_lcb_atocas(vv->data, vv->len, &cas) != NGX_OK) { ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); return NGX_HTTP_BAD_REQUEST; } } /* setup flags value */ vv = ngx_http_get_indexed_variable(r, ngx_lcb_flags_idx); if (vv == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (!vv->not_found && vv->len > 0) { flags = ngx_atoi(vv->data, vv->len); } /* setup expiration value */ vv = ngx_http_get_indexed_variable(r, ngx_lcb_exptime_idx); if (vv == NULL) { ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (!vv->not_found && vv->len > 0) { exptime = ngx_atoi(vv->data, vv->len); } switch (opcode) { case ngx_lcb_cmd_get: { lcb_get_cmd_t cmd; const lcb_get_cmd_t *commands[1]; commands[0] = &cmd; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.key = key.data; cmd.v.v0.nkey = key.len; cmd.v.v0.exptime = exptime; err = lcb_get(conn->lcb, r, 1, commands); ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "couchbase(%p): get request \"%*s\"", (void *)conn->lcb, cmd.v.v0.nkey, cmd.v.v0.key); } break; case ngx_lcb_cmd_add: case ngx_lcb_cmd_replace: case ngx_lcb_cmd_set: case ngx_lcb_cmd_append: case ngx_lcb_cmd_prepend: { lcb_store_cmd_t cmd; const lcb_store_cmd_t *commands[1]; commands[0] = &cmd; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.operation = opcode; cmd.v.v0.key = key.data; cmd.v.v0.nkey = key.len; cmd.v.v0.bytes = val.data; cmd.v.v0.nbytes = val.len; cmd.v.v0.cas = cas; cmd.v.v0.flags = flags; cmd.v.v0.exptime = exptime; err = lcb_store(conn->lcb, r, 1, commands); ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "couchbase(%p): store request \"%*s\", operation: 0x%02xd", (void *)conn->lcb, cmd.v.v0.nkey, cmd.v.v0.key, cmd.v.v0.operation); } break; case ngx_lcb_cmd_delete: { lcb_remove_cmd_t cmd; const lcb_remove_cmd_t *commands[1]; commands[0] = &cmd; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.key = key.data; cmd.v.v0.nkey = key.len; err = lcb_remove(conn->lcb, r, 1, commands); ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "couchbase(%p): remove request \"%*s\"", (void *)conn->lcb, cmd.v.v0.nkey, cmd.v.v0.key); } break; } if (need_free_value) { ngx_pfree(r->pool, val.data); } if (err != LCB_SUCCESS) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "couchbase: failed to schedule couchbase request: %s", lcb_strerror(conn->lcb, err)); ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); return NGX_ERROR; } return NGX_OK; }
static ngx_int_t ngx_rtmp_authen_http_response_decode(ngx_rtmp_session_t *s, ngx_rtmp_authen_ctx_t *ctx) { ngx_http_request_t r; ngx_str_t val; u_char val_buf[NGX_RTMP_AUTHEN_MAX_RESPONSE]; u_char status; ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, "connect (authen): response: %s", ctx->resp.data); val.len = 0; val.data = val_buf; r.args.len = ctx->resp.len; r.args.data = ctx->resp.data; ctx->conn_desc.len = 0; if (ngx_http_arg(&r, (u_char *)"desc", sizeof("desc") - 1, &val) == NGX_OK && val.len > 0) { ctx->conn_desc.len = ngx_base64_decoded_length(val.len); ctx->conn_desc.data = ngx_pcalloc(s->connection->pool, ctx->conn_desc.len + 1); if (ctx->conn_desc.data != NULL && ngx_decode_base64(&ctx->conn_desc, &val) == NGX_OK) { ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, "connect (authen): description: %s", ctx->conn_desc.data); } else { ctx->conn_desc.len = 0; } } val.len = 0; if (ngx_http_arg(&r, (u_char *)"status", sizeof ("status") - 1, &val) != NGX_OK || val.len == 0) { return NGX_ERROR; } else { status = val.data[0]; ctx->user.len = 0; val.len = 0; if (ngx_http_arg(&r, (u_char *)"user", sizeof("user") - 1, &val) == NGX_OK && val.len > 0) { ctx->user.data = ngx_pcalloc(s->connection->pool, val.len + 1); if (ctx->user.data != NULL) { u_char *dst = ctx->user.data; ngx_unescape_uri(&dst, &val.data, val.len, 0); *dst = '\0'; ctx->user.len = ngx_strlen(ctx->user.data); } } ctx->authmod.len = 0; val.len = 0; if (ngx_http_arg(&r, (u_char *)"authmod", sizeof("authmod") - 1, &val) == NGX_OK && val.len > 0) { ctx->authmod.data = ngx_pcalloc(s->connection->pool, val.len + 1); if (ctx->authmod.data != NULL) { u_char *dst = ctx->authmod.data; ngx_unescape_uri(&dst, &val.data, val.len, 0); *dst = '\0'; ctx->authmod.len = ngx_strlen(ctx->authmod.data); } } } switch (status) { /* Allow */ case (u_char)'a': case (u_char)'A': if (ctx->user.len > 0) { ngx_log_error(NGX_LOG_INFO, s->connection->log, 0, "connect (authen): Allow, user: %s", ctx->user.data); } else { ngx_log_error(NGX_LOG_INFO, s->connection->log, 0, "connect (authen): Allow"); } ctx->conn_status = NGX_RTMP_CONN_ALLOW; return NGX_OK; /* Reject */ case (u_char)'r': case (u_char)'R': if (ctx->user.len > 0) { ngx_log_error(NGX_LOG_INFO, s->connection->log, 0, "connect (authen): Reject, user: %s", ctx->user.data); } else { ngx_log_error(NGX_LOG_INFO, s->connection->log, 0, "connect (authen): Reject"); } if (ctx->conn_desc.len > 0) { ngx_log_error(NGX_LOG_INFO, s->connection->log, 0, "connect (authen): Reject, reason: %s", ctx->conn_desc.data); } ctx->conn_status = NGX_RTMP_CONN_REJECT; return NGX_OK; /* Deny */ case (u_char)'d': case (u_char)'D': default: if (ctx->user.len > 0) { ngx_log_error(NGX_LOG_INFO, s->connection->log, 0, "connect (authen): Deny, user: %s", ctx->user.data); } else { ngx_log_error(NGX_LOG_INFO, s->connection->log, 0, "connect (authen): Deny"); } ctx->conn_status = NGX_RTMP_CONN_DENY; return NGX_ERROR; } }