void
ngx_queue_sort(ngx_queue_t *queue,
intptr_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
if (q == ngx_queue_last(queue)) {
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q);
next = ngx_queue_next(q);
ngx_queue_remove(q);
do {
if (cmp(prev, q) <= 0) {
break;
}
prev = ngx_queue_prev(prev);
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);
}
}
// cmp 指向函数的指针
// 队列排序采用的是稳定的简单插入排序方法，即从第一个节点开始遍历，依次将节点(q)插入前面已经排序好的队列(链表)中
// prev 为已经排序好的queue
void
ngx_queue_sort(ngx_queue_t *queue,
ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
// 若只有一个元素，则无须排序
if (q == ngx_queue_last(queue)) {
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q);
// 也充当了循环条件
next = ngx_queue_next(q);
ngx_queue_remove(q);
do {
// 指针函数调用
if (cmp(prev, q) <= 0) {
break;
}
prev = ngx_queue_prev(prev);
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);
}
}
void
ngx_queue_sort(ngx_queue_t *queue,
ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
if (q == ngx_queue_last(queue)) {
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q);
next = ngx_queue_next(q);
ngx_queue_remove(q);
do {
if (cmp(prev, q) <= 0) {/* 比较 */
break;
}
prev = ngx_queue_prev(prev); /* prev指针前移 */
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);/* 将q插入prev节点之后(此处即为简单插入) */
}
}
/*
* [analy] 队列排序采用的是稳定的简单插入排序方法，即从第一个节点开始遍历，依次将当前节点(q)插入前面已经排好序的队列(链表)中
* 由于排序仅简单的修改了指针指向的操作，所以效率较高的。
*/
void
ngx_queue_sort(ngx_queue_t *queue,
ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
if (q == ngx_queue_last(queue)) { // 第一个节点和最后一个节点相等，不需要排序（有0或1个节点）
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q); // 取当前节点的前一个节点
next = ngx_queue_next(q); // 取当前节点的后一个节点
ngx_queue_remove(q); // 删除当前节点
do {
if (cmp(prev, q) <= 0) {
break;
}
prev = ngx_queue_prev(prev); // 这里取前一个节点的目的是为了检查循环条件是否成立，如果成立说明头节点之后还有节点，需要继续比较
// 不成立，说明头结点之后已经无接点，直接插入到头结点后
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);
}
}
static void
ngx_http_create_locations_list(ngx_queue_t *locations, ngx_queue_t *q)
{
u_char *name;
size_t len;
ngx_queue_t *x, tail;
ngx_http_location_queue_t *lq, *lx;
if (q == ngx_queue_last(locations)) {
return;
}
lq = (ngx_http_location_queue_t *) q;
if (lq->inclusive == NULL) {
ngx_http_create_locations_list(locations, ngx_queue_next(q));
return;
}
len = lq->name->len;
name = lq->name->data;
for (x = ngx_queue_next(q);
x != ngx_queue_sentinel(locations);
x = ngx_queue_next(x))
{
lx = (ngx_http_location_queue_t *) x;
if (len > lx->name->len
|| (ngx_strncmp(name, lx->name->data, len) != 0))
{
break;
}
}
q = ngx_queue_next(q);
if (q == x) {
ngx_http_create_locations_list(locations, x);
return;
}
ngx_queue_split(locations, q, &tail);
ngx_queue_add(&lq->list, &tail);
if (x == ngx_queue_sentinel(locations)) {
ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));
return;
}
ngx_queue_split(&lq->list, x, &tail);
ngx_queue_add(locations, &tail);
ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));
ngx_http_create_locations_list(locations, x);
}
static void
ngx_http_push_stream_send_old_messages(ngx_http_request_t *r, ngx_http_push_stream_channel_t *channel, ngx_uint_t backtrack, time_t if_modified_since, ngx_int_t tag, time_t greater_message_time, ngx_int_t greater_message_tag, ngx_str_t *last_event_id)
{
ngx_http_push_stream_module_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_http_push_stream_module);
ngx_http_push_stream_msg_t *message;
ngx_queue_t *q;
if (ngx_http_push_stream_has_old_messages_to_send(channel, backtrack, if_modified_since, tag, greater_message_time, greater_message_tag, last_event_id)) {
if (backtrack > 0) {
ngx_uint_t qtd = (backtrack > channel->stored_messages) ? channel->stored_messages : backtrack;
ngx_uint_t start = channel->stored_messages - qtd;
ngx_shmtx_lock(channel->mutex);
// positioning at first message, and send the others
for (q = ngx_queue_head(&channel->message_queue); (qtd > 0) && q != ngx_queue_sentinel(&channel->message_queue); q = ngx_queue_next(q)) {
message = ngx_queue_data(q, ngx_http_push_stream_msg_t, queue);
if (message->deleted) {
break;
}
if (start == 0) {
qtd--;
ngx_http_push_stream_send_response_message(r, channel, message, 0, ctx->message_sent);
} else {
start--;
}
}
ngx_shmtx_unlock(channel->mutex);
} else if ((last_event_id != NULL) || (if_modified_since >= 0)) {
ngx_flag_t found = 0;
ngx_shmtx_lock(channel->mutex);
for (q = ngx_queue_head(&channel->message_queue); q != ngx_queue_sentinel(&channel->message_queue); q = ngx_queue_next(q)) {
message = ngx_queue_data(q, ngx_http_push_stream_msg_t, queue);
if (message->deleted) {
break;
}
if ((!found) && (last_event_id != NULL) && (message->event_id != NULL) && (ngx_memn2cmp(message->event_id->data, last_event_id->data, message->event_id->len, last_event_id->len) == 0)) {
found = 1;
continue;
}
if ((!found) && (if_modified_since >= 0) && ((message->time > if_modified_since) || ((message->time == if_modified_since) && (tag >= 0) && (message->tag >= tag)))) {
found = 1;
if ((message->time == if_modified_since) && (message->tag == tag)) {
continue;
}
}
if (found && (((greater_message_time == 0) && (greater_message_tag == -1)) || (greater_message_time > message->time) || ((greater_message_time == message->time) && (greater_message_tag >= message->tag)))) {
ngx_http_push_stream_send_response_message(r, channel, message, 0, ctx->message_sent);
}
}
ngx_shmtx_unlock(channel->mutex);
}
}
}
int main(int argc, char *argv[])
{
ngx_int_t n;
ngx_log_t * log;
ngx_queue_t queue_container;
ngx_queue_t *q;
test_node node[5];
test_node *ele_node;
ngx_pagesize = getpagesize();
n = ngx_strerror_init();
if (n == NGX_ERROR){
return NGX_ERROR;
}
ngx_time_init();
log = ngx_log_init((u_char *)"./");
ngx_use_stderr = 0;
if (log == NULL){
ngx_log_stderr(NGX_ERROR,(const char*)"can not init log ");
return NGX_ERROR;
}
ngx_queue_init(&queue_container);
for (n = 0;n < 5;n++){
node[n].num = n;
}
ngx_queue_insert_tail(&queue_container,&node[0].queue);
ngx_queue_insert_head(&queue_container,&node[1].queue);
ngx_queue_insert_after(&queue_container,&node[2].queue);
ngx_queue_insert_head(&queue_container,&node[3].queue);
ngx_queue_insert_tail(&queue_container,&node[4].queue);
for (q = ngx_queue_head(&queue_container);
q != ngx_queue_sentinel(&queue_container);
q = ngx_queue_next(q)){
ele_node = ngx_queue_data(q,test_node,queue);
printf("%d\n",ele_node->num);
}
ngx_queue_sort(&queue_container,cmp_test_node);
for (q = ngx_queue_head(&queue_container);
q != ngx_queue_sentinel(&queue_container);
q = ngx_queue_next(q)){
ele_node = ngx_queue_data(q,test_node,queue);
printf("%d\n",ele_node->num);
}
return NGX_OK;
}
int main()
{
ngx_pool_t* pool;
yahoo_guy_t* guy;
ngx_queue_t* q;
yahoo_t* yahoo;
pool = ngx_create_pool(1024*10, NULL); //初始化内存池
int i;
// 构建队列
const ngx_str_t names[] = {
ngx_string("rainx"), ngx_string("xiaozhe"), ngx_string("zhoujian")
} ;
const int ids[] = {4611, 8322, 6111};
yahoo = ngx_palloc(pool, sizeof(yahoo_t));
ngx_queue_init(&yahoo->queue); //初始化queue
for(i = 0; i < 3; i++)
{
guy = (yahoo_guy_t*) ngx_palloc(pool, sizeof(yahoo_guy_t));
guy->id = ids[i];
//guy->name = (char*) ngx_palloc(pool, (size_t) (strlen(names[i]) + 1) );
guy->name = (u_char*) ngx_pstrdup(pool, (ngx_str_t*) &(names[i]) );
ngx_queue_init(&guy->queue);
// 从头部进入队列
ngx_queue_insert_head(&yahoo->queue, &guy->queue);
}
// 从尾部遍历输出
for(q = ngx_queue_last(&yahoo->queue);
q != ngx_queue_sentinel(&yahoo->queue);
q = ngx_queue_prev(q) ) {
guy = ngx_queue_data(q, yahoo_guy_t, queue);
printf("No. %d guy in yahoo is %s \n", guy->id, guy->name);
}
// 排序从头部输出
ngx_queue_sort(&yahoo->queue, yahoo_no_cmp);
printf("sorting....\n");
for(q = ngx_queue_prev(&yahoo->queue);
q != ngx_queue_sentinel(&yahoo->queue);
q = ngx_queue_last(q) ) {
guy = ngx_queue_data(q, yahoo_guy_t, queue);
printf("No. %d guy in yahoo is %s \n", guy->id, guy->name);
}
ngx_destroy_pool(pool);
return 0;
}
static ngx_int_t
ngx_http_push_stream_send_response_all_channels_info_detailed(ngx_http_request_t *r, ngx_str_t *prefix)
{
ngx_http_push_stream_main_conf_t *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
ngx_queue_t queue_channel_info;
ngx_http_push_stream_shm_data_t *data = mcf->shm_data;
ngx_queue_t *q;
ngx_http_push_stream_channel_t *channel;
ngx_queue_init(&queue_channel_info);
ngx_shmtx_lock(&data->channels_queue_mutex);
for (q = ngx_queue_head(&data->channels_queue); q != ngx_queue_sentinel(&data->channels_queue); q = ngx_queue_next(q)) {
channel = ngx_queue_data(q, ngx_http_push_stream_channel_t, queue);
ngx_http_push_stream_channel_info_t *channel_info;
if(!prefix || (ngx_strncmp(channel->id.data, prefix->data, prefix->len) == 0)) {
if ((channel_info = ngx_pcalloc(r->pool, sizeof(ngx_http_push_stream_channel_info_t))) != NULL) {
channel_info->id.data = channel->id.data;
channel_info->id.len = channel->id.len;
channel_info->published_messages = channel->last_message_id;
channel_info->stored_messages = channel->stored_messages;
channel_info->subscribers = channel->subscribers;
ngx_queue_insert_tail(&queue_channel_info, &channel_info->queue);
}
}
}
ngx_shmtx_unlock(&data->channels_queue_mutex);
return ngx_http_push_stream_send_response_channels_info(r, &queue_channel_info);
}
static void
ngx_http_spdy_waiting_queue(ngx_http_spdy_connection_t *sc,
ngx_http_spdy_stream_t *stream)
{
ngx_queue_t *q;
ngx_http_spdy_stream_t *s;
if (stream->handled)
{
return;
}
stream->handled = 1;
for (q = ngx_queue_last(&sc->waiting);
q != ngx_queue_sentinel(&sc->waiting);
q = ngx_queue_prev(q))
{
s = ngx_queue_data(q, ngx_http_spdy_stream_t, queue);
/*
* NB: higher values represent lower priorities.
*/
if (stream->priority >= s->priority)
{
break;
}
}
ngx_queue_insert_after(q, &stream->queue);
}
static ngx_http_push_stream_pid_queue_t *
ngx_http_push_stream_get_worker_subscriber_channel_sentinel_locked(ngx_slab_pool_t *shpool, ngx_http_push_stream_channel_t *channel, ngx_log_t *log)
{
ngx_http_push_stream_pid_queue_t *worker_sentinel;
ngx_queue_t *q;
for (q = ngx_queue_head(&channel->workers_with_subscribers); q != ngx_queue_sentinel(&channel->workers_with_subscribers); q = ngx_queue_next(q)) {
worker_sentinel = ngx_queue_data(q, ngx_http_push_stream_pid_queue_t, queue);
if (worker_sentinel->pid == ngx_pid) {
return worker_sentinel;
}
}
if ((worker_sentinel = ngx_slab_alloc(shpool, sizeof(ngx_http_push_stream_pid_queue_t))) == NULL) {
ngx_log_error(NGX_LOG_ERR, log, 0, "push stream module: unable to allocate worker subscriber queue marker in shared memory");
return NULL;
}
// initialize
ngx_queue_insert_tail(&channel->workers_with_subscribers, &worker_sentinel->queue);
worker_sentinel->subscribers = 0;
worker_sentinel->pid = ngx_pid;
worker_sentinel->slot = ngx_process_slot;
ngx_queue_init(&worker_sentinel->subscriptions);
return worker_sentinel;
}
int ngx_shmap_foreach(ngx_shm_zone_t* zone, foreach_pt func, void* args)
{
ngx_queue_t *q;
ngx_shmap_node_t *sd;
ngx_shmap_ctx_t *ctx;
assert(zone != NULL);
ctx = zone->data;
int locked = ngx_shmtx_trylock(&ctx->shpool->mutex);
if (!locked){
return -1;
}
for (q = ngx_queue_head(&ctx->sh->queue);
q != ngx_queue_sentinel(&ctx->sh->queue);
q = ngx_queue_next(q))
{
sd = ngx_queue_data(q, ngx_shmap_node_t, queue);
func(sd, args);
}
ngx_shmtx_unlock(&ctx->shpool->mutex);
return 0;
}
int ngx_shmap_flush_all(ngx_shm_zone_t* zone)
{
ngx_queue_t *q;
ngx_shmap_node_t *sd;
ngx_shmap_ctx_t *ctx;
assert(zone != NULL);
ctx = zone->data;
ngx_shmtx_lock(&ctx->shpool->mutex);
for (q = ngx_queue_head(&ctx->sh->queue);
q != ngx_queue_sentinel(&ctx->sh->queue);
q = ngx_queue_next(q))
{
sd = ngx_queue_data(q, ngx_shmap_node_t, queue);
sd->expires = 1;
}
ngx_shmap_expire(ctx, 0);
ngx_shmtx_unlock(&ctx->shpool->mutex);
return 0;
}
int main(int argc, char const *argv[])
{
ngx_queue_t queueContainer;
ngx_queue_init(&queueContainer);
int i = 0;
my_queue node[5];
for(;i < 5;++i){
node[i].num = i;
}
ngx_queue_insert_tail(&queueContainer,&node[0].que);
ngx_queue_insert_head(&queueContainer,&node[1].que);
ngx_queue_insert_tail(&queueContainer,&node[2].que);
ngx_queue_insert_after(&queueContainer,&node[3].que);
ngx_queue_insert_tail(&queueContainer,&node[4].que);
ngx_queue_sort(&queueContainer,compTestNode);
ngx_queue_t *q;
for(q = ngx_queue_head(&queueContainer);q != ngx_queue_sentinel(&queueContainer)
;q = ngx_queue_next(q)){
my_queue* eleNode = ngx_queue_data(q,my_queue,que);
printf("%d\n",eleNode -> num );
}
return 0;
}
static void
ngx_http_gettoken_close_connection(ngx_http_gettoken_connection_t *c)
{
ngx_queue_t *q;
if (c->conn.connection) {
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "http_gettoken: Closing connection (fd=%d)",
c->conn.connection->fd);
ngx_close_connection(c->conn.connection);
c->conn.connection = NULL;
}
q = ngx_queue_head(&c->server->free_connections);
while (q != ngx_queue_sentinel(&c->server->free_connections)) {
if (q == &c->queue) {
ngx_queue_remove(q);
break;
}
q = ngx_queue_next(q);
}
c->rctx = NULL;
if (c->state != STATE_DISCONNECTED) {
c->state = STATE_DISCONNECTED;
ngx_add_timer(&c->reconnect_event, c->server->reconnect_timeout);
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "http_gettoken: Connection scheduled for reconnection in %d ms", c->server->reconnect_timeout);
}
}
int
ngx_tcp_lua_ffi_shdict_flush_all(ngx_shm_zone_t *zone)
{
ngx_queue_t *q;
ngx_tcp_lua_shdict_node_t *sd;
ngx_tcp_lua_shdict_ctx_t *ctx;
ctx = zone->data;
ngx_shmtx_lock(&ctx->shpool->mutex);
for (q = ngx_queue_head(&ctx->sh->queue);
q != ngx_queue_sentinel(&ctx->sh->queue);
q = ngx_queue_next(q))
{
sd = ngx_queue_data(q, ngx_tcp_lua_shdict_node_t, queue);
sd->expires = 1;
}
ngx_tcp_lua_shdict_expire(ctx, 0);
ngx_shmtx_unlock(&ctx->shpool->mutex);
return NGX_OK;
}
static ngx_uint_t
ngx_http_viewer_cache_node_count(ngx_http_file_cache_t *cache)
{
ngx_queue_t *q;
ngx_uint_t count;
ngx_http_file_cache_node_t *fcn;
count = 0;
ngx_shmtx_lock(&cache->shpool->mutex);
for (q = ngx_queue_last(&cache->sh->queue);
q != ngx_queue_sentinel(&cache->sh->queue);
q = ngx_queue_prev(q))
{
fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);
ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
"http viewer file cache: #%d %d %02xd%02xd%02xd%02xd",
fcn->count, fcn->exists,
fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);
count++;
}
ngx_shmtx_unlock(&cache->shpool->mutex);
return count;
}
static void
ngx_http_v2_waiting_queue(ngx_http_v2_connection_t *h2c,
ngx_http_v2_stream_t *stream)
{
ngx_queue_t *q;
ngx_http_v2_stream_t *s;
if (stream->handled) {
return;
}
stream->handled = 1;
for (q = ngx_queue_last(&h2c->waiting);
q != ngx_queue_sentinel(&h2c->waiting);
q = ngx_queue_prev(q))
{
s = ngx_queue_data(q, ngx_http_v2_stream_t, queue);
if (s->node->rank < stream->node->rank
|| (s->node->rank == stream->node->rank
&& s->node->rel_weight >= stream->node->rel_weight))
{
break;
}
}
ngx_queue_insert_after(q, &stream->queue);
}
static ngx_int_t
ngx_http_upstream_get_keepalive_peer(ngx_peer_connection_t *pc, void *data)
{
ngx_http_upstream_keepalive_peer_data_t *kp = data;
ngx_http_upstream_keepalive_cache_t *item;
ngx_int_t rc;
ngx_queue_t *q, *cache;
ngx_connection_t *c;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
"get keepalive peer");
kp->failed = 0;
/* ask balancer */
rc = kp->original_get_peer(pc, kp->data);
if (rc != NGX_OK) {
return rc;
}
/* search cache for suitable connection */
cache = &kp->conf->cache;
for (q = ngx_queue_head(cache);
q != ngx_queue_sentinel(cache);
q = ngx_queue_next(q))
{
item = ngx_queue_data(q, ngx_http_upstream_keepalive_cache_t, queue);
c = item->connection;
if (ngx_memn2cmp((u_char *) &item->sockaddr, (u_char *) pc->sockaddr,
item->socklen, pc->socklen)
== 0)
{
ngx_queue_remove(q);
ngx_queue_insert_head(&kp->conf->free, q);
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
"get keepalive peer: using connection %p", c);
c->idle = 0;
c->log = pc->log;
c->read->log = pc->log;
c->write->log = pc->log;
c->pool->log = pc->log;
pc->connection = c;
pc->cached = 1;
return NGX_DONE;
}
}
return NGX_OK;
}
static ngx_int_t
ngx_http_push_stream_channels_statistics_handler(ngx_http_request_t *r)
{
ngx_http_push_stream_main_conf_t *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
char *pos = NULL;
ngx_http_push_stream_requested_channel_t *requested_channels, *requested_channel;
ngx_queue_t *q;
ngx_http_push_stream_set_expires(r, NGX_HTTP_PUSH_STREAM_EXPIRES_EPOCH, 0);
// only accept GET method
if (!(r->method & NGX_HTTP_GET)) {
ngx_http_push_stream_add_response_header(r, &NGX_HTTP_PUSH_STREAM_HEADER_ALLOW, &NGX_HTTP_PUSH_STREAM_ALLOW_GET);
return ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_NOT_ALLOWED, NULL);
}
ngx_http_push_stream_add_response_header(r, &NGX_HTTP_PUSH_STREAM_HEADER_TAG, &NGX_HTTP_PUSH_STREAM_TAG);
ngx_http_push_stream_add_response_header(r, &NGX_HTTP_PUSH_STREAM_HEADER_COMMIT, &NGX_HTTP_PUSH_STREAM_COMMIT);
//get channels ids
requested_channels = ngx_http_push_stream_parse_channels_ids_from_path(r, r->pool);
// if not specify a channel id, get info about all channels in a resumed way
if ((requested_channels == NULL) || ngx_queue_empty(&requested_channels->queue)) {
return ngx_http_push_stream_send_response_all_channels_info_summarized(r);
}
for (q = ngx_queue_head(&requested_channels->queue); q != ngx_queue_sentinel(&requested_channels->queue); q = ngx_queue_next(q)) {
requested_channel = ngx_queue_data(q, ngx_http_push_stream_requested_channel_t, queue);
// could not have a large size
if ((mcf->max_channel_id_length != NGX_CONF_UNSET_UINT) && (requested_channel->id->len > mcf->max_channel_id_length)) {
ngx_log_error(NGX_LOG_WARN, r->connection->log, 0, "push stream module: channel id is larger than allowed %d", requested_channel->id->len);
return ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_BAD_REQUEST, &NGX_HTTP_PUSH_STREAM_TOO_LARGE_CHANNEL_ID_MESSAGE);
}
if ((pos = ngx_strchr(requested_channel->id->data, '*')) != NULL) {
ngx_str_t *aux = NULL;
if (pos != (char *) requested_channel->id->data) {
*pos = '\0';
requested_channel->id->len = ngx_strlen(requested_channel->id->data);
aux = requested_channel->id;
}
return ngx_http_push_stream_send_response_all_channels_info_detailed(r, aux);
}
// if specify a channel id equals to ALL, get info about all channels in a detailed way
if (ngx_memn2cmp(requested_channel->id->data, NGX_HTTP_PUSH_STREAM_ALL_CHANNELS_INFO_ID.data, requested_channel->id->len, NGX_HTTP_PUSH_STREAM_ALL_CHANNELS_INFO_ID.len) == 0) {
return ngx_http_push_stream_send_response_all_channels_info_detailed(r, NULL);
}
requested_channel->channel = ngx_http_push_stream_find_channel(requested_channel->id, r->connection->log, mcf);
}
// if specify a channels ids != ALL, get info about specified channels if they exists
return ngx_http_push_stream_send_response_channels_info_detailed(r, requested_channels);
}
static ngx_int_t
ngx_http_ip_blacklist_manager(void)
{
ngx_queue_t *node;
ngx_queue_t *tmp;
ngx_http_ip_blacklist_tree_t *blacklist;
ngx_http_ip_blacklist_t *bn;
blacklist = ngx_http_ip_blacklist_shm_zone->data;
ngx_shmtx_lock(&blacklist->shpool->mutex);
if (ngx_queue_empty(&blacklist->garbage)) {
goto out;
}
for (node = ngx_queue_head(&blacklist->garbage);
node != ngx_queue_sentinel(&blacklist->garbage);
node = ngx_queue_next(node)) {
bn = ngx_queue_data(node, ngx_http_ip_blacklist_t, queue);
if (bn->blacklist) {
if (bn->timeout <= ngx_time()) {
if (bn->ref != 0) {
/* wait for request cleanup handler to delete this */
bn->timed = 1;
bn->blacklist = 0;
goto out;
}
/* blacklist timed out */
tmp = node;
node = ngx_queue_prev(node);
ngx_rbtree_delete(&blacklist->blacklist, &bn->node);
ngx_queue_remove(tmp);
ngx_slab_free_locked(blacklist->shpool, bn);
}
} else {
if (bn->ref == 0) {
tmp = node;
node = ngx_queue_prev(node);
ngx_rbtree_delete(&blacklist->blacklist, &bn->node);
ngx_queue_remove(tmp);
ngx_slab_free_locked(blacklist->shpool, bn);
} else {
/* wait for request cleanup handler to delete this */
bn->timed = 1;
}
}
}
out:
ngx_shmtx_unlock(&blacklist->shpool->mutex);
return NGX_OK;
}
void print_queue(ngx_queue_t *h)
{
ngx_queue_t *t;
for( t=ngx_queue_head(h); t != ngx_queue_sentinel(h);
t = ngx_queue_next(t))
{
ngx_qTest_t *tmp = ngx_queue_data(t, ngx_qTest_t, link);
printf("Key:%d, name:%s\n", tmp->key, tmp->name);
}
}
int ngx_shmap_flush_expired(ngx_shm_zone_t* zone, int attempts)
{
ngx_queue_t *q, *prev;
ngx_shmap_node_t *sd;
ngx_shmap_ctx_t *ctx;
ngx_time_t *tp;
int freed = 0;
ngx_rbtree_node_t *node;
uint64_t now;
assert(zone != NULL);
ctx = zone->data;
ngx_shmtx_lock(&ctx->shpool->mutex);
if (ngx_queue_empty(&ctx->sh->queue)) {
return 0;
}
tp = ngx_timeofday();
now = (uint64_t) tp->sec * 1000 + tp->msec;
q = ngx_queue_last(&ctx->sh->queue);
while (q != ngx_queue_sentinel(&ctx->sh->queue)) {
prev = ngx_queue_prev(q);
sd = ngx_queue_data(q, ngx_shmap_node_t, queue);
if (sd->expires != 0 && sd->expires <= now) {
ngx_queue_remove(q);
node = (ngx_rbtree_node_t *)
((u_char *) sd - offsetof(ngx_rbtree_node_t, color));
ngx_rbtree_delete(&ctx->sh->rbtree, node);
ngx_slab_free_locked(ctx->shpool, node);
freed++;
if (attempts && freed == attempts) {
break;
}
}
q = prev;
}
ngx_shmtx_unlock(&ctx->shpool->mutex);
return freed;
}
void dump_queue_from_tail(ngx_queue_t *que)
{
ngx_queue_t *q = ngx_queue_last(que);
printf("(0x%x: (0x%x, 0x%x)) <==> \n", que, que->prev, que->next);
for (; q != ngx_queue_sentinel(que); q = ngx_queue_prev(q))
{
my_point_queue_t *point = ngx_queue_data(q, my_point_queue_t, queue);
printf("(0x%x: (%-2d, %-2d), 0x%x: (0x%x, 0x%x)) <==> \n", point, point->point.x,
point->point.y, &point->queue, point->queue.prev, point->queue.next);
}
}
ngx_int_t
ngx_http_drizzle_keepalive_get_peer_multi(ngx_peer_connection_t *pc,
ngx_http_upstream_drizzle_peer_data_t *dp,
ngx_http_upstream_drizzle_srv_conf_t *dscf)
{
ngx_queue_t *q, *cache;
ngx_http_drizzle_keepalive_cache_t *item;
ngx_connection_t *c;
/* search cache for suitable connection */
cache = &dscf->cache;
for (q = ngx_queue_head(cache);
q != ngx_queue_sentinel(cache);
q = ngx_queue_next(q))
{
item = ngx_queue_data(q, ngx_http_drizzle_keepalive_cache_t, queue);
c = item->connection;
/* XXX maybe we should take dbname and user into account
* as well? */
if (ngx_memn2cmp((u_char *) &item->sockaddr, (u_char *) pc->sockaddr,
item->socklen, pc->socklen)
== 0)
{
ngx_queue_remove(q);
ngx_queue_insert_head(&dscf->free, q);
c->idle = 0;
c->log = pc->log;
c->read->log = pc->log;
c->write->log = pc->log;
pc->connection = c;
pc->cached = 1;
/* we do not need to resume dp->name here because
* it already takes the right value in the
* ngx_http_upstream_drizzle_get_peer function */
dp->drizzle_con = item->drizzle_con;
dp->has_set_names = item->has_set_names;
dp->used = item->used;
return NGX_DONE;
}
}
return NGX_DECLINED;
}
ngx_int_t
ngx_postgres_keepalive_get_peer_multi(ngx_peer_connection_t *pc,
ngx_postgres_upstream_peer_data_t *pgp,
ngx_postgres_upstream_srv_conf_t *pgscf)
{
ngx_postgres_keepalive_cache_t *item;
ngx_queue_t *q, *cache;
ngx_connection_t *c;
dd("entering");
cache = &pgscf->cache;
for (q = ngx_queue_head(cache);
q != ngx_queue_sentinel(cache);
q = ngx_queue_next(q))
{
item = ngx_queue_data(q, ngx_postgres_keepalive_cache_t, queue);
c = item->connection;
if (ngx_memn2cmp((u_char *) &item->sockaddr, (u_char *) pc->sockaddr,
item->socklen, pc->socklen) == 0)
{
ngx_queue_remove(q);
ngx_queue_insert_head(&pgscf->free, q);
c->idle = 0;
c->log = pc->log;
#if defined(nginx_version) && (nginx_version >= 1001004)
c->pool->log = pc->log;
#endif
c->read->log = pc->log;
c->write->log = pc->log;
pc->connection = c;
pc->cached = 1;
/* we do not need to resume the peer name
* because we already take the right value outside */
pgp->pgconn = item->pgconn;
dd("returning NGX_DONE");
return NGX_DONE;
}
}
dd("returning NGX_DECLINED");
return NGX_DECLINED;
}
ngx_uint_t
ngx_http_drizzle_queue_size(ngx_queue_t *queue)
{
ngx_queue_t *q;
ngx_uint_t n = 0;
for (q = ngx_queue_head(queue);
q != ngx_queue_sentinel(queue);
q = ngx_queue_next(q))
{
n++;
}
return n;
}
static void
ngx_http_push_stream_publisher_delete_handler(ngx_http_request_t *r)
{
ngx_http_push_stream_main_conf_t *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
ngx_http_push_stream_module_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_http_push_stream_module);
ngx_buf_t *buf = NULL;
u_char *text = mcf->channel_deleted_message_text.data;
size_t len = mcf->channel_deleted_message_text.len;
ngx_uint_t qtd_channels = 0;
ngx_int_t rc;
ngx_http_push_stream_requested_channel_t *requested_channel;
ngx_queue_t *q;
if (r->headers_in.content_length_n > 0) {
// get and check if has access to request body
NGX_HTTP_PUSH_STREAM_CHECK_AND_FINALIZE_REQUEST_ON_ERROR(r->request_body->bufs, NULL, r, "push stream module: unexpected publisher message request body buffer location. please report this to the push stream module developers.");
buf = ngx_http_push_stream_read_request_body_to_buffer(r);
NGX_HTTP_PUSH_STREAM_CHECK_AND_FINALIZE_REQUEST_ON_ERROR(buf, NULL, r, "push stream module: cannot allocate memory for read the message");
text = buf->pos;
len = ngx_buf_size(buf);
}
for (q = ngx_queue_head(&ctx->requested_channels->queue); q != ngx_queue_sentinel(&ctx->requested_channels->queue); q = ngx_queue_next(q)) {
requested_channel = ngx_queue_data(q, ngx_http_push_stream_requested_channel_t, queue);
rc = ngx_http_push_stream_delete_channel(mcf, requested_channel->channel, text, len, r->pool);
if (rc == -1) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: error while deleting channel '%V'", &requested_channel->channel->id);
ngx_http_push_stream_send_only_header_response_and_finalize(r, NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
return;
}
if (rc > 0) {
qtd_channels++;
}
}
if (qtd_channels == 0) {
ngx_http_push_stream_send_only_header_response_and_finalize(r, NGX_HTTP_NOT_FOUND, NULL);
} else {
ngx_http_push_stream_send_only_header_response_and_finalize(r, NGX_HTTP_OK, &NGX_HTTP_PUSH_STREAM_CHANNEL_DELETED);
}
}
static ngx_int_t
ngx_http_ip_blacklist_flush_handler(ngx_http_request_t *r)
{
ngx_http_ip_blacklist_main_conf_t *imcf;
ngx_http_ip_blacklist_tree_t *blacklist;
ngx_http_ip_blacklist_t *bn;
ngx_queue_t *node;
ngx_queue_t *tmp;
imcf = ngx_http_get_module_main_conf(r, ngx_http_ip_blacklist_module);
if (!imcf->enabled) {
return NGX_HTTP_CLOSE;
}
blacklist = ngx_http_ip_blacklist_shm_zone->data;
ngx_shmtx_lock(&blacklist->shpool->mutex);
if (ngx_queue_empty(&blacklist->garbage)) {
ngx_shmtx_unlock(&blacklist->shpool->mutex);
return NGX_HTTP_CLOSE;
}
for (node = ngx_queue_head(&blacklist->garbage);
node != ngx_queue_sentinel(&blacklist->garbage);
node = ngx_queue_next(node)) {
bn = ngx_queue_data(node, ngx_http_ip_blacklist_t, queue);
if (bn->ref != 0) {
/* force node to time out */
bn->timed = 1;
continue;
}
tmp = node;
node = ngx_queue_prev(node);
ngx_rbtree_delete(&blacklist->blacklist, &bn->node);
ngx_queue_remove(tmp);
ngx_slab_free_locked(blacklist->shpool, bn);
}
ngx_shmtx_unlock(&blacklist->shpool->mutex);
return NGX_HTTP_CLOSE;
}
static void
ngx_http_push_stream_publisher_body_handler(ngx_http_request_t *r)
{
ngx_str_t *event_id, *event_type;
ngx_http_push_stream_module_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_http_push_stream_module);
ngx_http_push_stream_main_conf_t *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
ngx_http_push_stream_loc_conf_t *cf = ngx_http_get_module_loc_conf(r, ngx_http_push_stream_module);
ngx_buf_t *buf = NULL;
ngx_http_push_stream_requested_channel_t *requested_channel;
ngx_queue_t *q;
// check if body message wasn't empty
if (r->headers_in.content_length_n <= 0) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: Post request was sent with no message");
ngx_http_push_stream_send_only_header_response_and_finalize(r, NGX_HTTP_BAD_REQUEST, &NGX_HTTP_PUSH_STREAM_EMPTY_POST_REQUEST_MESSAGE);
return;
}
// get and check if has access to request body
NGX_HTTP_PUSH_STREAM_CHECK_AND_FINALIZE_REQUEST_ON_ERROR(r->request_body->bufs, NULL, r, "push stream module: unexpected publisher message request body buffer location. please report this to the push stream module developers.");
// copy request body to a memory buffer
buf = ngx_http_push_stream_read_request_body_to_buffer(r);
NGX_HTTP_PUSH_STREAM_CHECK_AND_FINALIZE_REQUEST_ON_ERROR(buf, NULL, r, "push stream module: cannot allocate memory for read the message");
event_id = ngx_http_push_stream_get_header(r, &NGX_HTTP_PUSH_STREAM_HEADER_EVENT_ID);
event_type = ngx_http_push_stream_get_header(r, &NGX_HTTP_PUSH_STREAM_HEADER_EVENT_TYPE);
for (q = ngx_queue_head(&ctx->requested_channels->queue); q != ngx_queue_sentinel(&ctx->requested_channels->queue); q = ngx_queue_next(q)) {
requested_channel = ngx_queue_data(q, ngx_http_push_stream_requested_channel_t, queue);
if (ngx_http_push_stream_add_msg_to_channel(mcf, r->connection->log, requested_channel->channel, buf->pos, ngx_buf_size(buf), event_id, event_type, cf->store_messages, r->pool) != NGX_OK) {
ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
return;
}
}
if (cf->channel_info_on_publish) {
ngx_http_push_stream_send_response_channels_info_detailed(r, ctx->requested_channels);
ngx_http_finalize_request(r, NGX_OK);
} else {
ngx_http_push_stream_send_only_header_response_and_finalize(r, NGX_HTTP_OK, NULL);
}
}
