static void
ngx_procs_process_exit(ngx_cycle_t *cycle, ngx_proc_module_t *module)
{
ngx_uint_t i;
ngx_connection_t *c;
#if (NGX_THREADS)
ngx_terminate = 1;
ngx_wakeup_worker_threads(cycle);
#endif
if (module->exit) {
module->exit(cycle);
}
if (ngx_exiting) {
c = cycle->connections;
for (i = 0; i < cycle->connection_n; i++) {
if (c[i].fd != -1
&& c[i].read
&& !c[i].read->accept
&& !c[i].read->channel
&& !c[i].read->resolver)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"open socket #%d left in connection %ui",
c[i].fd, i);
ngx_debug_quit = 1;
}
}
if (ngx_debug_quit) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "aborting");
ngx_debug_point();
}
}
/*
* Copy ngx_cycle->log related data to the special static exit cycle,
* log, and log file structures enough to allow a signal handler to log.
* The handler may be called when standard ngx_cycle->log allocated from
* ngx_cycle->pool is already destroyed.
*/
ngx_procs_exit_log_file.fd = ngx_cycle->log->file->fd;
ngx_procs_exit_log = *ngx_cycle->log;
ngx_procs_exit_log.file = &ngx_procs_exit_log_file;
ngx_procs_exit_cycle.log = &ngx_procs_exit_log;
ngx_cycle = &ngx_procs_exit_cycle;
ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0, "process %V exit",
&module->name);
ngx_destroy_pool(cycle->pool);
exit(0);
}
void ngx_array_t_test()
{
ngx_pool_t* pool;
int i = 0;
printf("--------------------------------\n");
printf("the size of ngx_array_t: \n");
printf("--------------------------------\n");
printf("%lu\n\n", sizeof(ngx_array_t));
printf("--------------------------------\n");
printf("create a new pool: \n");
printf("--------------------------------\n");
pool = ngx_create_pool(1024, NULL);
dump_pool(pool);
printf("--------------------------------\n");
printf("alloc an array from the pool: \n");
printf("--------------------------------\n");
ngx_array_t* array = ngx_array_create(pool, 10, sizeof(int));
dump_pool(pool);
for(i = 0; i < 100; ++i)
{
int* ptr = ngx_array_push(array);
*ptr = i + 1;
}
dump_array(array);
ngx_array_destroy(array);
ngx_destroy_pool(pool);
}
ngx_int_t websocket_subscriber_destroy(subscriber_t *sub) {
full_subscriber_t *fsub = (full_subscriber_t *)sub;
nchan_request_ctx_t *ctx;
if(!fsub->awaiting_destruction) {
ctx = ngx_http_get_module_ctx(fsub->sub.request, nchan_module);
ctx->sub = NULL;
}
if(fsub->upstream_stuff && fsub->upstream_stuff->psr_data.tmp_pool) {
ngx_destroy_pool(fsub->upstream_stuff->psr_data.tmp_pool);
}
if(sub->reserved > 0) {
DBG("%p not ready to destroy (reserved for %i) for req %p", sub, sub->reserved, fsub->sub.request);
fsub->awaiting_destruction = 1;
}
else {
DBG("%p destroy for req %p", sub, fsub->sub.request);
nchan_free_msg_id(&fsub->sub.last_msgid);
#if NCHAN_SUBSCRIBER_LEAK_DEBUG
subscriber_debug_remove(&fsub->sub);
#endif
nchan_free_msg_id(&sub->last_msgid);
//debug
ngx_memset(fsub, 0x13, sizeof(*fsub));
ngx_free(fsub);
}
return NGX_OK;
}
static void
ngx_tcp_check_clear_all_events()
{
ngx_uint_t i;
static ngx_flag_t has_cleared = 0;
ngx_tcp_check_peer_shm_t *peer_shm;
ngx_tcp_check_peers_shm_t *peers_shm;
ngx_tcp_check_peer_conf_t *peer_conf;
ngx_tcp_check_peers_conf_t *peers_conf;
if (has_cleared || check_peers_ctx == NULL) {
return;
}
has_cleared = 1;
peers_conf = check_peers_ctx;
peers_shm = peers_conf->peers_shm;
peer_conf = peers_conf->peers.elts;
peer_shm = peers_shm->peers;
for (i = 0; i < peers_conf->peers.nelts; i++) {
if (peer_conf[i].check_ev.timer_set) {
ngx_del_timer(&peer_conf[i].check_ev);
}
if (peer_shm[i].owner == ngx_pid) {
ngx_tcp_check_clean_event(&peer_conf[i]);
}
if (peer_conf[i].pool != NULL) {
ngx_destroy_pool(peer_conf[i].pool);
}
}
}
int main()
{
ngx_pool_t* pool;
ngx_array_t* arr;
int n;
int* ele;
pool = ngx_create_pool(4000, NULL);
arr = ngx_array_create(pool, 10, sizeof(ngx_uint_t));
for (n=0; n < 5; n++) {
ele = (int*) ngx_array_push(arr);
*ele = n;
printf("new element %d added\n", n);
}
printf("arr->nelts is %d, arr->nalloc = %d\n", arr->nelts, arr->nalloc);
for (n=5; n < 15; n++) {
ele = (int*) ngx_array_push(arr);
*ele = n;
printf("new element %d added\n", n);
}
printf("arr->nelts is %d, arr->nalloc = %d\n", arr->nelts, arr->nalloc);
ngx_array_destroy(arr);
ngx_destroy_pool(pool);
return 0;
}
/* 工作进程退出 */
static void
ngx_worker_process_exit(ngx_cycle_t *cycle)
{
ngx_uint_t i;
ngx_connection_t *c;
for (i = 0; ngx_modules[i]; i++) {
if (ngx_modules[i]->exit_process) {
ngx_modules[i]->exit_process(cycle);
}
}
if (ngx_exiting) {
c = cycle->connections;
for (i = 0; i < cycle->connection_n; i++) {
if (c[i].fd != -1
&& c[i].read
&& !c[i].read->accept
&& !c[i].read->channel
&& !c[i].read->resolver)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"*%uA open socket #%d left in connection %ui",
c[i].number, c[i].fd, i);
ngx_debug_quit = 1;
}
}
if (ngx_debug_quit) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "aborting");
ngx_debug_point();
}
}
/*
* Copy ngx_cycle->log related data to the special static exit cycle,
* log, and log file structures enough to allow a signal handler to log.
* The handler may be called when standard ngx_cycle->log allocated from
* ngx_cycle->pool is already destroyed.
*/
ngx_exit_log = *ngx_log_get_file_log(ngx_cycle->log);
ngx_exit_log_file.fd = ngx_exit_log.file->fd;
ngx_exit_log.file = &ngx_exit_log_file;
ngx_exit_log.next = NULL;
ngx_exit_log.writer = NULL;
ngx_exit_cycle.log = &ngx_exit_log;
ngx_exit_cycle.files = ngx_cycle->files;
ngx_exit_cycle.files_n = ngx_cycle->files_n;
ngx_cycle = &ngx_exit_cycle;
ngx_destroy_pool(cycle->pool);
ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0, "exit");
/* 此时进程就退出了，进程之后的代码就都不会执行了 */
exit(0);
}
void
ngx_mail_close_connection(ngx_connection_t *c)
{
ngx_pool_t *pool;
ngx_log_debug1(NGX_LOG_DEBUG_MAIL, c->log, 0,
"close mail connection: %d", c->fd);
#if (NGX_MAIL_SSL)
if (c->ssl) {
if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
c->ssl->handler = ngx_mail_close_connection;
return;
}
}
#endif
#if (NGX_STAT_STUB)
(void) ngx_atomic_fetch_add(ngx_stat_active, -1);
#endif
c->destroyed = 1;
pool = c->pool;
ngx_close_connection(c);
ngx_destroy_pool(pool);
}
static void
ngx_rtmp_gop_cache_cleanup(ngx_rtmp_session_t *s)
{
ngx_rtmp_gop_cache_ctx_t *ctx;
ngx_rtmp_gop_cache_t *cache;
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_gop_cache_module);
if (ctx == NULL) {
return;
}
for (cache = ctx->cache_head; cache; cache = cache->next) {
ngx_rtmp_gop_cache_free_cache(s, cache);
}
if (ctx->pool) {
ngx_destroy_pool(ctx->pool);
ctx->pool = NULL;
}
ctx->video_seq_header = NULL;
ctx->audio_seq_header = NULL;
ctx->meta = NULL;
ctx->cache_tail = ctx->cache_head = NULL;
ctx->gop_cache_count = 0;
ctx->free_cache = NULL;
ctx->free_frame = NULL;
ctx->video_frame_in_all = 0;
ctx->audio_frame_in_all = 0;
}
// 关闭stream连接，销毁线程池
void
ngx_stream_close_connection(ngx_connection_t *c)
{
ngx_pool_t *pool;
ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
"close stream connection: %d", c->fd);
#if (NGX_STREAM_SSL)
if (c->ssl) {
if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
c->ssl->handler = ngx_stream_close_connection;
return;
}
}
#endif
#if (NGX_STAT_STUB)
(void) ngx_atomic_fetch_add(ngx_stat_active, -1);
#endif
// 暂时保留内存池
pool = c->pool;
// 关闭连接
ngx_close_connection(c);
// 最后再销毁内存池
ngx_destroy_pool(pool);
}
static void
ngx_worker_process_exit(ngx_cycle_t *cycle)
{
ngx_uint_t i;
ngx_connection_t *c;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exit");
for (i = 0; ngx_modules[i]; i++) {
if (ngx_modules[i]->exit_process) {
ngx_modules[i]->exit_process(cycle);
}
}
if (ngx_exiting) {
c = cycle->connections;
for (i = 0; i < cycle->connection_n; i++) {
if (c[i].fd != -1
&& c[i].read
&& !c[i].read->accept
&& !c[i].read->channel
&& !c[i].read->resolver)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"open socket #%d left in connection %ui",
c[i].fd, i);
}
}
}
ngx_destroy_pool(cycle->pool);
exit(0);
}
static void
ngx_master_process_exit(ngx_cycle_t *cycle)
{
ngx_uint_t i;
ngx_delete_pidfile(cycle);
ngx_close_handle(ngx_cache_manager_mutex);
ngx_close_handle(ngx_stop_event);
ngx_close_handle(ngx_quit_event);
ngx_close_handle(ngx_reopen_event);
ngx_close_handle(ngx_reload_event);
ngx_close_handle(ngx_master_process_event);
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exit");
for (i = 0; ngx_modules[i]; i++) {
if (ngx_modules[i]->exit_master) {
ngx_modules[i]->exit_master(cycle);
}
}
ngx_destroy_pool(cycle->pool);
exit(0);
}
static void
ngx_mail_zmauth_wait_handler(ngx_event_t *ev) {
ngx_connection_t *c;
ngx_mail_session_t *s;
ngx_mail_zmauth_ctx_t *ctx;
ngx_log_debug0(NGX_LOG_DEBUG_MAIL, ev->log, 0, "mail zmauth wait handler");
c = ev->data;
s = c->data;
ctx = ngx_mail_get_module_ctx(s, ngx_mail_zmauth_module);
if (ev->timedout) {
/* we need to close the connection immediately */
ngx_destroy_pool(ctx->pool);
ngx_mail_set_ctx(s, NULL, ngx_mail_zmauth_module);
s->quit = 1;
ngx_mail_send(c->write);
return;
}
if (ev->active) {
if (ngx_handle_read_event(ev, 0) != NGX_OK) {
ngx_mail_close_connection(c);
}
}
}
void* add_urls_to_array(ngx_pool_t *pool, ngx_hash_keys_arrays_t *ha, ngx_array_t *url, ngx_array_t *value)
{
ngx_uint_t loop;
ngx_int_t rc;
ngx_str_t *strUrl, *strValue;
memset(ha, 0, sizeof(ngx_hash_keys_arrays_t));
ha->temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, &ngx_log);
ha->pool = pool;
if (ngx_hash_keys_array_init(ha, NGX_HASH_LARGE) != NGX_OK) {
goto failed;
}
strUrl = url->elts;
strValue = value->elts;
for (loop = 0; loop < url->nelts; loop++)
{
rc = ngx_hash_add_key(ha, &strUrl[loop], &strValue[loop],
NGX_HASH_WILDCARD_KEY);
if (rc == NGX_ERROR) {
goto failed;
}
}
return ha;
failed:
ngx_destroy_pool(ha->temp_pool);
return NULL;
}
// 发生了错误，关闭一个连接
static void
ngx_close_accepted_connection(ngx_connection_t *c)
{
ngx_socket_t fd;
// 释放连接，加入空闲链表
// in core/ngx_connection.c
ngx_free_connection(c);
// 连接的描述符置为无效
fd = c->fd;
c->fd = (ngx_socket_t) -1;
// 关闭socket
if (!c->shared && ngx_close_socket(fd) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_socket_errno,
ngx_close_socket_n " failed");
}
// 释放连接相关的所有内存
if (c->pool) {
ngx_destroy_pool(c->pool);
}
#if (NGX_STAT_STUB)
(void) ngx_atomic_fetch_add(ngx_stat_active, -1);
#endif
}
// hash table的一些基本操作
int main()
{
ngx_uint_t k; //, p, h;
ngx_pool_t* pool;
ngx_hash_init_t hash_init;
ngx_hash_t* hash;
ngx_array_t* elements;
ngx_hash_key_t* arr_node;
char* find;
int i;
ngx_cacheline_size = 32;
// hash key cal start
ngx_str_t str = ngx_string("hello, world");
k = ngx_hash_key_lc( str.data, str.len);
pool = ngx_create_pool(1024*10, NULL);
printf("caculated key is %u \n", k);
// hask key cal end
//
hash = (ngx_hash_t*) ngx_pcalloc(pool, sizeof(hash));
hash_init.hash = hash; // hash结构
hash_init.key = &ngx_hash_key_lc; // hash算法函数
hash_init.max_size = 1024*10; // max_size
hash_init.bucket_size = 64; // ngx_align(64, ngx_cacheline_size);
hash_init.name = "yahoo_guy_hash"; // 在log里会用到
hash_init.pool = pool; // 内存池
hash_init.temp_pool = NULL;
// 创建数组
elements = ngx_array_create(pool, 32, sizeof(ngx_hash_key_t));
for(i = 0; i < 3; i++) {
arr_node = (ngx_hash_key_t*) ngx_array_push(elements);
arr_node->key = (names[i]);
arr_node->key_hash = ngx_hash_key_lc(arr_node->key.data, arr_node->key.len);
arr_node->value = (void*) descs[i];
//
printf("key: %s , key_hash: %u\n", arr_node->key.data, arr_node->key_hash);
}
if (ngx_hash_init(&hash_init, (ngx_hash_key_t*) elements->elts, elements->nelts)!=NGX_OK){
return 1;
}
// 查找
k = ngx_hash_key_lc(names[0].data, names[0].len);
printf("%s key is %d\n", names[0].data, k);
find = (char*)
ngx_hash_find(hash, k, (u_char*) names[0].data, names[0].len);
if (find) {
printf("get desc of rainx: %s\n", (char*) find);
}
ngx_array_destroy(elements);
ngx_destroy_pool(pool);
return 0;
}
void
ngx_postgres_upstream_free_connection(ngx_log_t *log, ngx_connection_t *c,
PGconn *pgconn, ngx_postgres_upstream_srv_conf_t *pgscf)
{
ngx_event_t *rev, *wev;
dd("entering");
PQfinish(pgconn);
if (c) {
rev = c->read;
wev = c->write;
if (rev->timer_set) {
ngx_del_timer(rev);
}
if (wev->timer_set) {
ngx_del_timer(wev);
}
if (ngx_del_conn) {
ngx_del_conn(c, NGX_CLOSE_EVENT);
} else {
if (rev->active || rev->disabled) {
ngx_del_event(rev, NGX_READ_EVENT, NGX_CLOSE_EVENT);
}
if (wev->active || wev->disabled) {
ngx_del_event(wev, NGX_WRITE_EVENT, NGX_CLOSE_EVENT);
}
}
if (rev->prev) {
ngx_delete_posted_event(rev);
}
if (wev->prev) {
ngx_delete_posted_event(wev);
}
rev->closed = 1;
wev->closed = 1;
#if defined(nginx_version) && (nginx_version >= 1001004)
if (c->pool) {
ngx_destroy_pool(c->pool);
}
#endif
ngx_free_connection(c);
}
/* free spot in keepalive connection pool */
pgscf->active_conns--;
dd("returning");
}
static void
ngx_http_tfs_remote_block_cache_dummy_handler(ngx_int_t rc, void *data)
{
ngx_pool_t *pool = (ngx_pool_t *)data;
ngx_destroy_pool(pool);
return;
}
void app_close(int num){
triger ( NOTIFIER_EXIT, &globals_r);
//extern struct GLOBAL_RAPHTERS globals_r;
//cleanup_handlers(globals_r.pool);
// should free the total memory
if ( globals_r.pool ) ngx_destroy_pool(globals_r.pool);
// globals_r.pool = NULL;
// globals_r.con = NULL;
}
int main(/* int argc, char **argv */)
{
ngx_pool_t *pool = NULL;
ngx_array_t *array = NULL;
ngx_hash_t *hash;
printf("--------------------------------\n");
printf("create a new pool:\n");
printf("--------------------------------\n");
pool = ngx_create_pool(1024, NULL);
dump_pool(pool);
printf("--------------------------------\n");
printf("create and add urls to it:\n");
printf("--------------------------------\n");
array = add_urls_to_array(pool); //in fact, here should validate array
dump_hash_array(array);
printf("--------------------------------\n");
printf("the pool:\n");
printf("--------------------------------\n");
dump_pool(pool);
hash = init_hash(pool, array);
if (hash == NULL)
{
printf("Failed to initialize hash!\n");
return -1;
}
printf("--------------------------------\n");
printf("the hash:\n");
printf("--------------------------------\n");
dump_hash(hash, array);
printf("\n");
printf("--------------------------------\n");
printf("the pool:\n");
printf("--------------------------------\n");
dump_pool(pool);
//find test
printf("--------------------------------\n");
printf("find test:\n");
printf("--------------------------------\n");
find_test(hash, urls, Max_Num);
printf("\n");
find_test(hash, urls2, Max_Num2);
//release
ngx_array_destroy(array);
ngx_destroy_pool(pool);
return 0;
}
static ngx_int_t
ngx_http_dyups_check_commands(ngx_array_t *arglist)
{
ngx_int_t rc;
ngx_url_t u;
ngx_str_t *value;
ngx_pool_t *pool;
ngx_uint_t i;
ngx_array_t *line;
pool = ngx_create_pool(128, ngx_cycle->log);
if (pool == NULL) {
return NGX_ERROR;
}
line = arglist->elts;
for (i = 0; i < arglist->nelts; i++) {
value = line[i].elts;
/* TODO */
if (line[i].nelts != 2) {
rc = NGX_ERROR;
goto finish;
}
if (value[0].len == 6 &&
ngx_strncasecmp(value[0].data, (u_char *) "server", 6) != 0)
{
rc = NGX_ERROR;
goto finish;
}
u.url = value[1];
u.default_port = 80;
if (ngx_parse_url(pool, &u) != NGX_OK) {
if (u.err) {
ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, 0,
"%s in upstream \"%V\"", u.err, &u.url);
}
rc = NGX_ERROR;
goto finish;
}
}
rc = NGX_OK;
finish:
ngx_destroy_pool(pool);
return rc;
}
static void ngx_master_exit(ngx_cycle_t *cycle, ngx_master_ctx_t *ctx)
{
ngx_delete_pidfile(cycle);
ngx_log_error(NGX_LOG_INFO, cycle->log, 0, "exit");
ngx_destroy_pool(cycle->pool);
exit(0);
}
void
ngx_http_memcachep_close_connection(ngx_connection_t *c)
{
ngx_pool_t *pool;
c->destroyed = 1;
pool = c->pool;
ngx_close_connection(c);
ngx_destroy_pool(pool);
}
static void
ngx_rtmp_close_connection(ngx_connection_t *c)
{
ngx_pool_t *pool;
ngx_log_debug0(NGX_LOG_DEBUG_RTMP, c->log, 0, "close connection");
pool = c->pool;
ngx_close_connection(c);
ngx_destroy_pool(pool);
}
static void ngx_http_upstream_dynamic_servers_exit_process(ngx_cycle_t *cycle) {
ngx_http_upstream_dynamic_server_main_conf_t *udsmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_upstream_dynamic_servers_module);
ngx_http_upstream_dynamic_server_conf_t *dynamic_server = udsmcf->dynamic_servers.elts;
ngx_uint_t i;
for (i = 0; i < udsmcf->dynamic_servers.nelts; i++) {
if (dynamic_server[i].pool) {
ngx_destroy_pool(dynamic_server[i].pool);
dynamic_server[i].pool = NULL;
}
}
}
static void
ngx_ssl_ocsp_done(ngx_ssl_ocsp_ctx_t *ctx)
{
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
"ssl ocsp done");
if (ctx->peer.connection) {
ngx_close_connection(ctx->peer.connection);
}
ngx_destroy_pool(ctx->pool);
}
static void nchan_exit_worker(ngx_cycle_t *cycle) {
nchan_store_memory.exit_worker(cycle);
nchan_store_redis.exit_worker(cycle);
nchan_output_shutdown();
ngx_destroy_pool(nchan_pool); // just for this worker
#if NCHAN_SUBSCRIBER_LEAK_DEBUG
subscriber_debug_assert_isempty();
#endif
#if NCHAN_MSG_LEAK_DEBUG
msg_debug_assert_isempty();
#endif
}
void ngx_queue_t_test()
{
int i = 0;
ngx_pool_t* pool;
ngx_queue_t* myque;
my_point_queue_t* point;
my_point_t points[POINTS_LEN] = {
{10, 1}, {20, 9}, {9, 9}, {90, 80}, {5, 3}, {50, 20}
};
printf("----------------------------------------\n");
printf("the size of ngx_queue_t: \n");
printf("----------------------------------------\n");
printf("%lu\n\n", sizeof(ngx_queue_t));
printf("----------------------------------------\n");
printf("create a new pool: \n");
printf("----------------------------------------\n");
pool = ngx_create_pool(1024, NULL);
dump_pool(pool);
printf("----------------------------------------\n");
printf("alloc a queue head and nodes: \n");
printf("----------------------------------------\n");
myque = ngx_palloc(pool, sizeof(ngx_queue_t));
ngx_queue_init(myque);
for(i = 0; i < POINTS_LEN; ++i)
{
point = (my_point_queue_t*)ngx_palloc(pool, sizeof(my_point_queue_t));
point->point.x = points[i].x;
point->point.y = points[i].y;
ngx_queue_init(&point->queue);
ngx_queue_insert_head(myque, &point->queue);
}
dump_queue_from_tail(myque);
printf("\n");
printf("----------------------------------------\n");
printf("sort the queue: \n");
printf("----------------------------------------\n");
ngx_queue_sort(myque, my_point_cmp);
dump_queue_from_head(myque);
printf("\n");
printf("----------------------------------------\n");
printf("the pool at the end: \n");
printf("----------------------------------------\n");
dump_pool(pool);
ngx_destroy_pool(pool);
}
int main()
{
ngx_pool_t *pool;
ngx_queue_t *myque;
my_point_queue_t *point;
my_point_t points[Max_Num] = {
{10, 1}, {20, 9}, {9, 9}, {90, 80}, {5, 3}, {50, 20}
};
int i;
printf("--------------------------------\n");
printf("create a new pool:\n");
printf("--------------------------------\n");
pool = ngx_create_pool(1024, NULL);
dump_pool(pool);
printf("--------------------------------\n");
printf("alloc a queue head and nodes :\n");
printf("--------------------------------\n");
myque =ngx_palloc(pool, sizeof(ngx_queue_t)); //alloc a queue head
ngx_queue_init(myque); //init the queue
//insert some points into the queue
for (i = 0; i < Max_Num; i++)
{
point = (my_point_queue_t*)ngx_palloc(pool, sizeof(my_point_queue_t));
point->point.x = points[i].x;
point->point.y = points[i].y;
ngx_queue_init(&point->queue);
//insert this point into the points queue
ngx_queue_insert_head(myque, &point->queue);
}
dump_queue_from_tail(myque);
printf("\n");
printf("--------------------------------\n");
printf("sort the queue:\n");
printf("--------------------------------\n");
ngx_queue_sort(myque, my_point_cmp);
dump_queue_from_head(myque);
printf("\n");
printf("--------------------------------\n");
printf("the pool at the end:\n");
printf("--------------------------------\n");
dump_pool(pool);
ngx_destroy_pool(pool);
return 0;
}
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 void
ngx_close_udp_connection(ngx_connection_t *c)
{
ngx_free_connection(c);
if (c->pool) {
ngx_destroy_pool(c->pool);
}
#if (NGX_STAT_STUB)
(void) ngx_atomic_fetch_add(ngx_stat_active, -1);
#endif
}
