static ngx_http_upstream_srv_conf_t *
ngx_http_lua_upstream_find_upstream(lua_State *L, ngx_str_t *host)
{
u_char *port;
size_t len;
ngx_int_t n;
ngx_uint_t i;
ngx_http_upstream_srv_conf_t **uscfp, *uscf;
ngx_http_upstream_main_conf_t *umcf;
umcf = ngx_http_lua_upstream_get_upstream_main_conf(L);
uscfp = umcf->upstreams.elts;
for (i = 0; i < umcf->upstreams.nelts; i++) {
uscf = uscfp[i];
if (uscf->host.len == host->len
&& ngx_memcmp(uscf->host.data, host->data, host->len) == 0)
{
return uscf;
}
}
port = ngx_strlchr(host->data, host->data + host->len, ':');
if (port) {
port++;
n = ngx_atoi(port, host->data + host->len - port);
if (n < 1 || n > 65535) {
return NULL;
}
/* try harder with port */
len = port - host->data - 1;
for (i = 0; i < umcf->upstreams.nelts; i++) {
uscf = uscfp[i];
if (uscf->port
&& uscf->port == n
&& uscf->host.len == len
&& ngx_memcmp(uscf->host.data, host->data, len) == 0)
{
return uscf;
}
}
}
return NULL;
}
static ngx_tcp_virtual_server_t *
ngx_tcp_websocket_find_virtual_server(ngx_tcp_session_t *s,
ngx_tcp_websocket_ctx_t *ctx)
{
ngx_uint_t hash, i;
ngx_tcp_core_main_conf_t *cmcf;
ngx_tcp_virtual_server_t *vs;
cmcf = ngx_tcp_get_module_main_conf(s, ngx_tcp_core_module);
if (ctx->host.len == 0) {
return NULL;
}
hash = ngx_hash_key(ctx->host.data, ctx->host.len);
vs = cmcf->virtual_servers.elts;
for (i = 0; i < cmcf->virtual_servers.nelts; i++) {
if (vs[i].hash != hash) {
continue;
}
if ((vs[i].name.len != ctx->host.len)
|| ngx_memcmp(vs[i].name.data, ctx->host.data,
ctx->host.len) != 0){
continue;
}
return &vs[i];
}
return NULL;
}
/* Utility function to check if a (login) name has the zimbra
supported `special' extensions
The test is to see if the name ends with /tb, /wm, or /ni
tb = thunderbird
wm = windows mobile
ni = no idle
*/
ngx_flag_t
has_zimbra_extensions (ngx_str_t login)
{
ngx_flag_t f = 0;
if ((login.len > 3) &&
(!ngx_memcmp (login.data + (login.len - 3), "/tb", 3) ||
!ngx_memcmp (login.data + (login.len - 3), "/wm", 3) ||
!ngx_memcmp (login.data + (login.len - 3), "/ni", 3)
)
) {
f = 1;
}
return f;
}
/* 查找密文 */
static ngx_int_t
ngx_rtmp_find_digest(ngx_buf_t *b, ngx_str_t *key, size_t base, ngx_log_t *log)
{
size_t n, offs;
u_char digest[NGX_RTMP_HANDSHAKE_KEYLEN];
u_char *p;
/* 获得密文偏移 */
offs = 0;
for (n = 0; n < 4; ++n) {
offs += b->pos[base + n];
}
offs = (offs % 728) + base + 4;
p = b->pos + offs;
if (ngx_rtmp_make_digest(key, b, p, digest, log) != NGX_OK) {
return NGX_ERROR;
}
/* 比较是否一致 */
if (ngx_memcmp(digest, p, NGX_RTMP_HANDSHAKE_KEYLEN) == 0) {
return offs;
}
return NGX_ERROR;
}
void
ngx_http_tfs_rcs_set_group_info_by_addr(ngx_http_tfs_rcs_info_t *rc_info,
ngx_int_t group_count, ngx_int_t group_seq, ngx_http_tfs_inet_t addr)
{
ngx_uint_t i, j;
ngx_http_tfs_group_info_t *group_info;
ngx_http_tfs_cluster_group_info_t *cluster_group_info;
cluster_group_info = rc_info->unlink_cluster_groups;
for (i = 0; i < rc_info->unlink_cluster_group_count; i++) {
group_info = cluster_group_info[i].group_info;
for (j = 0; j < cluster_group_info[i].info_count; j++) {
if (ngx_memcmp(&group_info[j].ns_vip, &addr,
sizeof(ngx_http_tfs_inet_t)) == 0)
{
group_info[j].group_seq = group_seq;
cluster_group_info[i].group_count = group_count;
return;
}
}
}
}
static int
ngx_selective_cache_purge_compare_rbtree_file_cache_key(const ngx_rbtree_node_t *v_node, const void *v_key)
{
ngx_http_file_cache_node_t *node = (ngx_http_file_cache_node_t *) v_node;
u_char *key = (u_char *) v_key;
return ngx_memcmp(&key[sizeof(ngx_rbtree_key_t)], node->key, NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));
}
static ngx_int_t
ngx_http_brotli_ok(ngx_http_request_t *r)
{
ngx_table_elt_t *ae;
if (r != r->main) {
return NGX_DECLINED;
}
ae = r->headers_in.accept_encoding;
if (ae == NULL) {
return NGX_DECLINED;
}
if (ae->value.len < sizeof("br") - 1) {
return NGX_DECLINED;
}
if (ngx_memcmp(ae->value.data, "br,", sizeof("br,") - 1) != 0
&& ngx_http_brotli_accept_encoding(&ae->value) != NGX_OK)
{
return NGX_DECLINED;
}
r->gzip_tested = 1;
r->gzip_ok = 0;
return NGX_OK;
}
static ngx_int_t
ngx_http_check_ajp_parse(ngx_http_check_peer_t *peer)
{
u_char *p;
ngx_http_check_ctx *ctx;
ctx = peer->check_data;
if ((size_t)(ctx->recv.last - ctx->recv.pos) < sizeof(ajp_cpong_packet)) {
return NGX_AGAIN;
}
p = ctx->recv.pos;
#if (NGX_DEBUG)
ajp_raw_packet_t *ajp;
ajp = (ajp_raw_packet_t *)p;
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
"ajp_parse: preamble=0x%xd, length=0x%xd, type=0x%xd",
ntohs(ajp->preamble), ntohs(ajp->length), ajp->type);
#endif
if (ngx_memcmp(ajp_cpong_packet, p, sizeof(ajp_cpong_packet)) == 0) {
return NGX_OK;
} else {
return NGX_ERROR;
}
}
static ngx_int_t
ngx_handoff_add_addrs6(ngx_conf_t *cf, ngx_handoff_port_t *mport,
ngx_handoff_conf_addr_t *addr)
{
u_char *p;
size_t len;
ngx_uint_t i, j;
ngx_handoff_in6_addr_t *addrs6;
struct sockaddr_in6 *sin6, *sin6_b;
u_char buf[NGX_SOCKADDR_STRLEN];
mport->addrs = ngx_pcalloc(cf->pool,
mport->naddrs * sizeof(ngx_handoff_in6_addr_t));
if (mport->addrs == NULL) {
return NGX_ERROR;
}
addrs6 = mport->addrs;
for (i = 0; i < mport->naddrs; i++) {
sin6 = (struct sockaddr_in6 *) addr[i].sockaddr;
addrs6[i].addr6 = sin6->sin6_addr;
addrs6[i].conf.ctx = addr[i].ctx;
for (j = 0; j < mport->naddrs; j++) {
sin6_b = (struct sockaddr_in6 *) addr[j].sockaddr;
if ((ngx_memcmp(&sin6->sin6_addr, &sin6_b->sin6_addr, 16) == 0) &&
addr[j].default_ctx) {
addrs6[i].conf.default_ctx = addr[j].default_ctx;
}
}
#if (NGX_HANDOFF_SSL)
addrs6[i].conf.ssl = addr[i].ssl;
#endif
#if defined(nginx_version) && nginx_version >= 1005003
len = ngx_sock_ntop(addr[i].sockaddr, addr[i].socklen, buf, NGX_SOCKADDR_STRLEN, 1);
#else
len = ngx_sock_ntop(addr[i].sockaddr, buf, NGX_SOCKADDR_STRLEN, 1);
#endif
p = ngx_pnalloc(cf->pool, len);
if (p == NULL) {
return NGX_ERROR;
}
ngx_memcpy(p, buf, len);
addrs6[i].conf.addr_text.len = len;
addrs6[i].conf.addr_text.data = p;
}
return NGX_OK;
}
static void
ngx_rtmp_relay_reconnect(ngx_event_t *ev)
{
ngx_rtmp_session_t *s = ev->data;
ngx_rtmp_relay_app_conf_t *racf;
ngx_rtmp_relay_ctx_t *ctx, *pctx;
ngx_uint_t n;
ngx_rtmp_relay_target_t *target, **t;
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"relay: push reconnect");
racf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_relay_module);
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_relay_module);
if (ctx == NULL) {
return;
}
t = racf->pushes.elts;
for (n = 0; n < racf->pushes.nelts; ++n, ++t) {
target = *t;
if (target->name.len && (ctx->name.len != target->name.len ||
ngx_memcmp(ctx->name.data, target->name.data, ctx->name.len)))
{
continue;
}
for (pctx = ctx->play; pctx; pctx = pctx->next) {
if (pctx->tag == &ngx_rtmp_relay_module &&
pctx->data == target)
{
break;
}
}
if (pctx) {
continue;
}
if (ngx_rtmp_relay_push(s, &ctx->name, target) == NGX_OK) {
continue;
}
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"relay: push reconnect failed name='%V' app='%V' "
"playpath='%V' url='%V'",
&ctx->name, &target->app, &target->play_path,
&target->url.url);
if (!ctx->push_evt.timer_set) {
ngx_add_timer(&ctx->push_evt, racf->push_reconnect);
}
}
}
ngx_int_t ngx_str_equal(ngx_str_t *s1, ngx_str_t *s2)
{
if (s1->len != s2->len) {
return 0;
}
if (ngx_memcmp(s1->data, s2->data, s1->len) != 0) {
return 0;
}
return 1;
}
static ngx_int_t
ngx_rtmp_relay_publish(ngx_rtmp_session_t *s, ngx_rtmp_publish_t *v)
{
ngx_rtmp_relay_app_conf_t *racf;
ngx_rtmp_relay_target_t *target, **t;
ngx_str_t name;
size_t n;
ngx_rtmp_relay_ctx_t *ctx;
if (s->auto_pushed) {
goto next;
}
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_relay_module);
if (ctx && s->relay) {
goto next;
}
racf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_relay_module);
if (racf == NULL || racf->pushes.nelts == 0) {
goto next;
}
name.len = ngx_strlen(v->name);
name.data = v->name;
t = racf->pushes.elts;
for (n = 0; n < racf->pushes.nelts; ++n, ++t) {
target = *t;
if (target->name.len && (name.len != target->name.len ||
ngx_memcmp(name.data, target->name.data, name.len)))
{
continue;
}
if (ngx_rtmp_relay_push(s, &name, target) == NGX_OK) {
continue;
}
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"relay: push failed name='%V' app='%V' "
"playpath='%V' url='%V'",
&name, &target->app, &target->play_path,
&target->url.url);
if (!ctx->push_evt.timer_set) {
ngx_add_timer(&ctx->push_evt, racf->push_reconnect);
}
}
next:
return next_publish(s, v);
}
static ngx_int_t
ngx_rtmp_relay_create(ngx_rtmp_session_t *s, ngx_str_t *name,
ngx_rtmp_relay_target_t *target,
ngx_rtmp_relay_create_ctx_pt create_publish_ctx,
ngx_rtmp_relay_create_ctx_pt create_play_ctx)
{
ngx_rtmp_relay_app_conf_t *racf;
ngx_rtmp_relay_ctx_t *publish_ctx, *play_ctx, **cctx;
ngx_uint_t hash;
racf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_relay_module);
if (racf == NULL) {
return NGX_ERROR;
}
play_ctx = create_play_ctx(s, name, target);
if (play_ctx == NULL) {
return NGX_ERROR;
}
hash = ngx_hash_key(name->data, name->len);
cctx = &racf->ctx[hash % racf->nbuckets];
for (; *cctx; cctx = &(*cctx)->next) {
if ((*cctx)->name.len == name->len
&& !ngx_memcmp(name->data, (*cctx)->name.data,
name->len))
{
break;
}
}
if (*cctx) {
play_ctx->publish = (*cctx)->publish;
play_ctx->next = (*cctx)->play;
(*cctx)->play = play_ctx;
return NGX_OK;
}
publish_ctx = create_publish_ctx(s, name, target);
if (publish_ctx == NULL) {
ngx_rtmp_finalize_session(play_ctx->session);
return NGX_ERROR;
}
publish_ctx->publish = publish_ctx;
publish_ctx->play = play_ctx;
play_ctx->publish = publish_ctx;
*cctx = publish_ctx;
return NGX_OK;
}
bool_t
ngx_http_vod_parse_string(
const ngx_http_vod_match_definition_t* match_def,
u_char* start_pos,
u_char* end_pos,
void* output)
{
uint64_t value;
u_char* delim_pos;
for (;;)
{
switch (match_def->match_type)
{
case MATCH_END:
return start_pos == end_pos;
case MATCH_FIXED_STRING:
if (end_pos - start_pos < (ssize_t)match_def->string.len ||
ngx_memcmp(start_pos, match_def->string.data, match_def->string.len) != 0)
{
return FALSE;
}
start_pos += match_def->string.len;
break;
case MATCH_NUMBER:
value = 0;
for (; start_pos < end_pos && *start_pos >= '0' && *start_pos <= '9'; start_pos++)
{
value = value * 10 + *start_pos - '0';
}
*(uint64_t*)((u_char*)output + match_def->target_offset) = value;
break;
case MATCH_DELIM_STRING:
delim_pos = memchr(start_pos, match_def->delim, end_pos - start_pos);
if (delim_pos == NULL)
{
return FALSE;
}
((ngx_str_t*)((u_char*)output + match_def->target_offset))->data = start_pos;
((ngx_str_t*)((u_char*)output + match_def->target_offset))->len = delim_pos - start_pos;
start_pos = delim_pos + 1;
break;
}
match_def++;
}
}
static ngx_lua_session_node_t *
ngx_lua_session_lookup(ngx_lua_thread_t *thr, ngx_lua_session_t *s)
{
ngx_int_t rc;
ngx_rbtree_key_t key;
ngx_rbtree_node_t *node, *sentinel;
ngx_lua_session_node_t *sn;
ngx_lua_session_conf_t *lscf;
lscf = ngx_lua_thread_get_conf(thr, ngx_lua_session_module);
key = ngx_crc32_short(s->id, sizeof(s->id));
node = lscf->shm->rbtree.root;
sentinel = lscf->shm->rbtree.sentinel;
while (node != sentinel) {
if (key < node->key) {
node = node->left;
continue;
}
if (key > node->key) {
node = node->right;
continue;
}
/* key == node->key */
do {
sn = (ngx_lua_session_node_t *) node;
rc = ngx_memcmp(s->id, sn->id, sizeof(s->id));
if (rc == 0) {
return sn;
}
node = (rc < 0) ? node->left : node->right;
} while (node != sentinel && key == node->key);
break;
}
/* not found */
return NULL;
}
static ngx_int_t
ngx_cmp_sockaddr(struct sockaddr *sa1, struct sockaddr *sa2)
{
struct sockaddr_in *sin1, *sin2;
#if (NGX_HAVE_INET6)
struct sockaddr_in6 *sin61, *sin62;
#endif
if (sa1->sa_family != sa2->sa_family) {
return NGX_DECLINED;
}
switch (sa1->sa_family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin61 = (struct sockaddr_in6 *) sa1;
sin62 = (struct sockaddr_in6 *) sa2;
if (sin61->sin6_port != sin61->sin6_port) {
return NGX_DECLINED;
}
if (ngx_memcmp(&sin61->sin6_addr, &sin62->sin6_addr, 16) != 0) {
return NGX_DECLINED;
}
break;
#endif
default: /* AF_INET */
sin1 = (struct sockaddr_in *) sa1;
sin2 = (struct sockaddr_in *) sa2;
if (sin1->sin_port != sin2->sin_port) {
return NGX_DECLINED;
}
if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) {
return NGX_DECLINED;
}
break;
}
return NGX_OK;
}
static ngx_http_file_cache_node_t *
ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key)
{
ngx_int_t rc;
ngx_rbtree_key_t node_key;
ngx_rbtree_node_t *node, *sentinel;
ngx_http_file_cache_node_t *fcn;
ngx_memcpy((u_char *) &node_key, key, sizeof(ngx_rbtree_key_t));
node = cache->sh->rbtree.root;
sentinel = cache->sh->rbtree.sentinel;
while (node != sentinel) {
if (node_key < node->key) {
node = node->left;
continue;
}
if (node_key > node->key) {
node = node->right;
continue;
}
/* node_key == node->key */
do {
fcn = (ngx_http_file_cache_node_t *) node;
rc = ngx_memcmp(&key[sizeof(ngx_rbtree_key_t)], fcn->key,
NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));
if (rc == 0) {
return fcn;
}
node = (rc < 0) ? node->left : node->right;
} while (node != sentinel && node_key == node->key);
break;
}
/* not found */
return NULL;
}
static ngx_int_t
yy_sec_waf_execute_eq(ngx_http_request_t *r,
ngx_str_t *str, ngx_http_yy_sec_waf_rule_t *rule)
{
if (str == NULL || str->data == NULL) {
return NGX_ERROR;
}
if ((str->len == rule->eq->len)
&& (ngx_memcmp(str->data, rule->eq->data, str->len) == 0))
{
return RULE_MATCH;
}
return RULE_NO_MATCH;
}
ngx_int_t
ngx_http_tfs_raw_fsname_parse(ngx_str_t *tfs_name, ngx_str_t *suffix,
ngx_http_tfs_raw_fsname_t* fsname)
{
ngx_uint_t suffix_len;
if (fsname != NULL && tfs_name->data != NULL && tfs_name->data[0] != '\0') {
ngx_memzero(fsname, sizeof(ngx_http_tfs_raw_fsname_t));
fsname->file_type = ngx_http_tfs_raw_fsname_check_file_type(tfs_name);
if (fsname->file_type == NGX_HTTP_TFS_INVALID_FILE_TYPE) {
return NGX_ERROR;
} else {
/* if two suffix exist, check consistency */
if (suffix != NULL
&& suffix->data != NULL
&& tfs_name->len > NGX_HTTP_TFS_FILE_NAME_LEN)
{
suffix_len = tfs_name->len - NGX_HTTP_TFS_FILE_NAME_LEN;
if (suffix->len != suffix_len) {
return NGX_ERROR;
}
suffix_len = suffix->len > suffix_len ? suffix_len :suffix->len;
if (ngx_memcmp(suffix->data,
tfs_name->data + NGX_HTTP_TFS_FILE_NAME_LEN,
suffix_len))
{
return NGX_ERROR;
}
}
ngx_http_tfs_raw_fsname_decode(tfs_name->data + 2,
(u_char*) &(fsname->file));
if (suffix != NULL && suffix->data == NULL) {
suffix->data = tfs_name->data + NGX_HTTP_TFS_FILE_NAME_LEN;
suffix->len = tfs_name->len - NGX_HTTP_TFS_FILE_NAME_LEN;
}
ngx_http_tfs_raw_fsname_set_suffix(fsname, suffix);
if (fsname->cluster_id == 0) {
fsname->cluster_id = tfs_name->data[1] - '0';
}
}
}
return NGX_OK;
}
static void
ngx_rtmp_eval_append_var(void *ctx, ngx_buf_t *b, ngx_rtmp_eval_t **e,
ngx_str_t *name, ngx_log_t *log)
{
ngx_uint_t k;
ngx_str_t v;
ngx_rtmp_eval_t *ee;
for (; *e; ++e) {
for (k = 0, ee = *e; ee->handler; ++k, ++ee) {
if (ee->name.len == name->len &&
ngx_memcmp(ee->name.data, name->data, name->len) == 0)
{
ee->handler(ctx, ee, &v);
ngx_rtmp_eval_append(b, v.data, v.len, log);
}
}
}
}
static void
ngx_rtmp_eval_append_var(ngx_rtmp_session_t *s, ngx_buf_t *b,
ngx_rtmp_eval_t **e, ngx_str_t *name)
{
ngx_uint_t k;
ngx_str_t v;
ngx_rtmp_eval_t *ee;
for (; *e; ++e) {
for (k = 0, ee = *e; ee->handler; ++k, ++ee) {
if (ee->name.len == name->len &&
ngx_memcmp(ee->name.data, name->data, name->len) == 0)
{
ee->handler(s, ee, &v);
ngx_rtmp_eval_append(s, b, v.data, v.len);
}
}
}
}
static ngx_int_t
ngx_rtmp_relay_play(ngx_rtmp_session_t *s, ngx_rtmp_play_t *v)
{
ngx_rtmp_relay_app_conf_t *racf;
ngx_rtmp_relay_target_t *target;
ngx_str_t name;
size_t n;
ngx_rtmp_relay_ctx_t *ctx;
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_relay_module);
if (ctx && ctx->relay) {
goto next;
}
racf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_relay_module);
if (racf == NULL || racf->pulls.nelts == 0) {
goto next;
}
name.len = ngx_strlen(v->name);
name.data = v->name;
target = racf->pulls.elts;
for (n = 0; n < racf->pulls.nelts; ++n, ++target) {
if (target->name.len == 0
|| (name.len == target->name.len
&& !ngx_memcmp(name.data, target->name.data, name.len)))
{
if (ngx_rtmp_relay_pull(s, &name, target) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
"relay: pull failed name='%V' app='%V' "
"playpath='%V' url='%V'",
&name, &target->app, &target->play_path,
&target->url.url);
}
break;
}
}
next:
return next_play(s, v);
}
ngx_http_variable_value_t *
ngx_http_variable_value_lookup(ngx_rbtree_t *rbtree, ngx_str_t *val,
uint32_t hash)
{
ngx_int_t rc;
ngx_rbtree_node_t *node, *sentinel;
ngx_http_variable_value_node_t *vvn;
node = rbtree->root;
sentinel = rbtree->sentinel;
while (node != sentinel) {
vvn = (ngx_http_variable_value_node_t *) node;
if (hash != node->key) {
node = (hash < node->key) ? node->left : node->right;
continue;
}
if (val->len != vvn->len) {
node = (val->len < vvn->len) ? node->left : node->right;
continue;
}
rc = ngx_memcmp(val->data, vvn->value->data, val->len);
if (rc < 0) {
node = node->left;
continue;
}
if (rc > 0) {
node = node->right;
continue;
}
return vvn->value;
}
return NULL;
}
static void
ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
{
ngx_rbtree_node_t **p;
ngx_http_file_cache_node_t *cn, *cnt;
for ( ;; ) {
if (node->key < temp->key) {
p = &temp->left;
} else if (node->key > temp->key) {
p = &temp->right;
} else { /* node->key == temp->key */
cn = (ngx_http_file_cache_node_t *) node;
cnt = (ngx_http_file_cache_node_t *) temp;
p = (ngx_memcmp(cn->key, cnt->key,
NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t))
< 0)
? &temp->left : &temp->right;
}
if (*p == sentinel) {
break;
}
temp = *p;
}
*p = node;
node->parent = temp;
node->left = sentinel;
node->right = sentinel;
ngx_rbt_red(node);
}
static void
ngx_http_parallel_header_clear_value(
ngx_list_t* headers,
ngx_str_t* name,
ngx_uint_t hash)
{
ngx_list_part_t *part;
ngx_table_elt_t *h;
ngx_uint_t i = 0;
part = &headers->part;
h = part->elts;
for (;;)
{
if (i >= part->nelts)
{
if (part->next == NULL)
{
break;
}
part = part->next;
h = part->elts;
i = 0;
}
if (h[i].hash != hash ||
h[i].key.len != name->len ||
ngx_memcmp(h[i].lowcase_key, name->data, name->len) != 0)
{
i++;
continue;
}
ngx_memmove(h + i, h + i + 1, (part->nelts - i - 1) * sizeof(*h));
part->nelts--;
}
}
static inline ngx_int_t
ngx_http_limit_req2_ip_filter(ngx_http_request_t *r,
ngx_http_limit_req2_conf_t *lrcf)
{
ngx_http_variable_value_t *vv;
if (lrcf->geo_var_index != NGX_CONF_UNSET) {
vv = ngx_http_get_indexed_variable(r, lrcf->geo_var_index);
if (vv == NULL || vv->not_found) {
return NGX_DECLINED;
}
if ((vv->len == lrcf->geo_var_value.len)
&& (ngx_memcmp(vv->data, lrcf->geo_var_value.data, vv->len) == 0))
{
return NGX_OK;
}
}
return NGX_DECLINED;
}
static void
ngx_lua_session_insert_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
ngx_rbtree_node_t *sentinel)
{
ngx_rbtree_node_t **p;
ngx_lua_session_node_t *sn, *snt;
for ( ;; ) {
if (node->key < temp->key) {
p = &temp->left;
} else if (node->key > temp->key) {
p = &temp->right;
} else { /* node->key == temp->key */
sn = (ngx_lua_session_node_t *) node;
snt = (ngx_lua_session_node_t *) temp;
p = ngx_memcmp(sn->id, snt->id, sizeof(sn->id))
< 0 ? &temp->left : &temp->right;
}
if (*p == sentinel) {
break;
}
temp = *p;
}
*p = node;
node->parent = temp;
node->left = sentinel;
node->right = sentinel;
ngx_rbt_red(node);
}
static ngx_http_check_peer_shm_t *
ngx_http_check_find_shm_peer(ngx_http_check_peers_shm_t *peers_shm,
ngx_addr_t *addr)
{
ngx_uint_t i;
ngx_http_check_peer_shm_t *peer_shm;
for (i = 0; i < peers_shm->number; i++) {
peer_shm = &peers_shm->peers[i];
if (addr->socklen != peer_shm->socklen) {
continue;
}
if (ngx_memcmp(addr->sockaddr, peer_shm->sockaddr, addr->socklen) == 0) {
return peer_shm;
}
}
return NULL;
}
// Note: code taken from ngx_str_rbtree_lookup, updated the node comparison
static ngx_buffer_cache_entry_t *
ngx_buffer_cache_rbtree_lookup(ngx_rbtree_t *rbtree, const u_char* key, uint32_t hash)
{
ngx_buffer_cache_entry_t *n;
ngx_rbtree_node_t *node, *sentinel;
ngx_int_t rc;
node = rbtree->root;
sentinel = rbtree->sentinel;
while (node != sentinel)
{
n = (ngx_buffer_cache_entry_t *)node;
if (hash != node->key)
{
node = (hash < node->key) ? node->left : node->right;
continue;
}
rc = ngx_memcmp(key, n->key, BUFFER_CACHE_KEY_SIZE);
if (rc < 0)
{
node = node->left;
continue;
}
if (rc > 0)
{
node = node->right;
continue;
}
return n;
}
return NULL;
}
void
ngx_http_variable_value_rbtree_insert(ngx_rbtree_node_t *temp,
ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
{
ngx_rbtree_node_t **p;
ngx_http_variable_value_node_t *vvn, *vvt;
for ( ;; ) {
vvn = (ngx_http_variable_value_node_t *) node;
vvt = (ngx_http_variable_value_node_t *) temp;
if (node->key != temp->key) {
p = (node->key < temp->key) ? &temp->left : &temp->right;
} else if (vvn->len != vvt->len) {
p = (vvn->len < vvt->len) ? &temp->left : &temp->right;
} else {
p = (ngx_memcmp(vvn->value->data, vvt->value->data, vvn->len) < 0)
? &temp->left : &temp->right;
}
if (*p == sentinel) {
break;
}
temp = *p;
}
*p = node;
node->parent = temp;
node->left = sentinel;
node->right = sentinel;
ngx_rbt_red(node);
}
