Skip to content
This repository
Browse code

git-svn-id: svn://cherokee-project.com/cherokee/trunk@384 5dc97367-97…

…f1-0310-9951-d761b3857238
  • Loading branch information...
commit ee8023f218e58f866eeb54bd5434b7baa6920f8e 1 parent 1c17f18
Alvaro Lopez Ortega alobbs authored

Showing 64 changed files with 267 additions and 673 deletions. Show diff stats Hide diff stats

  1. +0 2  cherokee/Makefile.am
  2. +17 17 cherokee/access.c
  3. +2 2 cherokee/access.h
  4. +3 3 cherokee/admin_client.c
  5. +1 1  cherokee/admin_client.h
  6. +2 2 cherokee/admin_server.c
  7. +0 1  cherokee/cherokee.h
  8. +6 6 cherokee/cherokee_show.c
  9. +1 5 cherokee/config_entry.h
  10. +7 8 cherokee/config_node.c
  11. +3 3 cherokee/config_node.h
  12. +1 1  cherokee/connection-protected.h
  13. +5 5 cherokee/connection_info.c
  14. +3 3 cherokee/connection_info.h
  15. +13 13 cherokee/ext_source.c
  16. +4 5 cherokee/ext_source.h
  17. +2 3 cherokee/exts_table.c
  18. +5 5 cherokee/fcgi_dispatcher.c
  19. +1 1  cherokee/fcgi_dispatcher.h
  20. +0 1  cherokee/handler_cgi.c
  21. +5 7 cherokee/handler_cgi_base.c
  22. +1 1  cherokee/handler_cgi_base.h
  23. +1 2  cherokee/handler_common.c
  24. +14 15 cherokee/handler_dirlist.c
  25. +5 5 cherokee/handler_dirlist.h
  26. +4 4 cherokee/handler_error_redir.c
  27. +1 1  cherokee/handler_error_redir.h
  28. +1 1  cherokee/handler_fastcgi.c
  29. +2 2 cherokee/handler_fastcgi.h
  30. +2 2 cherokee/handler_fcgi.c
  31. +1 1  cherokee/handler_fcgi.h
  32. +1 1  cherokee/handler_file.c
  33. +1 1  cherokee/handler_phpcgi.c
  34. +1 1  cherokee/handler_proxy.c
  35. +5 6 cherokee/handler_redir.c
  36. +1 1  cherokee/handler_redir.h
  37. +2 2 cherokee/handler_scgi.c
  38. +2 2 cherokee/handler_scgi.h
  39. +1 1  cherokee/handler_server_info.c
  40. +0 1  cherokee/icons.c
  41. +4 4 cherokee/iocache.c
  42. +39 39 cherokee/list.c
  43. +18 15 cherokee/list.h
  44. +0 2  cherokee/main_admin.c
  45. +6 6 cherokee/matching_list.c
  46. +3 3 cherokee/matching_list.h
  47. +2 2 cherokee/mime-protected.h
  48. +4 4 cherokee/mime.c
  49. +1 1  cherokee/mime_entry.c
  50. +5 5 cherokee/reqs_list.c
  51. +1 1  cherokee/reqs_list.h
  52. +1 1  cherokee/reqs_list_entry.h
  53. +1 1  cherokee/request.c
  54. +1 1  cherokee/request.h
  55. +2 2 cherokee/server-protected.h
  56. +17 18 cherokee/server.c
  57. +25 26 cherokee/thread.c
  58. +4 4 cherokee/thread.h
  59. +0 317 cherokee/typed_table.c
  60. +0 70 cherokee/typed_table.h
  61. +1 1  cherokee/validator.c
  62. +1 1  cherokee/validator_ldap.c
  63. +2 3 cherokee/virtual_server.c
  64. +2 2 cherokee/virtual_server.h
2  cherokee/Makefile.am
@@ -714,8 +714,6 @@ regex.h \
714 714 regex.c \
715 715 resolv_cache.h \
716 716 resolv_cache.c \
717   -typed_table.h \
718   -typed_table.c \
719 717 post.h \
720 718 post.c
721 719
34 cherokee/access.c
@@ -64,10 +64,10 @@ typedef union {
64 64 } ip_t;
65 65
66 66 typedef struct {
67   - list_t node;
  67 + cherokee_list_t node;
68 68
69   - ip_type_t type;
70   - ip_t ip;
  69 + ip_type_t type;
  70 + ip_t ip;
71 71 } ip_item_t;
72 72
73 73 typedef struct {
@@ -87,7 +87,7 @@ new_ip (void)
87 87 ip_item_t *n = (ip_item_t *) malloc (sizeof(ip_item_t));
88 88 if (n == NULL) return NULL;
89 89
90   - INIT_LIST_HEAD((list_t*)n);
  90 + INIT_LIST_HEAD (LIST(n));
91 91 memset (&n->ip, 0, sizeof(ip_t));
92 92
93 93 return n;
@@ -109,7 +109,7 @@ new_subnet (void)
109 109 memset (&n->base.ip, 0, sizeof(ip_t));
110 110 memset (&n->mask, 0, sizeof(ip_t));
111 111
112   - INIT_LIST_HEAD((list_t*)n);
  112 + INIT_LIST_HEAD (LIST(n));
113 113 return n;
114 114 }
115 115
@@ -154,18 +154,18 @@ print_ip (ip_type_t type, ip_t *ip)
154 154 ret_t
155 155 cherokee_access_free (cherokee_access_t *entry)
156 156 {
157   - list_t *i, *tmp;
  157 + cherokee_list_t *i, *tmp;
158 158
159 159 /* Free the IP list items
160 160 */
161   - list_for_each_safe (i, tmp, (list_t*)&entry->list_ips) {
  161 + list_for_each_safe (i, tmp, LIST(&entry->list_ips)) {
162 162 list_del (i);
163 163 free (i);
164 164 }
165 165
166 166 /* Free the Subnet list items
167 167 */
168   - list_for_each_safe (i, tmp, (list_t*)&entry->list_subnets) {
  168 + list_for_each_safe (i, tmp, LIST(&entry->list_subnets)) {
169 169 list_del (i);
170 170 free (i);
171 171 }
@@ -317,7 +317,7 @@ cherokee_access_add_ip (cherokee_access_t *entry, char *ip)
317 317 return ret;
318 318 }
319 319
320   - list_add ((list_t *)n, &entry->list_ips);
  320 + list_add (LIST(n), &entry->list_ips);
321 321
322 322 return ret;
323 323 }
@@ -362,7 +362,7 @@ cherokee_access_add_subnet (cherokee_access_t *entry, char *subnet)
362 362 n = new_subnet();
363 363 if (n == NULL) return ret_error;
364 364
365   - list_add ((list_t *)n, &entry->list_subnets);
  365 + list_add (LIST(n), &entry->list_subnets);
366 366
367 367 /* Parse the IP
368 368 */
@@ -447,17 +447,17 @@ cherokee_access_add (cherokee_access_t *entry, char *ip_or_subnet)
447 447 ret_t
448 448 cherokee_access_print_debug (cherokee_access_t *entry)
449 449 {
450   - list_t *i;
  450 + cherokee_list_t *i;
451 451
452 452 printf ("IPs: ");
453   - list_for_each (i, (list_t*)&entry->list_ips) {
  453 + list_for_each (i, LIST(&entry->list_ips)) {
454 454 print_ip (IP_NODE(i)->type, &IP_NODE(i)->ip);
455 455 printf(" ");
456 456 }
457 457 printf("\n");
458 458
459 459 printf ("Subnets: ");
460   - list_for_each (i, (list_t*)&entry->list_subnets) {
  460 + list_for_each (i, LIST(&entry->list_subnets)) {
461 461 print_ip (IP_NODE(i)->type, &IP_NODE(i)->ip);
462 462 printf("/");
463 463 print_ip (IP_NODE(i)->type, &SUBNET_NODE(i)->mask);
@@ -472,12 +472,12 @@ cherokee_access_print_debug (cherokee_access_t *entry)
472 472 ret_t
473 473 cherokee_access_ip_match (cherokee_access_t *entry, cherokee_socket_t *sock)
474 474 {
475   - int re;
476   - list_t *i;
  475 + int re;
  476 + cherokee_list_t *i;
477 477
478 478 /* Check in the IP list
479 479 */
480   - list_for_each (i, (list_t*)&entry->list_ips) {
  480 + list_for_each (i, LIST(&entry->list_ips)) {
481 481
482 482 #ifdef HAVE_IPV6
483 483 /* This is a special case:
@@ -529,7 +529,7 @@ cherokee_access_ip_match (cherokee_access_t *entry, cherokee_socket_t *sock)
529 529
530 530 /* Check in the Subnets list
531 531 */
532   - list_for_each (i, (list_t*)&entry->list_subnets) {
  532 + list_for_each (i, LIST(&entry->list_subnets)) {
533 533 int j;
534 534 ip_t masqued_remote, masqued_list;
535 535
4 cherokee/access.h
@@ -30,8 +30,8 @@
30 30 #include "socket.h"
31 31
32 32 typedef struct {
33   - list_t list_ips;
34   - list_t list_subnets;
  33 + cherokee_list_t list_ips;
  34 + cherokee_list_t list_subnets;
35 35 } cherokee_access_t;
36 36
37 37 ret_t cherokee_access_new (cherokee_access_t **entry);
6 cherokee/admin_client.c
@@ -376,7 +376,7 @@ ask_get_connections (cherokee_admin_client_t *admin, void *arg)
376 376 }
377 377
378 378 static ret_t
379   -parse_reply_get_connections (char *reply, list_t *conns_list)
  379 +parse_reply_get_connections (char *reply, cherokee_list_t *conns_list)
380 380 {
381 381 char *begin;
382 382 char *end;
@@ -438,7 +438,7 @@ parse_reply_get_connections (char *reply, list_t *conns_list)
438 438 SHOULDNT_HAPPEN;
439 439 }
440 440
441   - list_add ((list_t *)conn_info, conns_list);
  441 + list_add (LIST(conn_info), conns_list);
442 442 cherokee_buffer_clean (&info_str);
443 443 }
444 444
@@ -446,7 +446,7 @@ parse_reply_get_connections (char *reply, list_t *conns_list)
446 446 }
447 447
448 448 ret_t
449   -cherokee_admin_client_ask_connections (cherokee_admin_client_t *admin, list_t *conns_list)
  449 +cherokee_admin_client_ask_connections (cherokee_admin_client_t *admin, cherokee_list_t *conns_list)
450 450 {
451 451 ret_t ret;
452 452
2  cherokee/admin_client.h
@@ -101,7 +101,7 @@ ret_t cherokee_admin_client_ask_port_tls (cherokee_admin_client_t *admin, cui
101 101 ret_t cherokee_admin_client_ask_rx (cherokee_admin_client_t *admin, cherokee_buffer_t *rx);
102 102 ret_t cherokee_admin_client_ask_tx (cherokee_admin_client_t *admin, cherokee_buffer_t *tx);
103 103
104   -ret_t cherokee_admin_client_ask_connections (cherokee_admin_client_t *admin, list_t *conns);
  104 +ret_t cherokee_admin_client_ask_connections (cherokee_admin_client_t *admin, cherokee_list_t *conns);
105 105 ret_t cherokee_admin_client_del_connection (cherokee_admin_client_t *admin, char *id);
106 106 ret_t cherokee_admin_client_ask_thread_num (cherokee_admin_client_t *admin, cherokee_buffer_t *num);
107 107 ret_t cherokee_admin_client_set_backup_mode (cherokee_admin_client_t *admin, cherokee_boolean_t active);
4 cherokee/admin_server.c
@@ -147,8 +147,8 @@ ret_t
147 147 cherokee_admin_server_reply_get_connections (cherokee_handler_admin_t *ahdl, cherokee_buffer_t *question, cherokee_buffer_t *reply)
148 148 {
149 149 ret_t ret;
150   - list_t *i, *tmp;
151   - list_t connections = LIST_HEAD_INIT(connections);
  150 + cherokee_list_t *i, *tmp;
  151 + cherokee_list_t connections = LIST_HEAD_INIT(connections);
152 152 cherokee_server_t *server = HANDLER_SRV(ahdl);
153 153
154 154 /* Get the connection info list
1  cherokee/cherokee.h
@@ -42,7 +42,6 @@
42 42 #include <cherokee/url.h>
43 43 #include <cherokee/header.h>
44 44 #include <cherokee/resolv_cache.h>
45   -#include <cherokee/typed_table.h>
46 45
47 46 /* Server library
48 47 */
12 cherokee/cherokee_show.c
@@ -41,16 +41,16 @@
41 41 int
42 42 main (int argc, char *argv[])
43 43 {
44   - ret_t ret;
45   - cuint_t fds_num;
  44 + ret_t ret;
  45 + cuint_t fds_num;
46 46 cherokee_fdpoll_t *fdpoll;
47 47 cherokee_admin_client_t *client;
48 48 cherokee_buffer_t url;
49   - list_t *i, *tmp;
  49 + cherokee_list_t *i, *tmp;
50 50
51   - cuint_t port;
52   - cherokee_buffer_t buf;
53   - list_t conns = LIST_HEAD_INIT(conns);
  51 + cuint_t port;
  52 + cherokee_buffer_t buf;
  53 + cherokee_list_t conns = LIST_HEAD_INIT(conns);
54 54
55 55 if (argc <= 1) {
56 56 PRINT_ERROR ("%s url request\n", argv[0]);
6 cherokee/config_entry.h
@@ -30,7 +30,6 @@
30 30 #include "table.h"
31 31 #include "handler.h"
32 32 #include "http.h"
33   -#include "typed_table.h"
34 33 #include "validator.h"
35 34
36 35 #define CHEROKEE_CONFIG_PRIORITY_NONE 0
@@ -73,10 +72,7 @@ ret_t cherokee_config_entry_free (cherokee_config_entry_t *entry);
73 72 ret_t cherokee_config_entry_init (cherokee_config_entry_t *entry);
74 73 ret_t cherokee_config_entry_mrproper (cherokee_config_entry_t *entry);
75 74
76   -ret_t cherokee_config_entry_set_handler_prop (cherokee_config_entry_t *entry, char *prop_name, cherokee_typed_table_types_t type, void *value, cherokee_table_free_item_t free_func);
77   -ret_t cherokee_config_entry_set_validator_prop (cherokee_config_entry_t *entry, char *prop_name, cherokee_typed_table_types_t type, void *value, cherokee_table_free_item_t free_func);
78   -ret_t cherokee_config_entry_set_handler (cherokee_config_entry_t *entry, cherokee_module_info_t *modinfo);
79   -
  75 +ret_t cherokee_config_entry_set_handler (cherokee_config_entry_t *entry, cherokee_module_info_t *modinfo);
80 76 ret_t cherokee_config_entry_complete (cherokee_config_entry_t *entry, cherokee_config_entry_t *parent, cherokee_boolean_t same_type);
81 77 ret_t cherokee_config_entry_inherit (cherokee_config_entry_t *entry);
82 78
15 cherokee/config_node.c
@@ -30,7 +30,6 @@
30 30
31 31 #include "config_node.h"
32 32 #include "util.h"
33   -#include "list_ext.h"
34 33
35 34 #define ENTRIES "config"
36 35
@@ -62,7 +61,7 @@ cherokee_config_node_new (cherokee_config_node_t **conf)
62 61 ret_t
63 62 cherokee_config_node_mrproper (cherokee_config_node_t *conf)
64 63 {
65   - list_t *i, *j;
  64 + cherokee_list_t *i, *j;
66 65
67 66 cherokee_buffer_mrproper (&conf->key);
68 67 cherokee_buffer_mrproper (&conf->val);
@@ -87,7 +86,7 @@ cherokee_config_node_free (cherokee_config_node_t *conf)
87 86 static cherokee_config_node_t *
88 87 search_child (cherokee_config_node_t *current, cherokee_buffer_t *child)
89 88 {
90   - list_t *i;
  89 + cherokee_list_t *i;
91 90 cherokee_config_node_t *entry;
92 91
93 92 list_for_each (i, &current->child) {
@@ -112,7 +111,7 @@ add_new_child (cherokee_config_node_t *entry, cherokee_buffer_t *key)
112 111
113 112 cherokee_buffer_add_buffer (&n->key, key);
114 113
115   - list_add_tail ((list_t *)n, &entry->child);
  114 + list_add_tail (LIST(n), &entry->child);
116 115 return n;
117 116 }
118 117
@@ -292,8 +291,8 @@ cherokee_config_node_get_buf (cherokee_config_node_t *conf, cherokee_buffer_t *k
292 291 ret_t
293 292 cherokee_config_node_while (cherokee_config_node_t *conf, cherokee_config_node_while_func_t func, void *data)
294 293 {
295   - ret_t ret;
296   - list_t *i;
  294 + ret_t ret;
  295 + cherokee_list_t *i;
297 296
298 297 cherokee_config_node_foreach (i, conf) {
299 298 ret = func (CONFIG_NODE(i), data);
@@ -499,12 +498,12 @@ cherokee_config_node_read_list (cherokee_config_node_t *conf,
499 498 static ret_t
500 499 convert_to_list_step (char *entry, void *data)
501 500 {
502   - return cherokee_list_add_tail_content ((list_t *)data, strdup(entry));
  501 + return cherokee_list_add_tail_content (LIST(data), strdup(entry));
503 502 }
504 503
505 504
506 505 ret_t
507   -cherokee_config_node_convert_list (cherokee_config_node_t *conf, const char *key, list_t *list)
  506 +cherokee_config_node_convert_list (cherokee_config_node_t *conf, const char *key, cherokee_list_t *list)
508 507 {
509 508 return cherokee_config_node_read_list (conf, key, convert_to_list_step, list);
510 509 }
6 cherokee/config_node.h
@@ -36,8 +36,8 @@
36 36 CHEROKEE_BEGIN_DECLS
37 37
38 38 typedef struct {
39   - list_t entry;
40   - list_t child;
  39 + cherokee_list_t entry;
  40 + cherokee_list_t child;
41 41
42 42 cherokee_buffer_t key;
43 43 cherokee_buffer_t val;
@@ -76,7 +76,7 @@ ret_t cherokee_config_node_read_int (cherokee_config_node_t *conf, const char
76 76 ret_t cherokee_config_node_read_list (cherokee_config_node_t *conf, const char *key,
77 77 cherokee_config_node_list_func_t func, void *param);
78 78
79   -ret_t cherokee_config_node_convert_list (cherokee_config_node_t *conf, const char *key, list_t *list);
  79 +ret_t cherokee_config_node_convert_list (cherokee_config_node_t *conf, const char *key, cherokee_list_t *list);
80 80
81 81 CHEROKEE_END_DECLS
82 82
2  cherokee/connection-protected.h
@@ -82,7 +82,7 @@ typedef enum {
82 82
83 83
84 84 struct cherokee_connection {
85   - list_t list_entry;
  85 + cherokee_list_t list_entry;
86 86
87 87 /* References
88 88 */
10 cherokee/connection_info.c
@@ -221,9 +221,9 @@ cherokee_connection_info_fill_up (cherokee_connection_info_t *info, cherokee_con
221 221
222 222
223 223 ret_t
224   -cherokee_connection_info_list_thread (list_t *list, void *_thread, cherokee_handler_t *self_handler)
  224 +cherokee_connection_info_list_thread (cherokee_list_t *list, void *_thread, cherokee_handler_t *self_handler)
225 225 {
226   - list_t *i;
  226 + cherokee_list_t *i;
227 227 cherokee_boolean_t locked = false;
228 228 cherokee_thread_t *thread = THREAD(_thread);
229 229
@@ -251,7 +251,7 @@ cherokee_connection_info_list_thread (list_t *list, void *_thread, cherokee_hand
251 251 CHEROKEE_NEW(n,connection_info);
252 252
253 253 cherokee_connection_info_fill_up (n, CONN(i));
254   - list_add ((list_t *)n, list);
  254 + list_add (LIST(n), list);
255 255 }
256 256
257 257 if (list_empty(list))
@@ -267,9 +267,9 @@ cherokee_connection_info_list_thread (list_t *list, void *_thread, cherokee_hand
267 267
268 268
269 269 ret_t
270   -cherokee_connection_info_list_server (list_t *list, cherokee_server_t *server, cherokee_handler_t *self)
  270 +cherokee_connection_info_list_server (cherokee_list_t *list, cherokee_server_t *server, cherokee_handler_t *self)
271 271 {
272   - list_t *i;
  272 + cherokee_list_t *i;
273 273
274 274 cherokee_connection_info_list_thread (list, server->main_thread, self);
275 275
6 cherokee/connection_info.h
@@ -40,7 +40,7 @@
40 40 CHEROKEE_BEGIN_DECLS
41 41
42 42 typedef struct {
43   - list_t list_entry;
  43 + cherokee_list_t list_entry;
44 44 cherokee_buffer_t id; /* ID */
45 45 cherokee_buffer_t phase; /* Current task */
46 46 cherokee_buffer_t request; /* Request string */
@@ -61,8 +61,8 @@ ret_t cherokee_connection_info_free (cherokee_connection_info_t *info);
61 61
62 62 ret_t cherokee_connection_info_fill_up (cherokee_connection_info_t *info, cherokee_connection_t *conn);
63 63
64   -ret_t cherokee_connection_info_list_thread (list_t *infos_list, void *thread, cherokee_handler_t *self);
65   -ret_t cherokee_connection_info_list_server (list_t *infos_list, cherokee_server_t *server, cherokee_handler_t *self);
  64 +ret_t cherokee_connection_info_list_thread (cherokee_list_t *infos_list, void *thread, cherokee_handler_t *self);
  65 +ret_t cherokee_connection_info_list_server (cherokee_list_t *infos_list, cherokee_server_t *server, cherokee_handler_t *self);
66 66
67 67 CHEROKEE_END_DECLS
68 68
26 cherokee/ext_source.c
@@ -36,7 +36,7 @@
36 36 static void
37 37 init_server (cherokee_ext_source_t *n)
38 38 {
39   - INIT_LIST_HEAD((list_t *)n);
  39 + INIT_LIST_HEAD (LIST(n));
40 40
41 41 cherokee_buffer_init (&n->interpreter);
42 42 cherokee_buffer_init (&n->host);
@@ -95,7 +95,7 @@ cherokee_ext_source_new (cherokee_ext_source_t **server)
95 95 CHEROKEE_NEW_STRUCT (n, ext_source);
96 96
97 97 init_server (n);
98   - n->free_func = (cherokee_typed_free_func_t) server_free;
  98 +// n->free_func = (cherokee_typed_free_func_t) server_free;
99 99
100 100 *server = n;
101 101 return ret_ok;
@@ -108,7 +108,7 @@ cherokee_ext_source_head_new (cherokee_ext_source_head_t **server)
108 108 CHEROKEE_NEW_STRUCT (n, ext_source_head);
109 109
110 110 init_server (EXT_SOURCE(n));
111   - EXT_SOURCE(n)->free_func = (cherokee_typed_free_func_t) server_head_free;
  111 +// EXT_SOURCE(n)->free_func = (cherokee_typed_free_func_t) server_head_free;
112 112
113 113 n->current_server = EXT_SOURCE(n);
114 114 CHEROKEE_MUTEX_INIT (&n->current_server_lock, NULL);
@@ -121,10 +121,10 @@ cherokee_ext_source_head_new (cherokee_ext_source_head_t **server)
121 121 ret_t
122 122 cherokee_ext_source_free (cherokee_ext_source_t *server)
123 123 {
124   - if (server->free_func == NULL)
  124 +// if (server->free_func == NULL)
125 125 return ret_error;
126 126
127   - server->free_func(server);
  127 +// server->free_func(server);
128 128 return ret_ok;
129 129 }
130 130
@@ -197,7 +197,7 @@ cherokee_ext_source_connect (cherokee_ext_source_t *src, cherokee_socket_t *sock
197 197
198 198
199 199 ret_t
200   -cherokee_ext_source_get_next (cherokee_ext_source_head_t *head_config, list_t *server_list, cherokee_ext_source_t **next)
  200 +cherokee_ext_source_get_next (cherokee_ext_source_head_t *head_config, cherokee_list_t *server_list, cherokee_ext_source_t **next)
201 201 {
202 202 cherokee_ext_source_t *current_config;
203 203
@@ -206,14 +206,14 @@ cherokee_ext_source_get_next (cherokee_ext_source_head_t *head_config, list_t *s
206 206 /* Set the next server
207 207 */
208 208 current_config = head_config->current_server;
209   - head_config->current_server = EXT_SOURCE(((list_t *)current_config)->next);
  209 + head_config->current_server = EXT_SOURCE(LIST(current_config)->next);
210 210
211 211 /* This is a special case: if the next is the base of the list, we have to
212 212 * skip the entry and point to the next one
213 213 */
214   - if ((list_t*)head_config->current_server == server_list) {
  214 + if (LIST(head_config->current_server) == server_list) {
215 215 current_config = head_config->current_server;
216   - head_config->current_server = EXT_SOURCE(((list_t *)current_config)->next);
  216 +// head_config->current_server = EXT_SOURCE((LIST(current_config)->next);
217 217 }
218 218
219 219 *next = head_config->current_server;
@@ -353,14 +353,14 @@ split_address_or_path (char *str, cherokee_buffer_t *hostname, cint_t *port_num,
353 353
354 354
355 355 ret_t
356   -cherokee_ext_source_configure (cherokee_config_node_t *conf, list_t *ext_list)
  356 +cherokee_ext_source_configure (cherokee_config_node_t *conf, cherokee_list_t *ext_list)
357 357 {
358 358 ret_t ret;
359 359 cherokee_config_node_t *child;
360 360 cherokee_config_node_t *child2;
361 361 cherokee_config_node_t *child3;
362   - list_t *i, *j, *k;
363   - list_t nlist = LIST_HEAD_INIT(nlist);
  362 + cherokee_list_t *i, *j, *k;
  363 + cherokee_list_t nlist = LIST_HEAD_INIT(nlist);
364 364 cherokee_ext_source_t *server_entry = NULL;
365 365 cherokee_ext_source_head_t *head = NULL;
366 366
@@ -383,7 +383,7 @@ cherokee_ext_source_configure (cherokee_config_node_t *conf, list_t *ext_list)
383 383
384 384 /* Add the entry to the list
385 385 */
386   - list_add_tail ((list_t *)server_entry, ext_list);
  386 + list_add_tail (LIST(server_entry), ext_list);
387 387
388 388 /* Parse properties
389 389 */
9 cherokee/ext_source.h
@@ -27,7 +27,6 @@
27 27
28 28 #include "list.h"
29 29 #include "buffer.h"
30   -#include "typed_table.h"
31 30 #include "socket.h"
32 31 #include "config_node.h"
33 32
@@ -35,7 +34,7 @@
35 34 CHEROKEE_BEGIN_DECLS
36 35
37 36 typedef struct {
38   - list_t entry;
  37 + cherokee_list_t entry;
39 38
40 39 cherokee_buffer_t interpreter;
41 40
@@ -47,7 +46,7 @@ typedef struct {
47 46 char **custom_env;
48 47 cuint_t custom_env_len;
49 48
50   - cherokee_typed_free_func_t free_func;
  49 +// cherokee_typed_free_func_t free_func;
51 50 } cherokee_ext_source_t;
52 51
53 52
@@ -79,11 +78,11 @@ ret_t cherokee_ext_source_spawn_srv (cherokee_ext_source_t *server);
79 78 /* External source head
80 79 */
81 80 ret_t cherokee_ext_source_head_new (cherokee_ext_source_head_t **serverf);
82   -ret_t cherokee_ext_source_get_next (cherokee_ext_source_head_t *serverf, list_t *server_list, cherokee_ext_source_t **next);
  81 +ret_t cherokee_ext_source_get_next (cherokee_ext_source_head_t *serverf, cherokee_list_t *server_list, cherokee_ext_source_t **next);
83 82
84 83 /* Configure
85 84 */
86   -ret_t cherokee_ext_source_configure (cherokee_config_node_t *conf, list_t *ext_list);
  85 +ret_t cherokee_ext_source_configure (cherokee_config_node_t *conf, cherokee_list_t *ext_list);
87 86
88 87
89 88 CHEROKEE_END_DECLS
5 cherokee/exts_table.c
@@ -23,7 +23,6 @@
23 23 */
24 24
25 25 #include "exts_table.h"
26   -#include "list_ext.h"
27 26 #include "table.h"
28 27
29 28 #define ENTRIES "exts"
@@ -31,7 +30,7 @@
31 30
32 31 struct cherokee_exts_table {
33 32 cherokee_table_t table;
34   - list_t list;
  33 + cherokee_list_t list;
35 34 };
36 35
37 36 ret_t
@@ -84,7 +83,7 @@ cherokee_exts_table_get (cherokee_exts_table_t *et, cherokee_buffer_t *requested
84 83 ret_t
85 84 cherokee_exts_table_add (cherokee_exts_table_t *et, char *ext, cherokee_config_entry_t *plugin_entry)
86 85 {
87   - list_t *i;
  86 + cherokee_list_t *i;
88 87 cherokee_boolean_t found = false;
89 88
90 89 /* Each plugin entry has to be added to the list only once
10 cherokee/fcgi_dispatcher.c
@@ -67,8 +67,8 @@ cherokee_fcgi_dispatcher_new (cherokee_fcgi_dispatcher_t **fcgi,
67 67 ret_t
68 68 cherokee_fcgi_dispatcher_free (cherokee_fcgi_dispatcher_t *fcgi)
69 69 {
70   - cuint_t i;
71   - list_t *l, *tmp;
  70 + cuint_t i;
  71 + cherokee_list_t *l, *tmp;
72 72
73 73 CHEROKEE_MUTEX_DESTROY(&fcgi->lock);
74 74
@@ -79,7 +79,7 @@ cherokee_fcgi_dispatcher_free (cherokee_fcgi_dispatcher_t *fcgi)
79 79 list_for_each_safe (l, tmp, &fcgi->queue) {
80 80 cherokee_connection_t *conn = HANDLER_CONN(l);
81 81
82   - list_del ((list_t *)conn);
  82 + list_del (LIST(conn));
83 83 cherokee_thread_inject_active_connection (HANDLER_THREAD(l), conn);
84 84 }
85 85
@@ -174,7 +174,7 @@ cherokee_fcgi_dispatcher_dispatch (cherokee_fcgi_dispatcher_t *fcgi,
174 174 ret_t
175 175 cherokee_fcgi_dispatcher_end_notif (cherokee_fcgi_dispatcher_t *fcgi)
176 176 {
177   - list_t *i;
  177 + cherokee_list_t *i;
178 178
179 179 if (list_empty (&fcgi->queue))
180 180 return ret_ok;
@@ -189,6 +189,6 @@ cherokee_fcgi_dispatcher_end_notif (cherokee_fcgi_dispatcher_t *fcgi)
189 189 ret_t
190 190 cherokee_fcgi_dispatcher_queue_conn (cherokee_fcgi_dispatcher_t *fcgi, cherokee_connection_t *conn)
191 191 {
192   - list_add_tail ((list_t *)conn, &fcgi->queue);
  192 + list_add_tail (LIST(conn), &fcgi->queue);
193 193 return ret_ok;
194 194 }
2  cherokee/fcgi_dispatcher.h
@@ -36,7 +36,7 @@ typedef struct {
36 36 cherokee_fcgi_manager_t *manager;
37 37 cuint_t manager_num;
38 38
39   - list_t queue;
  39 + cherokee_list_t queue;
40 40 cherokee_thread_t *thread;
41 41
42 42 #ifdef HAVE_PTHREAD
1  cherokee/handler_cgi.c
@@ -54,7 +54,6 @@
54 54 #include "server-protected.h"
55 55 #include "header.h"
56 56 #include "header-protected.h"
57   -#include "list_ext.h"
58 57 #include "post.h"
59 58
60 59
12 cherokee/handler_cgi_base.c
@@ -25,9 +25,7 @@
25 25 #include "common-internal.h"
26 26 #include "handler_cgi_base.h"
27 27
28   -#include "typed_table.h"
29 28 #include "socket.h"
30   -#include "list_ext.h"
31 29 #include "util.h"
32 30
33 31 #include "connection-protected.h"
@@ -93,7 +91,7 @@ cherokee_handler_cgi_base_init (cherokee_handler_cgi_base_t *cgi,
93 91
94 92
95 93 typedef struct {
96   - list_t entry;
  94 + cherokee_list_t entry;
97 95 cherokee_buffer_t env;
98 96 cherokee_buffer_t val;
99 97 } env_item_t;
@@ -127,7 +125,7 @@ env_item_free (void *p)
127 125 ret_t
128 126 cherokee_handler_cgi_base_props_free (cherokee_handler_cgi_base_props_t *props)
129 127 {
130   - list_t *i, *tmp;
  128 + cherokee_list_t *i, *tmp;
131 129
132 130 cherokee_buffer_mrproper (&props->script_alias);
133 131
@@ -142,7 +140,7 @@ ret_t
142 140 cherokee_handler_cgi_base_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
143 141 {
144 142 ret_t ret;
145   - list_t *i, *j;
  143 + cherokee_list_t *i, *j;
146 144 cherokee_handler_cgi_base_props_t *props;
147 145
148 146 /* Sanity check: This class is pure virtual, it shouldn't allocate memory here.
@@ -181,7 +179,7 @@ cherokee_handler_cgi_base_configure (cherokee_config_node_t *conf, cherokee_serv
181 179 env = env_item_new (&subconf2->key, &subconf2->val);
182 180 if (env == NULL) return ret_error;
183 181
184   - list_add_tail ((list_t *)env, &props->system_env);
  182 + list_add_tail (LIST(env), &props->system_env);
185 183 }
186 184 } else if (equal_buf_str (&subconf->key, "error_handler")) {
187 185 props->is_error_handler = atoi(subconf->val.buf);
@@ -416,7 +414,7 @@ ret_t
416 414 cherokee_handler_cgi_base_build_envp (cherokee_handler_cgi_base_t *cgi, cherokee_connection_t *conn)
417 415 {
418 416 ret_t ret;
419   - list_t *i;
  417 + cherokee_list_t *i;
420 418 cherokee_buffer_t *name;
421 419 cuint_t len = 0;
422 420 char *p = "";
2  cherokee/handler_cgi_base.h
@@ -50,7 +50,7 @@ typedef enum {
50 50
51 51 typedef struct {
52 52 cherokee_handler_props_t base;
53   - list_t system_env;
  53 + cherokee_list_t system_env;
54 54 cuint_t change_user;
55 55 cherokee_buffer_t script_alias;
56 56 cherokee_boolean_t check_file;
3  cherokee/handler_common.c
@@ -44,7 +44,6 @@
44 44 #include "server-protected.h"
45 45 #include "module.h"
46 46 #include "connection.h"
47   -#include "list_ext.h"
48 47
49 48 #define ENTRIES "handler,common"
50 49
@@ -230,7 +229,7 @@ cherokee_handler_common_new (cherokee_handler_t **hdl, void *cnt, cherokee_handl
230 229 /* Is it a directory
231 230 */
232 231 if (S_ISDIR(info->st_mode)) {
233   - list_t *i;
  232 + cherokee_list_t *i;
234 233
235 234 cherokee_iocache_mmap_release (iocache, file);
236 235
29 cherokee/handler_dirlist.c
@@ -48,13 +48,12 @@
48 48 #include "module_loader.h"
49 49 #include "icons.h"
50 50 #include "common.h"
51   -#include "list_ext.h"
52 51
53 52 #define DEFAULT_NAME_LEN 40
54 53
55 54
56 55 struct file_entry {
57   - list_t list_entry;
  56 + cherokee_list_t list_entry;
58 57 struct stat stat;
59 58 cuint_t name_len;
60 59 struct dirent info; /* It *must* be the last entry */
@@ -163,7 +162,7 @@ ret_t
163 162 cherokee_handler_dirlist_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
164 163 {
165 164 ret_t ret;
166   - list_t *i;
  165 + cherokee_list_t *i;
167 166 cherokee_handler_dirlist_props_t *props;
168 167 char *theme = NULL;
169 168 cherokee_buffer_t theme_path = CHEROKEE_BUF_INIT;
@@ -236,7 +235,7 @@ cherokee_handler_dirlist_configure (cherokee_config_node_t *conf, cherokee_serve
236 235 static cherokee_boolean_t
237 236 is_header_file (cherokee_handler_dirlist_t *dhdl, char *filename)
238 237 {
239   - list_t *i;
  238 + cherokee_list_t *i;
240 239
241 240 list_for_each (i, &HDL_DIRLIST_PROP(dhdl)->notice_files)
242 241 {
@@ -403,7 +402,7 @@ cherokee_handler_dirlist_new (cherokee_handler_t **hdl, void *cnt, cherokee_han
403 402 ret_t
404 403 cherokee_handler_dirlist_free (cherokee_handler_dirlist_t *dhdl)
405 404 {
406   - list_t *i, *tmp;
  405 + cherokee_list_t *i, *tmp;
407 406
408 407 cherokee_buffer_mrproper (&dhdl->header);
409 408 cherokee_buffer_mrproper (&dhdl->public_dir);
@@ -450,7 +449,7 @@ check_request_finish_with_slash (cherokee_handler_dirlist_t *dhdl)
450 449 }
451 450
452 451 static int
453   -cmp_name_down (list_t *a, list_t *b)
  452 +cmp_name_down (cherokee_list_t *a, cherokee_list_t *b)
454 453 {
455 454 file_entry_t *f1 = (file_entry_t *)a;
456 455 file_entry_t *f2 = (file_entry_t *)b;
@@ -460,7 +459,7 @@ cmp_name_down (list_t *a, list_t *b)
460 459
461 460
462 461 static int
463   -cmp_size_down (list_t *a, list_t *b)
  462 +cmp_size_down (cherokee_list_t *a, cherokee_list_t *b)
464 463 {
465 464 int diff;
466 465 file_entry_t *f1 = (file_entry_t *)a;
@@ -473,7 +472,7 @@ cmp_size_down (list_t *a, list_t *b)
473 472 }
474 473
475 474 static int
476   -cmp_date_down (list_t *a, list_t *b)
  475 +cmp_date_down (cherokee_list_t *a, cherokee_list_t *b)
477 476 {
478 477 int diff;
479 478 file_entry_t *f1 = (file_entry_t *)a;
@@ -486,25 +485,25 @@ cmp_date_down (list_t *a, list_t *b)
486 485 }
487 486
488 487 static int
489   -cmp_name_up (list_t *a, list_t *b)
  488 +cmp_name_up (cherokee_list_t *a, cherokee_list_t *b)
490 489 {
491 490 return -cmp_name_down(a,b);
492 491 }
493 492
494 493 static int
495   -cmp_size_up (list_t *a, list_t *b)
  494 +cmp_size_up (cherokee_list_t *a, cherokee_list_t *b)
496 495 {
497 496 return -cmp_size_down(a,b);
498 497 }
499 498
500 499 static int
501   -cmp_date_up (list_t *a, list_t *b)
  500 +cmp_date_up (cherokee_list_t *a, cherokee_list_t *b)
502 501 {
503 502 return -cmp_date_down(a,b);
504 503 }
505 504
506 505 static void
507   -list_sort_by_type (list_t *list, cherokee_dirlist_sort_t sort)
  506 +list_sort_by_type (cherokee_list_t *list, cherokee_dirlist_sort_t sort)
508 507 {
509 508 switch (sort) {
510 509 case Name_Down:
@@ -559,9 +558,9 @@ build_file_list (cherokee_handler_dirlist_t *dhdl)
559 558 continue;
560 559
561 560 if (S_ISDIR(item->stat.st_mode)) {
562   - list_add ((list_t *)item, &dhdl->dirs);
  561 + list_add (LIST(item), &dhdl->dirs);
563 562 } else {
564   - list_add ((list_t *)item, &dhdl->files);
  563 + list_add (LIST(item), &dhdl->files);
565 564 }
566 565 }
567 566
@@ -619,7 +618,7 @@ static ret_t
619 618 read_notice_file (cherokee_handler_dirlist_t *dhdl)
620 619 {
621 620 ret_t ret;
622   - list_t *i;
  621 + cherokee_list_t *i;
623 622 cherokee_connection_t *conn = HANDLER_CONN(dhdl);
624 623
625 624 list_for_each (i, &HDL_DIRLIST_PROP(dhdl)->notice_files) {
10 cherokee/handler_dirlist.h
@@ -55,7 +55,7 @@ typedef enum {
55 55 typedef struct {
56 56 cherokee_handler_props_t props;
57 57
58   - list_t notice_files;
  58 + cherokee_list_t notice_files;
59 59
60 60 /* Visible properties
61 61 */
@@ -78,8 +78,8 @@ typedef struct {
78 78
79 79 /* File list
80 80 */
81   - list_t dirs;
82   - list_t files;
  81 + cherokee_list_t dirs;
  82 + cherokee_list_t files;
83 83
84 84 /* State
85 85 */
@@ -89,8 +89,8 @@ typedef struct {
89 89 /* State
90 90 */
91 91 cuint_t longest_filename;
92   - list_t *dir_ptr;
93   - list_t *file_ptr;
  92 + cherokee_list_t *dir_ptr;
  93 + cherokee_list_t *file_ptr;
94 94 cherokee_buffer_t header;
95 95 cherokee_boolean_t serve_css;
96 96
8 cherokee/handler_error_redir.c
@@ -33,7 +33,7 @@
33 33
34 34
35 35 typedef struct {
36   - list_t entry;
  36 + cherokee_list_t entry;
37 37 cuint_t error;
38 38 cherokee_buffer_t url;
39 39 } error_entry_t;
@@ -42,7 +42,7 @@ typedef struct {
42 42 static ret_t
43 43 props_free (cherokee_handler_error_redir_props_t *props)
44 44 {
45   - list_t *i, *j;
  45 + cherokee_list_t *i, *j;
46 46
47 47 list_for_each_safe (i, j, &props->errors) {
48 48 error_entry_t *entry = (error_entry_t *)i;
@@ -57,7 +57,7 @@ props_free (cherokee_handler_error_redir_props_t *props)
57 57 ret_t
58 58 cherokee_handler_error_redir_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
59 59 {
60   - list_t *i;
  60 + cherokee_list_t *i;
61 61 cherokee_handler_error_redir_props_t *props;
62 62
63 63 if (*_props == NULL) {
@@ -103,7 +103,7 @@ cherokee_handler_error_redir_configure (cherokee_config_node_t *conf, cherokee_s
103 103 ret_t
104 104 cherokee_handler_error_redir_new (cherokee_handler_t **hdl, cherokee_connection_t *conn, cherokee_handler_props_t *props)
105 105 {
106   - list_t *i;
  106 + cherokee_list_t *i;
107 107
108 108 list_for_each (i, &PROP_ERREDIR(props)->errors) {
109 109 error_entry_t *entry = (error_entry_t *)i;
2  cherokee/handler_error_redir.h
@@ -38,7 +38,7 @@ typedef struct {
38 38
39 39 typedef struct {
40 40 cherokee_handler_props_t base;
41   - list_t errors;
  41 + cherokee_list_t errors;
42 42 } cherokee_handler_error_redir_props_t;
43 43
44 44 #define ERREDIR_HANDLER(x) ((cherokee_handler_error_redir_t *)(x))
2  cherokee/handler_fastcgi.c
@@ -50,7 +50,7 @@ static ret_t
50 50 cherokee_handler_fastcgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
51 51 {
52 52 ret_t ret;
53   - list_t *i, *j;
  53 + cherokee_list_t *i, *j;
54 54 cherokee_handler_fastcgi_props_t *props;
55 55
56 56 /* Instance a new property object
4 cherokee/handler_fastcgi.h
@@ -57,8 +57,8 @@ typedef enum {
57 57 typedef struct {
58 58 cherokee_handler_cgi_base_t base;
59 59
60   - list_t server_list;
61   - list_t fastcgi_env_ref;
  60 + cherokee_list_t server_list;
  61 + cherokee_list_t fastcgi_env_ref;
62 62
63 63 cuint_t nsockets;
64 64 cuint_t nkeepalive;
4 cherokee/handler_fcgi.c
@@ -197,7 +197,7 @@ read_from_fcgi (cherokee_handler_cgi_base_t *cgi, cherokee_buffer_t *buffer)
197 197 static ret_t
198 198 props_free (cherokee_handler_fcgi_props_t *props)
199 199 {
200   - list_t *i, *tmp;
  200 + cherokee_list_t *i, *tmp;
201 201
202 202 list_for_each_safe (i, tmp, &props->server_list) {
203 203 cherokee_ext_source_free (EXT_SOURCE(i));
@@ -211,7 +211,7 @@ static ret_t
211 211 cherokee_handler_fcgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
212 212 {
213 213 ret_t ret;
214   - list_t *i;
  214 + cherokee_list_t *i;
215 215 cherokee_handler_fcgi_props_t *props;
216 216
217 217 /* Instance a new property object
2  cherokee/handler_fcgi.h
@@ -44,7 +44,7 @@ typedef enum {
44 44
45 45 typedef struct {
46 46 cherokee_handler_cgi_base_t base;
47   - list_t server_list;
  47 + cherokee_list_t server_list;
48 48 } cherokee_handler_fcgi_props_t;
49 49
50 50 typedef struct {
2  cherokee/handler_file.c
@@ -54,7 +54,7 @@ cherokee_handler_file_props_free (cherokee_handler_file_props_t *props)
54 54 ret_t
55 55 cherokee_handler_file_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
56 56 {
57   - list_t *i;
  57 + cherokee_list_t *i;
58 58 cherokee_handler_file_props_t *props;
59 59
60 60 if (*_props == NULL) {
2  cherokee/handler_phpcgi.c
@@ -215,7 +215,7 @@ props_free (cherokee_handler_phpcgi_props_t *props)
215 215 static ret_t
216 216 cherokee_handler_phpcgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
217 217 {
218   - list_t *i;
  218 + cherokee_list_t *i;
219 219 cherokee_handler_phpcgi_props_t *props;
220 220
221 221 if (*_props == NULL) {
2  cherokee/handler_proxy.c
@@ -75,7 +75,7 @@ load_balancer (cherokee_server_t *srv, cherokee_buffer_t *name, cherokee_config_
75 75 ret_t
76 76 cherokee_handler_proxy_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
77 77 {
78   - list_t *i;
  78 + cherokee_list_t *i;
79 79 cherokee_handler_proxy_props_t *props;
80 80
81 81 if (*_props == NULL) {
11 cherokee/handler_redir.c
@@ -32,7 +32,6 @@
32 32 #include "pcre/pcre.h"
33 33 #include "regex.h"
34 34 #include "util.h"
35   -#include "list_ext.h"
36 35
37 36 #define ENTRIES "handler,redir"
38 37
@@ -40,7 +39,7 @@
40 39 #ifndef CHEROKEE_EMBEDDED
41 40
42 41 struct cre_list {
43   - list_t item;
  42 + cherokee_list_t item;
44 43 pcre *re;
45 44 char hidden;
46 45 cherokee_buffer_t subs;
@@ -91,7 +90,7 @@ substitute_groups (cherokee_buffer_t *url, const char *subject,
91 90 static ret_t
92 91 match_and_substitute (cherokee_handler_redir_t *n)
93 92 {
94   - list_t *i;
  93 + cherokee_list_t *i;
95 94 ret_t ret;
96 95 cherokee_connection_t *conn = HANDLER_CONN(n);
97 96
@@ -336,7 +335,7 @@ configure_rewrite (cherokee_config_node_t *conf, cherokee_server_t *srv, cheroke
336 335
337 336 /* Add the list
338 337 */
339   - list_add_tail ((list_t *)n, &props->regex_list);
  338 + list_add_tail (LIST(n), &props->regex_list);
340 339
341 340 return ret_ok;
342 341 }
@@ -353,7 +352,7 @@ cre_entry_free (struct cre_list *n)
353 352 static ret_t
354 353 props_free (cherokee_handler_redir_props_t *props)
355 354 {
356   - list_t *i, *tmp;
  355 + cherokee_list_t *i, *tmp;
357 356
358 357 cherokee_buffer_mrproper (&props->url);
359 358
@@ -369,7 +368,7 @@ static ret_t
369 368 cherokee_handler_redir_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
370 369 {
371 370 ret_t ret;
372   - list_t *i, *j;
  371 + cherokee_list_t *i, *j;
373 372 cherokee_handler_redir_props_t *props;
374 373
375 374 if (*_props == NULL) {
2  cherokee/handler_redir.h
@@ -36,7 +36,7 @@
36 36 typedef struct {
37 37 cherokee_handler_props_t base;
38 38 cherokee_buffer_t url;
39   - list_t regex_list;
  39 + cherokee_list_t regex_list;
40 40 } cherokee_handler_redir_props_t;
41 41
42 42 typedef struct {
4 cherokee/handler_scgi.c
@@ -40,7 +40,7 @@
40 40 static ret_t
41 41 props_free (cherokee_handler_scgi_props_t *props)
42 42 {
43   - list_t *i, *tmp;
  43 + cherokee_list_t *i, *tmp;
44 44
45 45 list_for_each_safe (i, tmp, &props->server_list) {
46 46 cherokee_ext_source_free (EXT_SOURCE(i));
@@ -55,7 +55,7 @@ static ret_t
55 55 cherokee_handler_scgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
56 56 {
57 57 ret_t ret;
58   - list_t *i;
  58 + cherokee_list_t *i;
59 59 cherokee_handler_scgi_props_t *props;
60 60
61 61 /* Instance a new property object
4 cherokee/handler_scgi.h
@@ -36,8 +36,8 @@
36 36
37 37 typedef struct {
38 38 cherokee_handler_cgi_base_t base;
39   - list_t scgi_env_ref;
40   - list_t server_list;
  39 + cherokee_list_t scgi_env_ref;
  40 + cherokee_list_t server_list;
41 41 } cherokee_handler_scgi_props_t;
42 42
43 43
2  cherokee/handler_server_info.c
@@ -107,7 +107,7 @@ props_free (cherokee_handler_server_info_props_t *props)
107 107 ret_t
108 108 cherokee_handler_server_info_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props)
109 109 {
110   - list_t *i;
  110 + cherokee_list_t *i;
111 111 cherokee_handler_server_info_props_t *props;
112 112
113 113 if (*_props == NULL) {
1  cherokee/icons.c
@@ -25,7 +25,6 @@
25 25 #include "common-internal.h"
26 26
27 27 #include "icons.h"
28   -#include "list_ext.h"
29 28 #include "match.h"
30 29 #include "util.h"
31 30
8 cherokee/iocache.c
@@ -88,12 +88,12 @@ struct cherokee_iocache {
88 88 typedef struct {
89 89 cherokee_iocache_t *iocache;
90 90 float average;
91   - list_t to_delete;
  91 + cherokee_list_t to_delete;