aniani/icecast-common
1
0
Fork 0
mirror of https://gitlab.xiph.org/xiph/icecast-common.git synced 2024-12-04 14:46:31 -05:00
Code

Update: Added "igloo_" to all experted symbols

Browse Source
This commit is contained in:
Philipp Schafft 2018-10-12 10:55:24 +00:00
parent f2efba644c
commit 5cc52a7b3d
20 changed files with 723 additions and 723 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
avl/avl.c
View File

@ -40,7 +40,7 @@
#include "avl.h" #include "avl.h"
avl_node * avl_node *
avl_node_new (void * key, igloo_avl_node_new (void * key,
avl_node * parent) avl_node * parent)
{ {
avl_node * node = (avl_node *) malloc (sizeof (avl_node)); avl_node * node = (avl_node *) malloc (sizeof (avl_node));
@ -63,7 +63,7 @@ avl_node_new (void * key,
} }
avl_tree * avl_tree *
avl_tree_new (avl_key_compare_fun_type compare_fun, igloo_avl_tree_new (avl_key_compare_fun_type compare_fun,
void * compare_arg) void * compare_arg)
{ {
avl_tree * t = (avl_tree *) malloc (sizeof (avl_tree)); avl_tree * t = (avl_tree *) malloc (sizeof (avl_tree));
@ -71,7 +71,7 @@ avl_tree_new (avl_key_compare_fun_type compare_fun,
if (!t) { if (!t) {
return NULL; return NULL;
} else { } else {
avl_node * root = avl_node_new((void *)NULL, (avl_node *) NULL); avl_node * root = igloo_avl_node_new((void *)NULL, (avl_node *) NULL);
if (!root) { if (!root) {
free (t); free (t);
return NULL; return NULL;
@ -88,44 +88,44 @@ avl_tree_new (avl_key_compare_fun_type compare_fun,
} }
static void static void
avl_tree_free_helper (avl_node * node, avl_free_key_fun_type free_key_fun) igloo_avl_tree_free_helper (avl_node * node, avl_free_key_fun_type free_key_fun)
{ {
if (node->left) { if (node->left) {
avl_tree_free_helper (node->left, free_key_fun); igloo_avl_tree_free_helper (node->left, free_key_fun);
} }
if (free_key_fun) if (free_key_fun)
free_key_fun (node->key); free_key_fun (node->key);
if (node->right) { if (node->right) {
avl_tree_free_helper (node->right, free_key_fun); igloo_avl_tree_free_helper (node->right, free_key_fun);
} }
#ifdef HAVE_AVL_NODE_LOCK #ifdef HAVE_AVL_NODE_LOCK
thread_rwlock_destroy (&node->rwlock); igloo_thread_rwlock_destroy (&node->rwlock);
#endif #endif
free (node); free (node);
} }
void void
avl_tree_free (avl_tree * tree, avl_free_key_fun_type free_key_fun) igloo_avl_tree_free (avl_tree * tree, avl_free_key_fun_type free_key_fun)
{ {
if (tree->length) { if (tree->length) {
avl_tree_free_helper (tree->root->right, free_key_fun); igloo_avl_tree_free_helper (tree->root->right, free_key_fun);
} }
if (tree->root) { if (tree->root) {
#ifdef HAVE_AVL_NODE_LOCK #ifdef HAVE_AVL_NODE_LOCK
thread_rwlock_destroy(&tree->root->rwlock); igloo_thread_rwlock_destroy(&tree->root->rwlock);
#endif #endif
free (tree->root); free (tree->root);
} }
thread_rwlock_destroy(&tree->rwlock); igloo_thread_rwlock_destroy(&tree->rwlock);
free (tree); free (tree);
} }
int int
avl_insert (avl_tree * ob, igloo_avl_insert (avl_tree * ob,
void * key) void * key)
{ {
if (!(ob->root->right)) { if (!(ob->root->right)) {
avl_node * node = avl_node_new (key, ob->root); avl_node * node = igloo_avl_node_new (key, ob->root);
if (!node) { if (!node) {
return -1; return -1;
} else { } else {
@ -147,7 +147,7 @@ avl_insert (avl_tree * ob,
q = p->left; q = p->left;
if (!q) { if (!q) {
/* insert */ /* insert */
avl_node * q_node = avl_node_new (key, p); avl_node * q_node = igloo_avl_node_new (key, p);
if (!q_node) { if (!q_node) {
return (-1); return (-1);
} else { } else {
@ -165,7 +165,7 @@ avl_insert (avl_tree * ob,
q = p->right; q = p->right;
if (!q) { if (!q) {
/* insert */ /* insert */
avl_node * q_node = avl_node_new (key, p); avl_node * q_node = igloo_avl_node_new (key, p);
if (!q_node) { if (!q_node) {
return -1; return -1;
} else { } else {
@ -297,7 +297,7 @@ avl_insert (avl_tree * ob,
} }
int int
avl_get_by_index (avl_tree * tree, igloo_avl_get_by_index (avl_tree * tree,
unsigned long index, unsigned long index,
void ** value_address) void ** value_address)
{ {
@ -320,7 +320,7 @@ avl_get_by_index (avl_tree * tree,
} }
int int
avl_get_by_key (avl_tree * tree, igloo_avl_get_by_key (avl_tree * tree,
void * key, void * key,
void **value_address) void **value_address)
{ {
@ -349,7 +349,7 @@ avl_get_by_key (avl_tree * tree,
} }
} }
int avl_delete(avl_tree *tree, void *key, avl_free_key_fun_type free_key_fun) int igloo_avl_delete(avl_tree *tree, void *key, avl_free_key_fun_type free_key_fun)
{ {
avl_node *x, *y, *p, *q, *r, *top, *x_child; avl_node *x, *y, *p, *q, *r, *top, *x_child;
int shortened_side, shorter; int shortened_side, shorter;
@ -458,7 +458,7 @@ int avl_delete(avl_tree *tree, void *key, avl_free_key_fun_type free_key_fun)
if (free_key_fun) if (free_key_fun)
free_key_fun (x->key); free_key_fun (x->key);
#ifdef HAVE_AVL_NODE_LOCK #ifdef HAVE_AVL_NODE_LOCK
thread_rwlock_destroy (&x->rwlock); igloo_thread_rwlock_destroy (&x->rwlock);
#endif #endif
free (x); free (x);
@ -625,13 +625,13 @@ int avl_delete(avl_tree *tree, void *key, avl_free_key_fun_type free_key_fun)
} }
static int static int
avl_iterate_inorder_helper (avl_node * node, igloo_avl_iterate_inorder_helper (avl_node * node,
avl_iter_fun_type iter_fun, avl_iter_fun_type iter_fun,
void * iter_arg) void * iter_arg)
{ {
int result; int result;
if (node->left) { if (node->left) {
result = avl_iterate_inorder_helper (node->left, iter_fun, iter_arg); result = igloo_avl_iterate_inorder_helper (node->left, iter_fun, iter_arg);
if (result != 0) { if (result != 0) {
return result; return result;
} }
@ -641,7 +641,7 @@ avl_iterate_inorder_helper (avl_node * node,
return result; return result;
} }
if (node->right) { if (node->right) {
result = avl_iterate_inorder_helper (node->right, iter_fun, iter_arg); result = igloo_avl_iterate_inorder_helper (node->right, iter_fun, iter_arg);
if (result != 0) { if (result != 0) {
return result; return result;
} }
@ -650,21 +650,21 @@ avl_iterate_inorder_helper (avl_node * node,
} }
int int
avl_iterate_inorder (avl_tree * tree, igloo_avl_iterate_inorder (avl_tree * tree,
avl_iter_fun_type iter_fun, avl_iter_fun_type iter_fun,
void * iter_arg) void * iter_arg)
{ {
int result; int result;
if (tree->length) { if (tree->length) {
result = avl_iterate_inorder_helper (tree->root->right, iter_fun, iter_arg); result = igloo_avl_iterate_inorder_helper (tree->root->right, iter_fun, iter_arg);
return (result); return (result);
} else { } else {
return 0; return 0;
} }
} }
avl_node *avl_get_first(avl_tree *tree) avl_node *igloo_avl_get_first(avl_tree *tree)
{ {
avl_node *node; avl_node *node;
@ -677,7 +677,7 @@ avl_node *avl_get_first(avl_tree *tree)
return node; return node;
} }
avl_node *avl_get_prev(avl_node *node) avl_node *igloo_avl_get_prev(avl_node *node)
{ {
if (node->left) { if (node->left) {
node = node->left; node = node->left;
@ -700,7 +700,7 @@ avl_node *avl_get_prev(avl_node *node)
} }
} }
avl_node *avl_get_next(avl_node *node) avl_node *igloo_avl_get_next(avl_node *node)
{ {
if (node->right) { if (node->right) {
node = node->right; node = node->right;
@ -726,7 +726,7 @@ avl_node *avl_get_next(avl_node *node)
/* iterate a function over a range of indices, using get_predecessor */ /* iterate a function over a range of indices, using get_predecessor */
int int
avl_iterate_index_range (avl_tree * tree, igloo_avl_iterate_index_range (avl_tree * tree,
avl_iter_index_fun_type iter_fun, avl_iter_index_fun_type iter_fun,
unsigned long low, unsigned long low,
unsigned long high, unsigned long high,
@ -759,7 +759,7 @@ avl_iterate_index_range (avl_tree * tree,
if (iter_fun (num_left, node->key, iter_arg) != 0) { if (iter_fun (num_left, node->key, iter_arg) != 0) {
return -1; return -1;
} }
node = avl_get_prev (node); node = igloo_avl_get_prev (node);
} }
return 0; return 0;
} }
@ -770,7 +770,7 @@ avl_iterate_index_range (avl_tree * tree,
*/ */
static avl_node * static avl_node *
avl_get_index_by_key (avl_tree * tree, igloo_avl_get_index_by_key (avl_tree * tree,
void * key, void * key,
unsigned long * index) unsigned long * index)
{ {
@ -811,7 +811,7 @@ avl_get_index_by_key (avl_tree * tree,
/* return the (low index, high index) pair that spans the given key */ /* return the (low index, high index) pair that spans the given key */
int int
avl_get_span_by_key (avl_tree * tree, igloo_avl_get_span_by_key (avl_tree * tree,
void * key, void * key,
unsigned long * low, unsigned long * low,
unsigned long * high) unsigned long * high)
@ -819,7 +819,7 @@ avl_get_span_by_key (avl_tree * tree,
unsigned long m, i, j; unsigned long m, i, j;
avl_node * node; avl_node * node;
node = avl_get_index_by_key (tree, key, &m); node = igloo_avl_get_index_by_key (tree, key, &m);
/* did we find an exact match? /* did we find an exact match?
* if so, we have to search left and right * if so, we have to search left and right
@ -829,17 +829,17 @@ avl_get_span_by_key (avl_tree * tree,
if (node) { if (node) {
avl_node * left, * right; avl_node * left, * right;
/* search left */ /* search left */
left = avl_get_prev (node); left = igloo_avl_get_prev (node);
i = m; i = m;
while (left && (i > 0) && (tree->compare_fun (tree->compare_arg, key, left->key) == 0)) { while (left && (i > 0) && (tree->compare_fun (tree->compare_arg, key, left->key) == 0)) {
left = avl_get_prev (left); left = igloo_avl_get_prev (left);
i = i - 1; i = i - 1;
} }
/* search right */ /* search right */
right = avl_get_next (node); right = igloo_avl_get_next (node);
j = m; j = m;
while (right && (j <= tree->length) && (tree->compare_fun (tree->compare_arg, key, right->key) == 0)) { while (right && (j <= tree->length) && (tree->compare_fun (tree->compare_arg, key, right->key) == 0)) {
right = avl_get_next (right); right = igloo_avl_get_next (right);
j = j + 1; j = j + 1;
} }
*low = i; *low = i;
@ -854,7 +854,7 @@ avl_get_span_by_key (avl_tree * tree,
/* return the (low index, high index) pair that spans the given key */ /* return the (low index, high index) pair that spans the given key */
int int
avl_get_span_by_two_keys (avl_tree * tree, igloo_avl_get_span_by_two_keys (avl_tree * tree,
void * low_key, void * low_key,
void * high_key, void * high_key,
unsigned long * low, unsigned long * low,
@ -872,15 +872,15 @@ avl_get_span_by_two_keys (avl_tree * tree,
high_key = temp; high_key = temp;
} }
low_node = avl_get_index_by_key (tree, low_key, &i); low_node = igloo_avl_get_index_by_key (tree, low_key, &i);
high_node = avl_get_index_by_key (tree, high_key, &j); high_node = igloo_avl_get_index_by_key (tree, high_key, &j);
if (low_node) { if (low_node) {
avl_node * left; avl_node * left;
/* search left */ /* search left */
left = avl_get_prev (low_node); left = igloo_avl_get_prev (low_node);
while (left && (i > 0) && (tree->compare_fun (tree->compare_arg, low_key, left->key) == 0)) { while (left && (i > 0) && (tree->compare_fun (tree->compare_arg, low_key, left->key) == 0)) {
left = avl_get_prev (left); left = igloo_avl_get_prev (left);
i = i - 1; i = i - 1;
} }
} else { } else {
@ -889,9 +889,9 @@ avl_get_span_by_two_keys (avl_tree * tree,
if (high_node) { if (high_node) {
avl_node * right; avl_node * right;
/* search right */ /* search right */
right = avl_get_next (high_node); right = igloo_avl_get_next (high_node);
while (right && (j <= tree->length) && (tree->compare_fun (tree->compare_arg, high_key, right->key) == 0)) { while (right && (j <= tree->length) && (tree->compare_fun (tree->compare_arg, high_key, right->key) == 0)) {
right = avl_get_next (right); right = igloo_avl_get_next (right);
j = j + 1; j = j + 1;
} }
} else { } else {
@ -905,7 +905,7 @@ avl_get_span_by_two_keys (avl_tree * tree,
int int
avl_get_item_by_key_most (avl_tree * tree, igloo_avl_get_item_by_key_most (avl_tree * tree,
void * key, void * key,
void **value_address) void **value_address)
{ {
@ -949,7 +949,7 @@ avl_get_item_by_key_most (avl_tree * tree,
} }
int int
avl_get_item_by_key_least (avl_tree * tree, igloo_avl_get_item_by_key_least (avl_tree * tree,
void * key, void * key,
void **value_address) void **value_address)
{ {
@ -993,13 +993,13 @@ avl_get_item_by_key_least (avl_tree * tree,
#define AVL_MAX(X, Y) ((X) > (Y) ? (X) : (Y)) #define AVL_MAX(X, Y) ((X) > (Y) ? (X) : (Y))
static long static long
avl_verify_balance (avl_node * node) igloo_avl_verify_balance (avl_node * node)
{ {
if (!node) { if (!node) {
return 0; return 0;
} else { } else {
long lh = avl_verify_balance (node->left); long lh = igloo_avl_verify_balance (node->left);
long rh = avl_verify_balance (node->right); long rh = igloo_avl_verify_balance (node->right);
if ((rh - lh) != AVL_GET_BALANCE(node)) { if ((rh - lh) != AVL_GET_BALANCE(node)) {
return 0; return 0;
} }
@ -1011,31 +1011,31 @@ avl_verify_balance (avl_node * node)
} }
static void static void
avl_verify_parent (avl_node * node, avl_node * parent) igloo_avl_verify_parent (avl_node * node, avl_node * parent)
{ {
if (node->parent != parent) { if (node->parent != parent) {
return; return;
} }
if (node->left) { if (node->left) {
avl_verify_parent (node->left, node); igloo_avl_verify_parent (node->left, node);
} }
if (node->right) { if (node->right) {
avl_verify_parent (node->right, node); igloo_avl_verify_parent (node->right, node);
} }
} }
static long static long
avl_verify_rank (avl_node * node) igloo_avl_verify_rank (avl_node * node)
{ {
if (!node) { if (!node) {
return 0; return 0;
} else { } else {
unsigned long num_left=0, num_right=0; unsigned long num_left=0, num_right=0;
if (node->left) { if (node->left) {
num_left = avl_verify_rank (node->left); num_left = igloo_avl_verify_rank (node->left);
} }
if (node->right) { if (node->right) {
num_right = avl_verify_rank (node->right); num_right = igloo_avl_verify_rank (node->right);
} }
if (AVL_GET_RANK (node) != num_left + 1) { if (AVL_GET_RANK (node) != num_left + 1) {
fprintf (stderr, "invalid rank at node %ld\n", (long) node->key); fprintf (stderr, "invalid rank at node %ld\n", (long) node->key);
@ -1048,12 +1048,12 @@ avl_verify_rank (avl_node * node)
/* sanity-check the tree */ /* sanity-check the tree */
int int
avl_verify (avl_tree * tree) igloo_avl_verify (avl_tree * tree)
{ {
if (tree->length) { if (tree->length) {
avl_verify_balance (tree->root->right); igloo_avl_verify_balance (tree->root->right);
avl_verify_parent (tree->root->right, tree->root); igloo_avl_verify_parent (tree->root->right, tree->root);
avl_verify_rank (tree->root->right); igloo_avl_verify_rank (tree->root->right);
} }
return (0); return (0);
} }
@ -1070,10 +1070,10 @@ typedef struct _link_node {
int width; int width;
} link_node; } link_node;
static char balance_chars[3] = {'\\', '-', '/'}; static char igloo_balance_chars[3] = {'\\', '-', '/'};
static int static int
default_key_printer (char * buffer, void * key) igloo_default_key_printer (char * buffer, void * key)
{ {
return snprintf (buffer, AVL_KEY_PRINTER_BUFLEN, "%p", key); return snprintf (buffer, AVL_KEY_PRINTER_BUFLEN, "%p", key);
} }
@ -1086,10 +1086,10 @@ default_key_printer (char * buffer, void * key)
*/ */
static void static void
print_connectors (link_node * link) igloo_print_connectors (link_node * link)
{ {
if (link->parent) { if (link->parent) {
print_connectors (link->parent); igloo_print_connectors (link->parent);
} }
if (link->parent && (link->parent->direction != link->direction) && (link->parent->parent)) { if (link->parent && (link->parent->direction != link->direction) && (link->parent->parent)) {
int i; int i;
@ -1113,7 +1113,7 @@ print_connectors (link_node * link)
*/ */
static void static void
print_node (avl_key_printer_fun_type key_printer, igloo_print_node (avl_key_printer_fun_type key_printer,
avl_node * node, avl_node * node,
link_node * link) link_node * link)
{ {
@ -1126,11 +1126,11 @@ print_node (avl_key_printer_fun_type key_printer,
here.parent = link; here.parent = link;
here.direction = 1; here.direction = 1;
here.width = width + 11; here.width = width + 11;
print_node (key_printer, node->right, &here); igloo_print_node (key_printer, node->right, &here);
} }
print_connectors (link); igloo_print_connectors (link);
fprintf (stdout, "+-[%c %s %03d]", fprintf (stdout, "+-[%c %s %03d]",
balance_chars[AVL_GET_BALANCE(node)+1], igloo_balance_chars[AVL_GET_BALANCE(node)+1],
buffer, buffer,
(int)AVL_GET_RANK(node)); (int)AVL_GET_RANK(node));
if (node->left || node->right) { if (node->left || node->right) {
@ -1143,36 +1143,36 @@ print_node (avl_key_printer_fun_type key_printer,
here.parent = link; here.parent = link;
here.direction = -1; here.direction = -1;
here.width = width + 11; here.width = width + 11;
print_node (key_printer, node->left, &here); igloo_print_node (key_printer, node->left, &here);
} }
} }
void void
avl_print_tree (avl_tree * tree, avl_key_printer_fun_type key_printer) igloo_avl_print_tree (avl_tree * tree, avl_key_printer_fun_type key_printer)
{ {
link_node top = {NULL, 0, 0}; link_node top = {NULL, 0, 0};
if (!key_printer) { if (!key_printer) {
key_printer = default_key_printer; key_printer = igloo_default_key_printer;
} }
if (tree->length) { if (tree->length) {
print_node (key_printer, tree->root->right, &top); igloo_print_node (key_printer, tree->root->right, &top);
} else { } else {
fprintf (stdout, "<empty tree>\n"); fprintf (stdout, "<empty tree>\n");
} }
} }
void avl_tree_rlock(avl_tree *tree) void igloo_avl_tree_rlock(avl_tree *tree)
{ {
thread_rwlock_rlock(&tree->rwlock); thread_rwlock_rlock(&tree->rwlock);
} }
void avl_tree_wlock(avl_tree *tree) void igloo_avl_tree_wlock(avl_tree *tree)
{ {
thread_rwlock_wlock(&tree->rwlock); thread_rwlock_wlock(&tree->rwlock);
} }
void avl_tree_unlock(avl_tree *tree) void igloo_avl_tree_unlock(avl_tree *tree)
{ {
thread_rwlock_unlock(&tree->rwlock); thread_rwlock_unlock(&tree->rwlock);
} }

44
avl/avl.h
View File

@ -18,7 +18,7 @@ extern "C" {
#include "thread/thread.h" #include "thread/thread.h"
#else #else
#define thread_rwlock_create(x) do{}while(0) #define thread_rwlock_create(x) do{}while(0)
#define thread_rwlock_destroy(x) do{}while(0) #define igloo_thread_rwlock_destroy(x) do{}while(0)
#define thread_rwlock_rlock(x) do{}while(0) #define thread_rwlock_rlock(x) do{}while(0)
#define thread_rwlock_wlock(x) do{}while(0) #define thread_rwlock_wlock(x) do{}while(0)
#define thread_rwlock_unlock(x) do{}while(0) #define thread_rwlock_unlock(x) do{}while(0)
@ -76,44 +76,44 @@ typedef struct _avl_tree {
#endif #endif
} avl_tree; } avl_tree;
avl_tree * avl_tree_new (avl_key_compare_fun_type compare_fun, void * compare_arg); avl_tree * igloo_avl_tree_new (avl_key_compare_fun_type compare_fun, void * compare_arg);
avl_node * avl_node_new (void * key, avl_node * parent); avl_node * igloo_avl_node_new (void * key, avl_node * parent);
void avl_tree_free ( void igloo_avl_tree_free (
avl_tree * tree, avl_tree * tree,
avl_free_key_fun_type free_key_fun avl_free_key_fun_type free_key_fun
); );
int avl_insert ( int igloo_avl_insert (
avl_tree * ob, avl_tree * ob,
void * key void * key
); );
int avl_delete ( int igloo_avl_delete (
avl_tree * tree, avl_tree * tree,
void * key, void * key,
avl_free_key_fun_type free_key_fun avl_free_key_fun_type free_key_fun
); );
int avl_get_by_index ( int igloo_avl_get_by_index (
avl_tree * tree, avl_tree * tree,
unsigned long index, unsigned long index,
void ** value_address void ** value_address
); );
int avl_get_by_key ( int igloo_avl_get_by_key (
avl_tree * tree, avl_tree * tree,
void * key, void * key,
void ** value_address void ** value_address
); );
int avl_iterate_inorder ( int igloo_avl_iterate_inorder (
avl_tree * tree, avl_tree * tree,
avl_iter_fun_type iter_fun, avl_iter_fun_type iter_fun,
void * iter_arg void * iter_arg
); );
int avl_iterate_index_range ( int igloo_avl_iterate_index_range (
avl_tree * tree, avl_tree * tree,
avl_iter_index_fun_type iter_fun, avl_iter_index_fun_type iter_fun,
unsigned long low, unsigned long low,
@ -121,14 +121,14 @@ int avl_iterate_index_range (
void * iter_arg void * iter_arg
); );
int avl_get_span_by_key ( int igloo_avl_get_span_by_key (
avl_tree * tree, avl_tree * tree,
void * key, void * key,
unsigned long * low, unsigned long * low,
unsigned long * high unsigned long * high
); );
int avl_get_span_by_two_keys ( int igloo_avl_get_span_by_two_keys (
avl_tree * tree, avl_tree * tree,
void * key_a, void * key_a,
void * key_b, void * key_b,
@ -136,37 +136,37 @@ int avl_get_span_by_two_keys (
unsigned long * high unsigned long * high
); );
int avl_verify (avl_tree * tree); int igloo_avl_verify (avl_tree * tree);
void avl_print_tree ( void igloo_avl_print_tree (
avl_tree * tree, avl_tree * tree,
avl_key_printer_fun_type key_printer avl_key_printer_fun_type key_printer
); );
avl_node *avl_get_first(avl_tree *tree); avl_node *igloo_avl_get_first(avl_tree *tree);
avl_node *avl_get_prev(avl_node * node); avl_node *igloo_avl_get_prev(avl_node * node);
avl_node *avl_get_next(avl_node * node); avl_node *igloo_avl_get_next(avl_node * node);
/* These two are from David Ascher <david_ascher@brown.edu> */ /* These two are from David Ascher <david_ascher@brown.edu> */
int avl_get_item_by_key_most ( int igloo_avl_get_item_by_key_most (
avl_tree * tree, avl_tree * tree,
void * key, void * key,
void ** value_address void ** value_address
); );
int avl_get_item_by_key_least ( int igloo_avl_get_item_by_key_least (
avl_tree * tree, avl_tree * tree,
void * key, void * key,
void ** value_address void ** value_address
); );
/* optional locking stuff */ /* optional locking stuff */
void avl_tree_rlock(avl_tree *tree); void igloo_avl_tree_rlock(avl_tree *tree);
void avl_tree_wlock(avl_tree *tree); void igloo_avl_tree_wlock(avl_tree *tree);
void avl_tree_unlock(avl_tree *tree); void igloo_avl_tree_unlock(avl_tree *tree);
void avl_node_rlock(avl_node *node); void avl_node_rlock(avl_node *node);
void avl_node_wlock(avl_node *node); void avl_node_wlock(avl_node *node);
void avl_node_unlock(avl_node *node); void avl_node_unlock(avl_node *node);

14
avl/test.c
View File

@ -25,21 +25,21 @@ int main(int argc, char **argv)
printf("avl test... max_nodes = %d...\n", max_nodes); printf("avl test... max_nodes = %d...\n", max_nodes);
tree = avl_tree_new(_compare, NULL); tree = igloo_avl_tree_new(_compare, NULL);
printf("Filling tree...\n"); printf("Filling tree...\n");
for (i = 0; i < max_nodes; i++) { for (i = 0; i < max_nodes; i++) {
avl_insert(tree, (void *)rand()); igloo_avl_insert(tree, (void *)rand());
} }
printf("Traversing tree...\n"); printf("Traversing tree...\n");
node = avl_get_first(tree); node = igloo_avl_get_first(tree);
while (node) { while (node) {
i = (int)node->key; i = (int)node->key;
printf("...%5d\n", i); printf("...%5d\n", i);
node = avl_get_next(node); node = igloo_avl_get_next(node);
} }
printf("Trying to go backwards...\n"); printf("Trying to go backwards...\n");
@ -47,13 +47,13 @@ int main(int argc, char **argv)
while (node) { while (node) {
i = (int)node->key; i = (int)node->key;
printf("...%5d\n", i); printf("...%5d\n", i);
node = avl_get_prev(node); node = igloo_avl_get_prev(node);
} }
printf("Printing tree...\n"); printf("Printing tree...\n");
avl_print_tree(tree, _printer); igloo_avl_print_tree(tree, _printer);
avl_tree_free(tree, _free); igloo_avl_tree_free(tree, _free);
return 0; return 0;
} }

70
httpp/encoding.c
View File

@ -62,13 +62,13 @@ struct httpp_encoding_tag {
/* Handlers, at end of file */ /* Handlers, at end of file */
static ssize_t __enc_identity_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata); static ssize_t igloo___enc_identity_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata);
static ssize_t __enc_identity_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata); static ssize_t igloo___enc_identity_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata);
static ssize_t __enc_chunked_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata); static ssize_t igloo___enc_chunked_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata);
static ssize_t __enc_chunked_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata); static ssize_t igloo___enc_chunked_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata);
/* function to move some data out of our buffers */ /* function to move some data out of our buffers */
ssize_t __copy_buffer(void *dst, void **src, size_t *boffset, size_t *blen, size_t len) ssize_t igloo___copy_buffer(void *dst, void **src, size_t *boffset, size_t *blen, size_t len)
{ {
void *p; void *p;
size_t have_len; size_t have_len;
@ -120,7 +120,7 @@ static inline void __flush_output(httpp_encoding_t *self, ssize_t (*cb)(void*, c
/* meta data functions */ /* meta data functions */
/* meta data is to be used in a encoding-specific way */ /* meta data is to be used in a encoding-specific way */
httpp_meta_t *httpp_encoding_meta_new(const char *key, const char *value) httpp_meta_t *igloo_httpp_encoding_meta_new(const char *key, const char *value)
{ {
httpp_meta_t *ret = calloc(1, sizeof(httpp_meta_t)); httpp_meta_t *ret = calloc(1, sizeof(httpp_meta_t));
if (!ret) if (!ret)
@ -138,11 +138,11 @@ httpp_meta_t *httpp_encoding_meta_new(const char *key, const char *value)
return ret; return ret;
fail: fail:
httpp_encoding_meta_free(ret); igloo_httpp_encoding_meta_free(ret);
return NULL; return NULL;
} }
int httpp_encoding_meta_free(httpp_meta_t *self) int igloo_httpp_encoding_meta_free(httpp_meta_t *self)
{ {
while (self) { while (self) {
httpp_meta_t *cur = self; httpp_meta_t *cur = self;
@ -158,7 +158,7 @@ int httpp_encoding_meta_free(httpp_meta_t *self)
return 0; return 0;
} }
int httpp_encoding_meta_append(httpp_meta_t **dst, httpp_meta_t *next) int igloo_httpp_encoding_meta_append(httpp_meta_t **dst, httpp_meta_t *next)
{ {
httpp_meta_t **cur; httpp_meta_t **cur;
@ -177,7 +177,7 @@ int httpp_encoding_meta_append(httpp_meta_t **dst, httpp_meta_t *n
} }
/* General setup */ /* General setup */
httpp_encoding_t *httpp_encoding_new(const char *encoding) { httpp_encoding_t *igloo_httpp_encoding_new(const char *encoding) {
httpp_encoding_t *ret = calloc(1, sizeof(httpp_encoding_t)); httpp_encoding_t *ret = calloc(1, sizeof(httpp_encoding_t));
if (!ret) if (!ret)
return NULL; return NULL;
@ -186,11 +186,11 @@ httpp_encoding_t *httpp_encoding_new(const char *encoding) {
ret->bytes_till_eof = -1; ret->bytes_till_eof = -1;
if (strcasecmp(encoding, HTTPP_ENCODING_IDENTITY) == 0) { if (strcasecmp(encoding, HTTPP_ENCODING_IDENTITY) == 0) {
ret->process_read = __enc_identity_read; ret->process_read = igloo___enc_identity_read;
ret->process_write = __enc_identity_write; ret->process_write = igloo___enc_identity_write;
} else if (strcasecmp(encoding, HTTPP_ENCODING_CHUNKED) == 0) { } else if (strcasecmp(encoding, HTTPP_ENCODING_CHUNKED) == 0) {
ret->process_read = __enc_chunked_read; ret->process_read = igloo___enc_chunked_read;
ret->process_write = __enc_chunked_write; ret->process_write = igloo___enc_chunked_write;
} else { } else {
goto fail; goto fail;
} }
@ -198,11 +198,11 @@ httpp_encoding_t *httpp_encoding_new(const char *encoding) {
return ret; return ret;
fail: fail:
httpp_encoding_release(ret); igloo_httpp_encoding_release(ret);
return NULL; return NULL;
} }
int httpp_encoding_addref(httpp_encoding_t *self) int igloo_httpp_encoding_addref(httpp_encoding_t *self)
{ {
if (!self) if (!self)
return -1; return -1;
@ -210,7 +210,7 @@ int httpp_encoding_addref(httpp_encoding_t *self)
return 0; return 0;
} }
int httpp_encoding_release(httpp_encoding_t *self) int igloo_httpp_encoding_release(httpp_encoding_t *self)
{ {
if (!self) if (!self)
return -1; return -1;
@ -219,8 +219,8 @@ int httpp_encoding_release(httpp_encoding_t *self)
if (self->refc) if (self->refc)
return 0; return 0;
httpp_encoding_meta_free(self->meta_read); igloo_httpp_encoding_meta_free(self->meta_read);
httpp_encoding_meta_free(self->meta_write); igloo_httpp_encoding_meta_free(self->meta_write);
if (self->buf_read_raw) if (self->buf_read_raw)
free(self->buf_read_raw); free(self->buf_read_raw);
@ -237,7 +237,7 @@ int httpp_encoding_release(httpp_encoding_t *self)
/* Read data from backend. /* Read data from backend.
* if cb is NULL this will read from the internal buffer. * if cb is NULL this will read from the internal buffer.
*/ */
ssize_t httpp_encoding_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata) ssize_t igloo_httpp_encoding_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata)
{ {
ssize_t done = 0; ssize_t done = 0;
ssize_t ret; ssize_t ret;
@ -248,7 +248,7 @@ ssize_t httpp_encoding_read(httpp_encoding_t *self, void *buf, size_t
if (!len) if (!len)
return 0; return 0;
ret = __copy_buffer(buf, &(self->buf_read_decoded), &(self->buf_read_decoded_offset), &(self->buf_read_decoded_len), len); ret = igloo___copy_buffer(buf, &(self->buf_read_decoded), &(self->buf_read_decoded_offset), &(self->buf_read_decoded_len), len);
if (ret == (ssize_t)len) if (ret == (ssize_t)len)
return ret; return ret;
@ -270,7 +270,7 @@ ssize_t httpp_encoding_read(httpp_encoding_t *self, void *buf, size_t
len -= ret; len -= ret;
if (len) { if (len) {
ret = __copy_buffer(buf, &(self->buf_read_decoded), &(self->buf_read_decoded_offset), &(self->buf_read_decoded_len), len); ret = igloo___copy_buffer(buf, &(self->buf_read_decoded), &(self->buf_read_decoded_offset), &(self->buf_read_decoded_len), len);
if (ret > 0) { if (ret > 0) {
done += ret; done += ret;
buf += ret; buf += ret;
@ -281,7 +281,7 @@ ssize_t httpp_encoding_read(httpp_encoding_t *self, void *buf, size_t
return done; return done;
} }
int httpp_encoding_eof(httpp_encoding_t *self, int (*cb)(void*), void *userdata) int igloo_httpp_encoding_eof(httpp_encoding_t *self, int (*cb)(void*), void *userdata)
{ {
if (!self) if (!self)
return -1; return -1;
@ -302,7 +302,7 @@ int httpp_encoding_eof(httpp_encoding_t *self, int (*cb)(void*), v
* After a call to this function the meta data is released from the * After a call to this function the meta data is released from the
* encoding object and the caller is responsible to free it. * encoding object and the caller is responsible to free it.
*/ */
httpp_meta_t *httpp_encoding_get_meta(httpp_encoding_t *self) httpp_meta_t *igloo_httpp_encoding_get_meta(httpp_encoding_t *self)
{ {
httpp_meta_t *ret; httpp_meta_t *ret;
@ -319,7 +319,7 @@ httpp_meta_t *httpp_encoding_get_meta(httpp_encoding_t *self)
* Depending on encoding flushing buffers may not be safe if not * Depending on encoding flushing buffers may not be safe if not
* at end of stream. * at end of stream.
*/ */
ssize_t httpp_encoding_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata) ssize_t igloo_httpp_encoding_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata)
{ {
ssize_t ret; ssize_t ret;
@ -339,7 +339,7 @@ ssize_t httpp_encoding_write(httpp_encoding_t *self, const void *buf,
} }
/* Check if we have something to flush. */ /* Check if we have something to flush. */
ssize_t httpp_encoding_pending(httpp_encoding_t *self) ssize_t igloo_httpp_encoding_pending(httpp_encoding_t *self)
{ {
if (!self) if (!self)
return -1; return -1;
@ -351,15 +351,15 @@ ssize_t httpp_encoding_pending(httpp_encoding_t *self)
/* Attach meta data to the stream. /* Attach meta data to the stream.
* this is to be written out as soon as the encoding supports. * this is to be written out as soon as the encoding supports.
*/ */
int httpp_encoding_append_meta(httpp_encoding_t *self, httpp_meta_t *meta) int igloo_httpp_encoding_append_meta(httpp_encoding_t *self, httpp_meta_t *meta)
{ {
if (!self) if (!self)
return -1; return -1;
return httpp_encoding_meta_append(&(self->meta_write), meta); return igloo_httpp_encoding_meta_append(&(self->meta_write), meta);
} }
/* handlers for encodings */ /* handlers for encodings */
static ssize_t __enc_identity_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata) static ssize_t igloo___enc_identity_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata)
{ {
(void)self; (void)self;
if (!cb) if (!cb)
@ -367,7 +367,7 @@ static ssize_t __enc_identity_read(httpp_encoding_t *self, void *buf, size_t len
return cb(userdata, buf, len); return cb(userdata, buf, len);
} }
static ssize_t __enc_identity_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata) static ssize_t igloo___enc_identity_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata)
{ {
(void)self; (void)self;
if (!cb) if (!cb)
@ -414,7 +414,7 @@ static void __enc_chunked_read_extentions(httpp_encoding_t *self, char *p, size_
p++; p++;
len--; len--;
*parent = meta = httpp_encoding_meta_new(NULL, NULL); *parent = meta = igloo_httpp_encoding_meta_new(NULL, NULL);
parent = &(meta->next); parent = &(meta->next);
for (key_len = 0; key_len < len && p[key_len] != '='; key_len++); for (key_len = 0; key_len < len && p[key_len] != '='; key_len++);
@ -482,7 +482,7 @@ static void __enc_chunked_read_extentions(httpp_encoding_t *self, char *p, size_
} }
} }
static ssize_t __enc_chunked_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata) static ssize_t igloo___enc_chunked_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata)
{ {
ssize_t ret; ssize_t ret;
size_t buflen; size_t buflen;
@ -780,12 +780,12 @@ static char *__enc_chunked_write_extensions(httpp_encoding_t *self)
*p = 0; /* terminate the string */ *p = 0; /* terminate the string */
httpp_encoding_meta_free(self->meta_write); igloo_httpp_encoding_meta_free(self->meta_write);
self->meta_write = NULL; self->meta_write = NULL;
return buf; return buf;
} }
static ssize_t __enc_chunked_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata) static ssize_t igloo___enc_chunked_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata)
{ {
char encoded_length[32]; char encoded_length[32];
char *extensions = NULL; char *extensions = NULL;
@ -798,7 +798,7 @@ static ssize_t __enc_chunked_write(httpp_encoding_t *self, const void *buf, size
len = 0; len = 0;
/* refuse to write if we still have stuff to flush. */ /* refuse to write if we still have stuff to flush. */
if (httpp_encoding_pending(self) > 0) if (igloo_httpp_encoding_pending(self) > 0)
return 0; return 0;
/* limit length to a bit more sane value */ /* limit length to a bit more sane value */

24
httpp/encoding.h
View File

@ -46,44 +46,44 @@ struct httpp_meta_tag {
/* meta data functions */ /* meta data functions */
/* meta data is to be used in a encoding-specific way */ /* meta data is to be used in a encoding-specific way */
httpp_meta_t *httpp_encoding_meta_new(const char *key, const char *value); httpp_meta_t *igloo_httpp_encoding_meta_new(const char *key, const char *value);
int httpp_encoding_meta_free(httpp_meta_t *self); int igloo_httpp_encoding_meta_free(httpp_meta_t *self);
int httpp_encoding_meta_append(httpp_meta_t **dst, httpp_meta_t *next); int igloo_httpp_encoding_meta_append(httpp_meta_t **dst, httpp_meta_t *next);
/* General setup */ /* General setup */
httpp_encoding_t *httpp_encoding_new(const char *encoding); httpp_encoding_t *igloo_httpp_encoding_new(const char *encoding);
int httpp_encoding_addref(httpp_encoding_t *self); int igloo_httpp_encoding_addref(httpp_encoding_t *self);
int httpp_encoding_release(httpp_encoding_t *self); int igloo_httpp_encoding_release(httpp_encoding_t *self);
/* Read data from backend. /* Read data from backend.
* if cb is NULL this will read from the internal buffer. * if cb is NULL this will read from the internal buffer.
*/ */
ssize_t httpp_encoding_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata); ssize_t igloo_httpp_encoding_read(httpp_encoding_t *self, void *buf, size_t len, ssize_t (*cb)(void*, void*, size_t), void *userdata);
/* Check if EOF is reached. /* Check if EOF is reached.
* If cb is not NULL this also considers backend state. * If cb is not NULL this also considers backend state.
*/ */
int httpp_encoding_eof(httpp_encoding_t *self, int (*cb)(void*), void *userdata); int igloo_httpp_encoding_eof(httpp_encoding_t *self, int (*cb)(void*), void *userdata);
/* Read any meta data that is in buffer. /* Read any meta data that is in buffer.
* After a call to this function the meta data is released from the * After a call to this function the meta data is released from the
* encoding object and the caller is responsible to free it. * encoding object and the caller is responsible to free it.
*/ */
httpp_meta_t *httpp_encoding_get_meta(httpp_encoding_t *self); httpp_meta_t *igloo_httpp_encoding_get_meta(httpp_encoding_t *self);
/* Write data to backend. /* Write data to backend.
* If buf is NULL this will flush buffers. * If buf is NULL this will flush buffers.
* Depending on encoding flushing buffers may not be safe if not * Depending on encoding flushing buffers may not be safe if not
* at end of stream. * at end of stream.
*/ */
ssize_t httpp_encoding_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata); ssize_t igloo_httpp_encoding_write(httpp_encoding_t *self, const void *buf, size_t len, ssize_t (*cb)(void*, const void*, size_t), void *userdata);
/* Check if we have something to flush. */ /* Check if we have something to flush. */
ssize_t httpp_encoding_pending(httpp_encoding_t *self); ssize_t igloo_httpp_encoding_pending(httpp_encoding_t *self);
/* Attach meta data to the stream. /* Attach meta data to the stream.
* this is to be written out as soon as the encoding supports. * this is to be written out as soon as the encoding supports.
*/ */
int httpp_encoding_append_meta(httpp_encoding_t *self, httpp_meta_t *meta); int igloo_httpp_encoding_append_meta(httpp_encoding_t *self, httpp_meta_t *meta);
#endif #endif

168
httpp/httpp.c
View File

@ -49,17 +49,17 @@
static char *_lowercase(char *str); static char *_lowercase(char *str);
/* for avl trees */ /* for avl trees */
static int _compare_vars(void *compare_arg, void *a, void *b); static int igloo__compare_vars(void *compare_arg, void *a, void *b);
static int _free_vars(void *key); static int igloo__free_vars(void *key);
/* For avl tree manipulation */ /* For avl tree manipulation */
static void parse_query(avl_tree *tree, const char *query, size_t len); static void parse_query(avl_tree *tree, const char *query, size_t len);
static const char *_httpp_get_param(avl_tree *tree, const char *name); static const char *_httpp_get_param(avl_tree *tree, const char *name);
static void _httpp_set_param_nocopy(avl_tree *tree, char *name, char *value, int replace); static void _httpp_set_param_nocopy(avl_tree *tree, char *name, char *value, int replace);
static void _httpp_set_param(avl_tree *tree, const char *name, const char *value); static void _httpp_set_param(avl_tree *tree, const char *name, const char *value);
static http_var_t *_httpp_get_param_var(avl_tree *tree, const char *name); static http_var_t *igloo__httpp_get_param_var(avl_tree *tree, const char *name);
httpp_request_info_t httpp_request_info(httpp_request_type_e req) httpp_request_info_t igloo_httpp_request_info(httpp_request_type_e req)
{ {
#if 0 #if 0
#define HTTPP_REQUEST_IS_SAFE ((httpp_request_info_t)0x0001U) #define HTTPP_REQUEST_IS_SAFE ((httpp_request_info_t)0x0001U)
@ -116,21 +116,21 @@ httpp_request_info_t httpp_request_info(httpp_request_type_e req)
} }
} }
http_parser_t *httpp_create_parser(void) http_parser_t *igloo_httpp_create_parser(void)
{ {
http_parser_t *parser = calloc(1, sizeof(http_parser_t)); http_parser_t *parser = calloc(1, sizeof(http_parser_t));
parser->refc = 1; parser->refc = 1;
parser->req_type = httpp_req_none; parser->req_type = httpp_req_none;
parser->uri = NULL; parser->uri = NULL;
parser->vars = avl_tree_new(_compare_vars, NULL); parser->vars = igloo_avl_tree_new(igloo__compare_vars, NULL);
parser->queryvars = avl_tree_new(_compare_vars, NULL); parser->queryvars = igloo_avl_tree_new(igloo__compare_vars, NULL);
parser->postvars = avl_tree_new(_compare_vars, NULL); parser->postvars = igloo_avl_tree_new(igloo__compare_vars, NULL);
return parser; return parser;
} }
void httpp_initialize(http_parser_t *parser, http_varlist_t *defaults) void igloo_httpp_initialize(http_parser_t *parser, http_varlist_t *defaults)
{ {
http_varlist_t *list; http_varlist_t *list;
@ -140,14 +140,14 @@ void httpp_initialize(http_parser_t *parser, http_varlist_t *defaults)
size_t i; size_t i;
for (i = 0; i < list->var.values; i++) { for (i = 0; i < list->var.values; i++) {
httpp_setvar(parser, list->var.name, list->var.value[i]); igloo_httpp_setvar(parser, list->var.name, list->var.value[i]);
} }
list = list->next; list = list->next;
} }
} }
static int split_headers(char *data, unsigned long len, char **line) static int igloo_split_headers(char *data, unsigned long len, char **line)
{ {
/* first we count how many lines there are /* first we count how many lines there are
** and set up the line[] array ** and set up the line[] array
@ -177,7 +177,7 @@ static int split_headers(char *data, unsigned long len, char **line)
return lines; return lines;
} }
static void parse_headers(http_parser_t *parser, char **line, int lines) static void igloo_parse_headers(http_parser_t *parser, char **line, int lines)
{ {
int i, l; int i, l;
int whitespace, slen; int whitespace, slen;
@ -209,14 +209,14 @@ static void parse_headers(http_parser_t *parser, char **line, int lines)
} }
if (name != NULL && value != NULL) { if (name != NULL && value != NULL) {
httpp_setvar(parser, _lowercase(name), value); igloo_httpp_setvar(parser, _lowercase(name), value);
name = NULL; name = NULL;
value = NULL; value = NULL;
} }
} }
} }
int httpp_parse_response(http_parser_t *parser, const char *http_data, unsigned long len, const char *uri) int igloo_httpp_parse_response(http_parser_t *parser, const char *http_data, unsigned long len, const char *uri)
{ {
char *data; char *data;
char *line[MAX_HEADERS]; char *line[MAX_HEADERS];
@ -232,7 +232,7 @@ int httpp_parse_response(http_parser_t *parser, const char *http_data, unsigned
memcpy(data, http_data, len); memcpy(data, http_data, len);
data[len] = 0; data[len] = 0;
lines = split_headers(data, len, line); lines = igloo_split_headers(data, len, line);
/* In this case, the first line contains: /* In this case, the first line contains:
* VERSION RESPONSE_CODE MESSAGE, such as HTTP/1.0 200 OK * VERSION RESPONSE_CODE MESSAGE, such as HTTP/1.0 200 OK
@ -260,25 +260,25 @@ int httpp_parse_response(http_parser_t *parser, const char *http_data, unsigned
return 0; return 0;
} }
httpp_setvar(parser, HTTPP_VAR_ERROR_CODE, resp_code); igloo_httpp_setvar(parser, HTTPP_VAR_ERROR_CODE, resp_code);
code = atoi(resp_code); code = atoi(resp_code);
if(code < 200 || code >= 300) { if(code < 200 || code >= 300) {
httpp_setvar(parser, HTTPP_VAR_ERROR_MESSAGE, message); igloo_httpp_setvar(parser, HTTPP_VAR_ERROR_MESSAGE, message);
} }
httpp_setvar(parser, HTTPP_VAR_URI, uri); igloo_httpp_setvar(parser, HTTPP_VAR_URI, uri);
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "NONE"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "NONE");
parse_headers(parser, line, lines); igloo_parse_headers(parser, line, lines);
free(data); free(data);
return 1; return 1;
} }
int httpp_parse_postdata(http_parser_t *parser, const char *body_data, size_t len) int igloo_httpp_parse_postdata(http_parser_t *parser, const char *body_data, size_t len)
{ {
const char *header = httpp_getvar(parser, "content-type"); const char *header = igloo_httpp_getvar(parser, "content-type");
if (strcasecmp(header, "application/x-www-form-urlencoded") != 0) { if (strcasecmp(header, "application/x-www-form-urlencoded") != 0) {
return -1; return -1;
@ -301,7 +301,7 @@ static int hex(char c)
return -1; return -1;
} }
static char *url_unescape(const char *src, size_t len) static char *igloo_url_unescape(const char *src, size_t len)
{ {
unsigned char *decoded; unsigned char *decoded;
size_t i; size_t i;
@ -374,7 +374,7 @@ static void parse_query_element(avl_tree *tree, const char *start, const char *m
memcpy(key, start, keylen); memcpy(key, start, keylen);
key[keylen] = 0; key[keylen] = 0;
value = url_unescape(mid + 1, valuelen); value = igloo_url_unescape(mid + 1, valuelen);
_httpp_set_param_nocopy(tree, key, value, 0); _httpp_set_param_nocopy(tree, key, value, 0);
} }
@ -404,7 +404,7 @@ static void parse_query(avl_tree *tree, const char *query, size_t len)
parse_query_element(tree, start, mid, &(query[i])); parse_query_element(tree, start, mid, &(query[i]));
} }
int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len) int igloo_httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len)
{ {
char *data, *tmp; char *data, *tmp;
char *line[MAX_HEADERS]; /* limited to 32 lines, should be more than enough */ char *line[MAX_HEADERS]; /* limited to 32 lines, should be more than enough */
@ -424,7 +424,7 @@ int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len)
memcpy(data, http_data, len); memcpy(data, http_data, len);
data[len] = 0; data[len] = 0;
lines = split_headers(data, len, line); lines = igloo_split_headers(data, len, line);
/* parse the first line special /* parse the first line special
** the format is: ** the format is:
@ -462,13 +462,13 @@ int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len)
} }
} }
parser->req_type = httpp_str_to_method(req_type); parser->req_type = igloo_httpp_str_to_method(req_type);
if (uri != NULL && strlen(uri) > 0) { if (uri != NULL && strlen(uri) > 0) {
char *query; char *query;
if((query = strchr(uri, '?')) != NULL) { if((query = strchr(uri, '?')) != NULL) {
httpp_setvar(parser, HTTPP_VAR_RAWURI, uri); igloo_httpp_setvar(parser, HTTPP_VAR_RAWURI, uri);
httpp_setvar(parser, HTTPP_VAR_QUERYARGS, query); igloo_httpp_setvar(parser, HTTPP_VAR_QUERYARGS, query);
*query = 0; *query = 0;
query++; query++;
parse_query(parser->queryvars, query, strlen(query)); parse_query(parser->queryvars, query, strlen(query));
@ -483,8 +483,8 @@ int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len)
if ((version != NULL) && ((tmp = strchr(version, '/')) != NULL)) { if ((version != NULL) && ((tmp = strchr(version, '/')) != NULL)) {
tmp[0] = '\0'; tmp[0] = '\0';
if ((strlen(version) > 0) && (strlen(&tmp[1]) > 0)) { if ((strlen(version) > 0) && (strlen(&tmp[1]) > 0)) {
httpp_setvar(parser, HTTPP_VAR_PROTOCOL, version); igloo_httpp_setvar(parser, HTTPP_VAR_PROTOCOL, version);
httpp_setvar(parser, HTTPP_VAR_VERSION, &tmp[1]); igloo_httpp_setvar(parser, HTTPP_VAR_VERSION, &tmp[1]);
} else { } else {
free(data); free(data);
return 0; return 0;
@ -497,37 +497,37 @@ int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len)
if (parser->req_type != httpp_req_none && parser->req_type != httpp_req_unknown) { if (parser->req_type != httpp_req_none && parser->req_type != httpp_req_unknown) {
switch (parser->req_type) { switch (parser->req_type) {
case httpp_req_get: case httpp_req_get:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "GET"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "GET");
break; break;
case httpp_req_post: case httpp_req_post:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "POST"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "POST");
break; break;
case httpp_req_put: case httpp_req_put:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "PUT"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "PUT");
break; break;
case httpp_req_head: case httpp_req_head:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "HEAD"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "HEAD");
break; break;
case httpp_req_options: case httpp_req_options:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "OPTIONS"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "OPTIONS");
break; break;
case httpp_req_delete: case httpp_req_delete:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "DELETE"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "DELETE");
break; break;
case httpp_req_trace: case httpp_req_trace:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "TRACE"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "TRACE");
break; break;
case httpp_req_connect: case httpp_req_connect:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "CONNECT"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "CONNECT");
break; break;
case httpp_req_source: case httpp_req_source:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "SOURCE"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "SOURCE");
break; break;
case httpp_req_play: case httpp_req_play:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "PLAY"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "PLAY");
break; break;
case httpp_req_stats: case httpp_req_stats:
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "STATS"); igloo_httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "STATS");
break; break;
default: default:
break; break;
@ -538,20 +538,20 @@ int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len)
} }
if (parser->uri != NULL) { if (parser->uri != NULL) {
httpp_setvar(parser, HTTPP_VAR_URI, parser->uri); igloo_httpp_setvar(parser, HTTPP_VAR_URI, parser->uri);
} else { } else {
free(data); free(data);
return 0; return 0;
} }
parse_headers(parser, line, lines); igloo_parse_headers(parser, line, lines);
free(data); free(data);
return 1; return 1;
} }
void httpp_deletevar(http_parser_t *parser, const char *name) void igloo_httpp_deletevar(http_parser_t *parser, const char *name)
{ {
http_var_t var; http_var_t var;
@ -561,10 +561,10 @@ void httpp_deletevar(http_parser_t *parser, const char *name)
var.name = (char*)name; var.name = (char*)name;
avl_delete(parser->vars, (void *)&var, _free_vars); igloo_avl_delete(parser->vars, (void *)&var, igloo__free_vars);
} }
void httpp_setvar(http_parser_t *parser, const char *name, const char *value) void igloo_httpp_setvar(http_parser_t *parser, const char *name, const char *value)
{ {
http_var_t *var; http_var_t *var;
@ -584,15 +584,15 @@ void httpp_setvar(http_parser_t *parser, const char *name, const char *value)
var->values = 1; var->values = 1;
var->value[0] = strdup(value); var->value[0] = strdup(value);
if (httpp_getvar(parser, name) == NULL) { if (igloo_httpp_getvar(parser, name) == NULL) {
avl_insert(parser->vars, (void *)var); igloo_avl_insert(parser->vars, (void *)var);
} else { } else {
avl_delete(parser->vars, (void *)var, _free_vars); igloo_avl_delete(parser->vars, (void *)var, igloo__free_vars);
avl_insert(parser->vars, (void *)var); igloo_avl_insert(parser->vars, (void *)var);
} }
} }
const char *httpp_getvar(http_parser_t *parser, const char *name) const char *igloo_httpp_getvar(http_parser_t *parser, const char *name)
{ {
http_var_t var; http_var_t var;
http_var_t *found; http_var_t *found;
@ -605,7 +605,7 @@ const char *httpp_getvar(http_parser_t *parser, const char *name)
memset(&var, 0, sizeof(var)); memset(&var, 0, sizeof(var));
var.name = (char*)name; var.name = (char*)name;
if (avl_get_by_key(parser->vars, &var, fp) == 0) { if (igloo_avl_get_by_key(parser->vars, &var, fp) == 0) {
if (!found->values) if (!found->values)
return NULL; return NULL;
return found->value[0]; return found->value[0];
@ -622,7 +622,7 @@ static void _httpp_set_param_nocopy(avl_tree *tree, char *name, char *value, int
if (name == NULL || value == NULL) if (name == NULL || value == NULL)
return; return;
found = _httpp_get_param_var(tree, name); found = igloo__httpp_get_param_var(tree, name);
if (replace || !found) { if (replace || !found) {
var = (http_var_t *)calloc(1, sizeof(http_var_t)); var = (http_var_t *)calloc(1, sizeof(http_var_t));
@ -652,10 +652,10 @@ static void _httpp_set_param_nocopy(avl_tree *tree, char *name, char *value, int
var->value[var->values++] = value; var->value[var->values++] = value;
if (replace && found) { if (replace && found) {
avl_delete(tree, (void *)found, _free_vars); igloo_avl_delete(tree, (void *)found, igloo__free_vars);
avl_insert(tree, (void *)var); igloo_avl_insert(tree, (void *)var);
} else if (!found) { } else if (!found) {
avl_insert(tree, (void *)var); igloo_avl_insert(tree, (void *)var);
} }
} }
@ -664,10 +664,10 @@ static void _httpp_set_param(avl_tree *tree, const char *name, const char *value
if (name == NULL || value == NULL) if (name == NULL || value == NULL)
return; return;
_httpp_set_param_nocopy(tree, strdup(name), url_unescape(value, strlen(value)), 1); _httpp_set_param_nocopy(tree, strdup(name), igloo_url_unescape(value, strlen(value)), 1);
} }
static http_var_t *_httpp_get_param_var(avl_tree *tree, const char *name) static http_var_t *igloo__httpp_get_param_var(avl_tree *tree, const char *name)
{ {
http_var_t var; http_var_t var;
http_var_t *found; http_var_t *found;
@ -677,14 +677,14 @@ static http_var_t *_httpp_get_param_var(avl_tree *tree, const char *name)
memset(&var, 0, sizeof(var)); memset(&var, 0, sizeof(var));
var.name = (char *)name; var.name = (char *)name;
if (avl_get_by_key(tree, (void *)&var, fp) == 0) if (igloo_avl_get_by_key(tree, (void *)&var, fp) == 0)
return found; return found;
else else
return NULL; return NULL;
} }
static const char *_httpp_get_param(avl_tree *tree, const char *name) static const char *_httpp_get_param(avl_tree *tree, const char *name)
{ {
http_var_t *res = _httpp_get_param_var(tree, name); http_var_t *res = igloo__httpp_get_param_var(tree, name);
if (!res) if (!res)
return NULL; return NULL;
@ -695,37 +695,37 @@ static const char *_httpp_get_param(avl_tree *tree, const char *name)
return res->value[0]; return res->value[0];
} }
void httpp_set_query_param(http_parser_t *parser, const char *name, const char *value) void igloo_httpp_set_query_param(http_parser_t *parser, const char *name, const char *value)
{ {
return _httpp_set_param(parser->queryvars, name, value); return _httpp_set_param(parser->queryvars, name, value);
} }
const char *httpp_get_query_param(http_parser_t *parser, const char *name) const char *igloo_httpp_get_query_param(http_parser_t *parser, const char *name)
{ {
return _httpp_get_param(parser->queryvars, name); return _httpp_get_param(parser->queryvars, name);
} }
void httpp_set_post_param(http_parser_t *parser, const char *name, const char *value) void igloo_httpp_set_post_param(http_parser_t *parser, const char *name, const char *value)
{ {
return _httpp_set_param(parser->postvars, name, value); return _httpp_set_param(parser->postvars, name, value);
} }
const char *httpp_get_post_param(http_parser_t *parser, const char *name) const char *igloo_httpp_get_post_param(http_parser_t *parser, const char *name)
{ {
return _httpp_get_param(parser->postvars, name); return _httpp_get_param(parser->postvars, name);
} }
const http_var_t *httpp_get_param_var(http_parser_t *parser, const char *name) const http_var_t *igloo_httpp_get_param_var(http_parser_t *parser, const char *name)
{ {
http_var_t *ret = _httpp_get_param_var(parser->postvars, name); http_var_t *ret = igloo__httpp_get_param_var(parser->postvars, name);
if (ret) if (ret)
return ret; return ret;
return _httpp_get_param_var(parser->queryvars, name); return igloo__httpp_get_param_var(parser->queryvars, name);
} }
const http_var_t *httpp_get_any_var(http_parser_t *parser, httpp_ns_t ns, const char *name) const http_var_t *igloo_httpp_get_any_var(http_parser_t *parser, httpp_ns_t ns, const char *name)
{ {
avl_tree *tree = NULL; avl_tree *tree = NULL;
@ -754,10 +754,10 @@ const http_var_t *httpp_get_any_var(http_parser_t *parser, httpp_ns_t ns, const
if (!tree) if (!tree)
return NULL; return NULL;
return _httpp_get_param_var(tree, name); return igloo__httpp_get_param_var(tree, name);
} }
char ** httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns) char ** igloo_httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns)
{ {
avl_tree *tree = NULL; avl_tree *tree = NULL;
avl_node *avlnode; avl_node *avlnode;
@ -790,7 +790,7 @@ char ** httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns)
len = 8; len = 8;
for (avlnode = avl_get_first(tree); avlnode; avlnode = avl_get_next(avlnode)) { for (avlnode = igloo_avl_get_first(tree); avlnode; avlnode = igloo_avl_get_next(avlnode)) {
http_var_t *var = avlnode->key; http_var_t *var = avlnode->key;
if (ns == HTTPP_NS_VAR) { if (ns == HTTPP_NS_VAR) {
@ -806,7 +806,7 @@ char ** httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns)
if (pos == (len-1)) { if (pos == (len-1)) {
char **n = realloc(ret, sizeof(*ret)*(len + 8)); char **n = realloc(ret, sizeof(*ret)*(len + 8));
if (!n) { if (!n) {
httpp_free_any_key(ret); igloo_httpp_free_any_key(ret);
return NULL; return NULL;
} }
memset(n + len, 0, sizeof(*n)*8); memset(n + len, 0, sizeof(*n)*8);
@ -816,7 +816,7 @@ char ** httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns)
ret[pos] = strdup(var->name); ret[pos] = strdup(var->name);
if (!ret[pos]) { if (!ret[pos]) {
httpp_free_any_key(ret); igloo_httpp_free_any_key(ret);
return NULL; return NULL;
} }
@ -826,7 +826,7 @@ char ** httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns)
return ret; return ret;
} }
void httpp_free_any_key(char **keys) void igloo_httpp_free_any_key(char **keys)
{ {
char **p; char **p;
@ -839,7 +839,7 @@ void httpp_free_any_key(char **keys)
free(keys); free(keys);
} }
const char *httpp_get_param(http_parser_t *parser, const char *name) const char *igloo_httpp_get_param(http_parser_t *parser, const char *name)
{ {
const char *ret = _httpp_get_param(parser->postvars, name); const char *ret = _httpp_get_param(parser->postvars, name);
@ -855,13 +855,13 @@ static void httpp_clear(http_parser_t *parser)
if (parser->uri) if (parser->uri)
free(parser->uri); free(parser->uri);
parser->uri = NULL; parser->uri = NULL;
avl_tree_free(parser->vars, _free_vars); igloo_avl_tree_free(parser->vars, igloo__free_vars);
avl_tree_free(parser->queryvars, _free_vars); igloo_avl_tree_free(parser->queryvars, igloo__free_vars);
avl_tree_free(parser->postvars, _free_vars); igloo_avl_tree_free(parser->postvars, igloo__free_vars);
parser->vars = NULL; parser->vars = NULL;
} }
int httpp_addref(http_parser_t *parser) int igloo_httpp_addref(http_parser_t *parser)
{ {
if (!parser) if (!parser)
return -1; return -1;
@ -871,7 +871,7 @@ int httpp_addref(http_parser_t *parser)
return 0; return 0;
} }
int httpp_release(http_parser_t *parser) int igloo_httpp_release(http_parser_t *parser)
{ {
if (!parser) if (!parser)
return -1; return -1;
@ -895,7 +895,7 @@ static char *_lowercase(char *str)
return str; return str;
} }
static int _compare_vars(void *compare_arg, void *a, void *b) static int igloo__compare_vars(void *compare_arg, void *a, void *b)
{ {
http_var_t *vara, *varb; http_var_t *vara, *varb;
@ -905,7 +905,7 @@ static int _compare_vars(void *compare_arg, void *a, void *b)
return strcmp(vara->name, varb->name); return strcmp(vara->name, varb->name);
} }
static int _free_vars(void *key) static int igloo__free_vars(void *key)
{ {
http_var_t *var = (http_var_t *)key; http_var_t *var = (http_var_t *)key;
size_t i; size_t i;
@ -921,7 +921,7 @@ static int _free_vars(void *key)
return 1; return 1;
} }
httpp_request_type_e httpp_str_to_method(const char * method) { httpp_request_type_e igloo_httpp_str_to_method(const char * method) {
if (strcasecmp("GET", method) == 0) { if (strcasecmp("GET", method) == 0) {
return httpp_req_get; return httpp_req_get;
} else if (strcasecmp("POST", method) == 0) { } else if (strcasecmp("POST", method) == 0) {

44
httpp/httpp.h
View File

@ -97,31 +97,31 @@ typedef struct http_parser_tag {
avl_tree *postvars; avl_tree *postvars;
} http_parser_t; } http_parser_t;
httpp_request_info_t httpp_request_info(httpp_request_type_e req); httpp_request_info_t igloo_httpp_request_info(httpp_request_type_e req);
http_parser_t *httpp_create_parser(void); http_parser_t *igloo_httpp_create_parser(void);
void httpp_initialize(http_parser_t *parser, http_varlist_t *defaults); void igloo_httpp_initialize(http_parser_t *parser, http_varlist_t *defaults);
int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len); int igloo_httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len);
int httpp_parse_icy(http_parser_t *parser, const char *http_data, unsigned long len); int httpp_parse_icy(http_parser_t *parser, const char *http_data, unsigned long len);
int httpp_parse_response(http_parser_t *parser, const char *http_data, unsigned long len, const char *uri); int igloo_httpp_parse_response(http_parser_t *parser, const char *http_data, unsigned long len, const char *uri);
int httpp_parse_postdata(http_parser_t *parser, const char *body_data, size_t len); int igloo_httpp_parse_postdata(http_parser_t *parser, const char *body_data, size_t len);
void httpp_setvar(http_parser_t *parser, const char *name, const char *value); void igloo_httpp_setvar(http_parser_t *parser, const char *name, const char *value);
void httpp_deletevar(http_parser_t *parser, const char *name); void igloo_httpp_deletevar(http_parser_t *parser, const char *name);
const char *httpp_getvar(http_parser_t *parser, const char *name); const char *igloo_httpp_getvar(http_parser_t *parser, const char *name);
void httpp_set_query_param(http_parser_t *parser, const char *name, const char *value); void igloo_httpp_set_query_param(http_parser_t *parser, const char *name, const char *value);
const char *httpp_get_query_param(http_parser_t *parser, const char *name); const char *igloo_httpp_get_query_param(http_parser_t *parser, const char *name);
void httpp_set_post_param(http_parser_t *parser, const char *name, const char *value); void igloo_httpp_set_post_param(http_parser_t *parser, const char *name, const char *value);
const char *httpp_get_post_param(http_parser_t *parser, const char *name); const char *igloo_httpp_get_post_param(http_parser_t *parser, const char *name);
const char *httpp_get_param(http_parser_t *parser, const char *name); const char *igloo_httpp_get_param(http_parser_t *parser, const char *name);
const http_var_t *httpp_get_param_var(http_parser_t *parser, const char *name); const http_var_t *igloo_httpp_get_param_var(http_parser_t *parser, const char *name);
const http_var_t *httpp_get_any_var(http_parser_t *parser, httpp_ns_t ns, const char *name); const http_var_t *igloo_httpp_get_any_var(http_parser_t *parser, httpp_ns_t ns, const char *name);
char ** httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns); char ** igloo_httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns);
void httpp_free_any_key(char **keys); void igloo_httpp_free_any_key(char **keys);
int httpp_addref(http_parser_t *parser); int igloo_httpp_addref(http_parser_t *parser);
int httpp_release(http_parser_t *parser); int igloo_httpp_release(http_parser_t *parser);
#define httpp_destroy(x) httpp_release((x)) #define httpp_destroy(x) igloo_httpp_release((x))
/* util functions */ /* util functions */
httpp_request_type_e httpp_str_to_method(const char * method); httpp_request_type_e igloo_httpp_str_to_method(const char * method);
#endif #endif

8
httpp/test.c
View File

@ -12,10 +12,10 @@ int main(int argc, char **argv)
avl_node *node; avl_node *node;
http_var_t *var; http_var_t *var;
httpp_initialize(&parser, NULL); igloo_httpp_initialize(&parser, NULL);
readed = fread(buff, 1, 8192, stdin); readed = fread(buff, 1, 8192, stdin);
if (httpp_parse(&parser, buff, readed)) { if (igloo_httpp_parse(&parser, buff, readed)) {
printf("Parse succeeded...\n\n"); printf("Parse succeeded...\n\n");
printf("Request was "); printf("Request was ");
switch (parser.req_type) { switch (parser.req_type) {
@ -37,14 +37,14 @@ int main(int argc, char **argv)
} }
printf("Version was 1.%d\n", parser.version); printf("Version was 1.%d\n", parser.version);
node = avl_get_first(parser.vars); node = igloo_avl_get_first(parser.vars);
while (node) { while (node) {
var = (http_var_t *)node->key; var = (http_var_t *)node->key;
if (var) if (var)
printf("Iterating variable(s): %s = %s\n", var->name, var->value); printf("Iterating variable(s): %s = %s\n", var->name, var->value);
node = avl_get_next(node); node = igloo_avl_get_next(node);
} }
} else { } else {
printf("Parse failed...\n"); printf("Parse failed...\n");

260
log/log.c
View File

@ -64,8 +64,8 @@
#define mutex_t pthread_mutex_t #define mutex_t pthread_mutex_t
#endif #endif
static mutex_t _logger_mutex; static mutex_t igloo__logger_mutex;
static int _initialized = 0; static int igloo__initialized = 0;
typedef struct _log_entry_t typedef struct _log_entry_t
{ {
@ -96,7 +96,7 @@ typedef struct log_tag
char *buffer; char *buffer;
} log_t; } log_t;
static log_t loglist[LOG_MAXLOGS]; static log_t igloo_loglist[LOG_MAXLOGS];
static int _get_log_id(void); static int _get_log_id(void);
static void _lock_logger(void); static void _lock_logger(void);
@ -105,87 +105,87 @@ static void _unlock_logger(void);
static int _log_open (int id) static int _log_open (int id)
{ {
if (loglist [id] . in_use == 0) if (igloo_loglist [id] . in_use == 0)
return 0; return 0;
/* check for cases where an open of the logfile is wanted */ /* check for cases where an open of the logfile is wanted */
if (loglist [id] . logfile == NULL || if (igloo_loglist [id] . logfile == NULL ||
(loglist [id] . trigger_level && loglist [id] . size > loglist [id] . trigger_level)) (igloo_loglist [id] . trigger_level && igloo_loglist [id] . size > igloo_loglist [id] . trigger_level))
{ {
if (loglist [id] . filename) /* only re-open files where we have a name */ if (igloo_loglist [id] . filename) /* only re-open files where we have a name */
{ {
struct stat st; struct stat st;
if (loglist [id] . logfile) if (igloo_loglist [id] . logfile)
{ {
char new_name [4096]; char new_name [4096];
fclose (loglist [id] . logfile); fclose (igloo_loglist [id] . logfile);
loglist [id] . logfile = NULL; igloo_loglist [id] . logfile = NULL;
/* simple rename, but could use time providing locking were used */ /* simple rename, but could use time providing locking were used */
if (loglist[id].archive_timestamp) if (igloo_loglist[id].archive_timestamp)
{ {
char timestamp [128]; char timestamp [128];
time_t now = time(NULL); time_t now = time(NULL);
strftime (timestamp, sizeof (timestamp), "%Y%m%d_%H%M%S", localtime (&now)); strftime (timestamp, sizeof (timestamp), "%Y%m%d_%H%M%S", localtime (&now));
snprintf (new_name, sizeof(new_name), "%s.%s", loglist[id].filename, timestamp); snprintf (new_name, sizeof(new_name), "%s.%s", igloo_loglist[id].filename, timestamp);
} }
else { else {
snprintf (new_name, sizeof(new_name), "%s.old", loglist [id] . filename); snprintf (new_name, sizeof(new_name), "%s.old", igloo_loglist [id] . filename);
} }
#ifdef _WIN32 #ifdef _WIN32
if (stat (new_name, &st) == 0) if (stat (new_name, &st) == 0)
remove (new_name); remove (new_name);
#endif #endif
rename (loglist [id] . filename, new_name); rename (igloo_loglist [id] . filename, new_name);
} }
loglist [id] . logfile = fopen (loglist [id] . filename, "a"); igloo_loglist [id] . logfile = fopen (igloo_loglist [id] . filename, "a");
if (loglist [id] . logfile == NULL) if (igloo_loglist [id] . logfile == NULL)
return 0; return 0;
setvbuf (loglist [id] . logfile, NULL, IO_BUFFER_TYPE, 0); setvbuf (igloo_loglist [id] . logfile, NULL, IO_BUFFER_TYPE, 0);
if (stat (loglist [id] . filename, &st) < 0) if (stat (igloo_loglist [id] . filename, &st) < 0)
loglist [id] . size = 0; igloo_loglist [id] . size = 0;
else else
loglist [id] . size = st.st_size; igloo_loglist [id] . size = st.st_size;
} }
else else
loglist [id] . size = 0; igloo_loglist [id] . size = 0;
} }
return 1; return 1;
} }
void log_initialize(void) void igloo_log_initialize(void)
{ {
int i; int i;
if (_initialized) return; if (igloo__initialized) return;
for (i = 0; i < LOG_MAXLOGS; i++) { for (i = 0; i < LOG_MAXLOGS; i++) {
loglist[i].in_use = 0; igloo_loglist[i].in_use = 0;
loglist[i].level = 2; igloo_loglist[i].level = 2;
loglist[i].size = 0; igloo_loglist[i].size = 0;
loglist[i].trigger_level = 1000000000; igloo_loglist[i].trigger_level = 1000000000;
loglist[i].filename = NULL; igloo_loglist[i].filename = NULL;
loglist[i].logfile = NULL; igloo_loglist[i].logfile = NULL;
loglist[i].buffer = NULL; igloo_loglist[i].buffer = NULL;
loglist[i].total = 0; igloo_loglist[i].total = 0;
loglist[i].entries = 0; igloo_loglist[i].entries = 0;
loglist[i].keep_entries = 0; igloo_loglist[i].keep_entries = 0;
loglist[i].log_head = NULL; igloo_loglist[i].log_head = NULL;
loglist[i].log_tail = &loglist[i].log_head; igloo_loglist[i].log_tail = &igloo_loglist[i].log_head;
} }
/* initialize mutexes */ /* initialize mutexes */
#ifndef _WIN32 #ifndef _WIN32
pthread_mutex_init(&_logger_mutex, NULL); pthread_mutex_init(&igloo__logger_mutex, NULL);
#else #else
InitializeCriticalSection(&_logger_mutex); InitializeCriticalSection(&igloo__logger_mutex);
#endif #endif
_initialized = 1; igloo__initialized = 1;
} }
int log_open_file(FILE *file) int igloo_log_open_file(FILE *file)
{ {
int log_id; int log_id;
@ -194,15 +194,15 @@ int log_open_file(FILE *file)
log_id = _get_log_id(); log_id = _get_log_id();
if (log_id < 0) return LOG_ENOMORELOGS; if (log_id < 0) return LOG_ENOMORELOGS;
loglist[log_id].logfile = file; igloo_loglist[log_id].logfile = file;
loglist[log_id].filename = NULL; igloo_loglist[log_id].filename = NULL;
loglist[log_id].size = 0; igloo_loglist[log_id].size = 0;
return log_id; return log_id;
} }
int log_open(const char *filename) int igloo_log_open(const char *filename)
{ {
int id; int id;
FILE *file; FILE *file;
@ -212,19 +212,19 @@ int log_open(const char *filename)
file = fopen(filename, "a"); file = fopen(filename, "a");
id = log_open_file(file); id = igloo_log_open_file(file);
if (id >= 0) if (id >= 0)
{ {
struct stat st; struct stat st;
setvbuf (loglist [id] . logfile, NULL, IO_BUFFER_TYPE, 0); setvbuf (igloo_loglist [id] . logfile, NULL, IO_BUFFER_TYPE, 0);
loglist [id] . filename = strdup (filename); igloo_loglist [id] . filename = strdup (filename);
if (stat (loglist [id] . filename, &st) == 0) if (stat (igloo_loglist [id] . filename, &st) == 0)
loglist [id] . size = st.st_size; igloo_loglist [id] . size = st.st_size;
loglist [id] . entries = 0; igloo_loglist [id] . entries = 0;
loglist [id] . log_head = NULL; igloo_loglist [id] . log_head = NULL;
loglist [id] . log_tail = &loglist [id] . log_head; igloo_loglist [id] . log_tail = &igloo_loglist [id] . log_head;
} }
return id; return id;
@ -232,184 +232,184 @@ int log_open(const char *filename)
/* set the trigger level to trigger, represented in kilobytes */ /* set the trigger level to trigger, represented in kilobytes */
void log_set_trigger(int id, unsigned trigger) void igloo_log_set_trigger(int id, unsigned trigger)
{ {
if (id >= 0 && id < LOG_MAXLOGS && loglist [id] . in_use) if (id >= 0 && id < LOG_MAXLOGS && igloo_loglist [id] . in_use)
{ {
loglist [id] . trigger_level = trigger*1024; igloo_loglist [id] . trigger_level = trigger*1024;
} }
} }
int log_set_filename(int id, const char *filename) int igloo_log_set_filename(int id, const char *filename)
{ {
if (id < 0 || id >= LOG_MAXLOGS) if (id < 0 || id >= LOG_MAXLOGS)
return LOG_EINSANE; return LOG_EINSANE;
/* NULL filename is ok, empty filename is not. */ /* NULL filename is ok, empty filename is not. */
if ((filename && !strcmp(filename, "")) || loglist [id] . in_use == 0) if ((filename && !strcmp(filename, "")) || igloo_loglist [id] . in_use == 0)
return LOG_EINSANE; return LOG_EINSANE;
_lock_logger(); _lock_logger();
if (loglist [id] . filename) if (igloo_loglist [id] . filename)
free (loglist [id] . filename); free (igloo_loglist [id] . filename);
if (filename) if (filename)
loglist [id] . filename = strdup (filename); igloo_loglist [id] . filename = strdup (filename);
else else
loglist [id] . filename = NULL; igloo_loglist [id] . filename = NULL;
_unlock_logger(); _unlock_logger();
return id; return id;
} }
int log_set_archive_timestamp(int id, int value) int igloo_log_set_archive_timestamp(int id, int value)
{ {
if (id < 0 || id >= LOG_MAXLOGS) if (id < 0 || id >= LOG_MAXLOGS)
return LOG_EINSANE; return LOG_EINSANE;
_lock_logger(); _lock_logger();
loglist[id].archive_timestamp = value; igloo_loglist[id].archive_timestamp = value;
_unlock_logger(); _unlock_logger();
return id; return id;
} }
int log_open_with_buffer(const char *filename, int size) int igloo_log_open_with_buffer(const char *filename, int size)
{ {
/* not implemented */ /* not implemented */
return LOG_ENOTIMPL; return LOG_ENOTIMPL;
} }
void log_set_lines_kept (int log_id, unsigned int count) void igloo_log_set_lines_kept (int log_id, unsigned int count)
{ {
if (log_id < 0 || log_id >= LOG_MAXLOGS) return; if (log_id < 0 || log_id >= LOG_MAXLOGS) return;
if (loglist[log_id].in_use == 0) return; if (igloo_loglist[log_id].in_use == 0) return;
_lock_logger (); _lock_logger ();
loglist[log_id].keep_entries = count; igloo_loglist[log_id].keep_entries = count;
while (loglist[log_id].entries > count) while (igloo_loglist[log_id].entries > count)
{ {
log_entry_t *to_go = loglist [log_id].log_head; log_entry_t *to_go = igloo_loglist [log_id].log_head;
loglist [log_id].log_head = to_go->next; igloo_loglist [log_id].log_head = to_go->next;
loglist [log_id].total -= to_go->len; igloo_loglist [log_id].total -= to_go->len;
free (to_go->line); free (to_go->line);
free (to_go); free (to_go);
loglist [log_id].entries--; igloo_loglist [log_id].entries--;
} }
_unlock_logger (); _unlock_logger ();
} }
void log_set_level(int log_id, unsigned level) void igloo_log_set_level(int log_id, unsigned level)
{ {
if (log_id < 0 || log_id >= LOG_MAXLOGS) return; if (log_id < 0 || log_id >= LOG_MAXLOGS) return;
if (loglist[log_id].in_use == 0) return; if (igloo_loglist[log_id].in_use == 0) return;
loglist[log_id].level = level; igloo_loglist[log_id].level = level;
} }
void log_flush(int log_id) void igloo_log_flush(int log_id)
{ {
if (log_id < 0 || log_id >= LOG_MAXLOGS) return; if (log_id < 0 || log_id >= LOG_MAXLOGS) return;
if (loglist[log_id].in_use == 0) return; if (igloo_loglist[log_id].in_use == 0) return;
_lock_logger(); _lock_logger();
if (loglist[log_id].logfile) if (igloo_loglist[log_id].logfile)
fflush(loglist[log_id].logfile); fflush(igloo_loglist[log_id].logfile);
_unlock_logger(); _unlock_logger();
} }
void log_reopen(int log_id) void igloo_log_reopen(int log_id)
{ {
if (log_id < 0 || log_id >= LOG_MAXLOGS) if (log_id < 0 || log_id >= LOG_MAXLOGS)
return; return;
if (loglist [log_id] . filename && loglist [log_id] . logfile) if (igloo_loglist [log_id] . filename && igloo_loglist [log_id] . logfile)
{ {
_lock_logger(); _lock_logger();
fclose (loglist [log_id] . logfile); fclose (igloo_loglist [log_id] . logfile);
loglist [log_id] . logfile = NULL; igloo_loglist [log_id] . logfile = NULL;
_unlock_logger(); _unlock_logger();
} }
} }
void log_close(int log_id) void igloo_log_close(int log_id)
{ {
if (log_id < 0 || log_id >= LOG_MAXLOGS) return; if (log_id < 0 || log_id >= LOG_MAXLOGS) return;
_lock_logger(); _lock_logger();
if (loglist[log_id].in_use == 0) if (igloo_loglist[log_id].in_use == 0)
{ {
_unlock_logger(); _unlock_logger();
return; return;
} }
loglist[log_id].in_use = 0; igloo_loglist[log_id].in_use = 0;
loglist[log_id].level = 2; igloo_loglist[log_id].level = 2;
if (loglist[log_id].filename) free(loglist[log_id].filename); if (igloo_loglist[log_id].filename) free(igloo_loglist[log_id].filename);
if (loglist[log_id].buffer) free(loglist[log_id].buffer); if (igloo_loglist[log_id].buffer) free(igloo_loglist[log_id].buffer);
if (loglist [log_id] . logfile) if (igloo_loglist [log_id] . logfile)
{ {
fclose (loglist [log_id] . logfile); fclose (igloo_loglist [log_id] . logfile);
loglist [log_id] . logfile = NULL; igloo_loglist [log_id] . logfile = NULL;
} }
while (loglist[log_id].entries) while (igloo_loglist[log_id].entries)
{ {
log_entry_t *to_go = loglist [log_id].log_head; log_entry_t *to_go = igloo_loglist [log_id].log_head;
loglist [log_id].log_head = to_go->next; igloo_loglist [log_id].log_head = to_go->next;
loglist [log_id].total -= to_go->len; igloo_loglist [log_id].total -= to_go->len;
free (to_go->line); free (to_go->line);
free (to_go); free (to_go);
loglist [log_id].entries--; igloo_loglist [log_id].entries--;
} }
_unlock_logger(); _unlock_logger();
} }
void log_shutdown(void) void igloo_log_shutdown(void)
{ {
/* destroy mutexes */ /* destroy mutexes */
#ifndef _WIN32 #ifndef _WIN32
pthread_mutex_destroy(&_logger_mutex); pthread_mutex_destroy(&igloo__logger_mutex);
#else #else
DeleteCriticalSection(&_logger_mutex); DeleteCriticalSection(&igloo__logger_mutex);
#endif #endif
_initialized = 0; igloo__initialized = 0;
} }
static int create_log_entry (int log_id, const char *pre, const char *line) static int igloo_create_log_entry (int log_id, const char *pre, const char *line)
{ {
log_entry_t *entry; log_entry_t *entry;
if (loglist[log_id].keep_entries == 0) if (igloo_loglist[log_id].keep_entries == 0)
return fprintf (loglist[log_id].logfile, "%s%s\n", pre, line); return fprintf (igloo_loglist[log_id].logfile, "%s%s\n", pre, line);
entry = calloc (1, sizeof (log_entry_t)); entry = calloc (1, sizeof (log_entry_t));
entry->len = strlen (pre) + strlen (line) + 2; entry->len = strlen (pre) + strlen (line) + 2;
entry->line = malloc (entry->len); entry->line = malloc (entry->len);
snprintf (entry->line, entry->len, "%s%s\n", pre, line); snprintf (entry->line, entry->len, "%s%s\n", pre, line);
loglist [log_id].total += entry->len; igloo_loglist [log_id].total += entry->len;
fprintf (loglist[log_id].logfile, "%s", entry->line); fprintf (igloo_loglist[log_id].logfile, "%s", entry->line);
*loglist [log_id].log_tail = entry; *igloo_loglist [log_id].log_tail = entry;
loglist [log_id].log_tail = &entry->next; igloo_loglist [log_id].log_tail = &entry->next;
if (loglist [log_id].entries >= loglist [log_id].keep_entries) if (igloo_loglist [log_id].entries >= igloo_loglist [log_id].keep_entries)
{ {
log_entry_t *to_go = loglist [log_id].log_head; log_entry_t *to_go = igloo_loglist [log_id].log_head;
loglist [log_id].log_head = to_go->next; igloo_loglist [log_id].log_head = to_go->next;
loglist [log_id].total -= to_go->len; igloo_loglist [log_id].total -= to_go->len;
free (to_go->line); free (to_go->line);
free (to_go); free (to_go);
} }
else else
loglist [log_id].entries++; igloo_loglist [log_id].entries++;
return entry->len; return entry->len;
} }
void log_contents (int log_id, char **_contents, unsigned int *_len) void igloo_log_contents (int log_id, char **_contents, unsigned int *_len)
{ {
int remain; int remain;
log_entry_t *entry; log_entry_t *entry;
@ -419,12 +419,12 @@ void log_contents (int log_id, char **_contents, unsigned int *_len)
if (log_id >= LOG_MAXLOGS) return; /* Bad log number */ if (log_id >= LOG_MAXLOGS) return; /* Bad log number */
_lock_logger (); _lock_logger ();
remain = loglist [log_id].total + 1; remain = igloo_loglist [log_id].total + 1;
*_contents = malloc (remain); *_contents = malloc (remain);
**_contents= '\0'; **_contents= '\0';
*_len = loglist [log_id].total; *_len = igloo_loglist [log_id].total;
entry = loglist [log_id].log_head; entry = igloo_loglist [log_id].log_head;
ptr = *_contents; ptr = *_contents;
while (entry) while (entry)
{ {
@ -653,7 +653,7 @@ static void __vsnprintf(char *str, size_t size, const char *format, va_list ap)
*str = 0; *str = 0;
} }
void log_write(int log_id, unsigned priority, const char *cat, const char *func, void igloo_log_write(int log_id, unsigned priority, const char *cat, const char *func,
const char *fmt, ...) const char *fmt, ...)
{ {
static const char *prior[] = { "EROR", "WARN", "INFO", "DBUG" }; static const char *prior[] = { "EROR", "WARN", "INFO", "DBUG" };
@ -664,7 +664,7 @@ void log_write(int log_id, unsigned priority, const char *cat, const char *func,
va_list ap; va_list ap;
if (log_id < 0 || log_id >= LOG_MAXLOGS) return; /* Bad log number */ if (log_id < 0 || log_id >= LOG_MAXLOGS) return; /* Bad log number */
if (loglist[log_id].level < priority) return; if (igloo_loglist[log_id].level < priority) return;
if (!priority || priority > sizeof(prior)/sizeof(prior[0])) return; /* Bad priority */ if (!priority || priority > sizeof(prior)/sizeof(prior[0])) return; /* Bad priority */
@ -679,14 +679,14 @@ void log_write(int log_id, unsigned priority, const char *cat, const char *func,
_lock_logger(); _lock_logger();
if (_log_open (log_id)) if (_log_open (log_id))
{ {
int len = create_log_entry (log_id, pre, line); int len = igloo_create_log_entry (log_id, pre, line);
if (len > 0) if (len > 0)
loglist[log_id].size += len; igloo_loglist[log_id].size += len;
} }
_unlock_logger(); _unlock_logger();
} }
void log_write_direct(int log_id, const char *fmt, ...) void igloo_log_write_direct(int log_id, const char *fmt, ...)
{ {
va_list ap; va_list ap;
char line[LOG_MAXLINELEN]; char line[LOG_MAXLINELEN];
@ -699,15 +699,15 @@ void log_write_direct(int log_id, const char *fmt, ...)
__vsnprintf(line, LOG_MAXLINELEN, fmt, ap); __vsnprintf(line, LOG_MAXLINELEN, fmt, ap);
if (_log_open (log_id)) if (_log_open (log_id))
{ {
int len = create_log_entry (log_id, "", line); int len = igloo_create_log_entry (log_id, "", line);
if (len > 0) if (len > 0)
loglist[log_id].size += len; igloo_loglist[log_id].size += len;
} }
_unlock_logger(); _unlock_logger();
va_end(ap); va_end(ap);
fflush(loglist[log_id].logfile); fflush(igloo_loglist[log_id].logfile);
} }
static int _get_log_id(void) static int _get_log_id(void)
@ -719,8 +719,8 @@ static int _get_log_id(void)
_lock_logger(); _lock_logger();
for (i = 0; i < LOG_MAXLOGS; i++) for (i = 0; i < LOG_MAXLOGS; i++)
if (loglist[i].in_use == 0) { if (igloo_loglist[i].in_use == 0) {
loglist[i].in_use = 1; igloo_loglist[i].in_use = 1;
id = i; id = i;
break; break;
} }
@ -734,17 +734,17 @@ static int _get_log_id(void)
static void _lock_logger(void) static void _lock_logger(void)
{ {
#ifndef _WIN32 #ifndef _WIN32
pthread_mutex_lock(&_logger_mutex); pthread_mutex_lock(&igloo__logger_mutex);
#else #else
EnterCriticalSection(&_logger_mutex); EnterCriticalSection(&igloo__logger_mutex);
#endif #endif
} }
static void _unlock_logger(void) static void _unlock_logger(void)
{ {
#ifndef _WIN32 #ifndef _WIN32
pthread_mutex_unlock(&_logger_mutex); pthread_mutex_unlock(&igloo__logger_mutex);
#else #else
LeaveCriticalSection(&_logger_mutex); LeaveCriticalSection(&igloo__logger_mutex);
#endif #endif
} }

32
log/log.h
View File

@ -43,23 +43,23 @@
#define IO_BUFFER_TYPE _IOLBF #define IO_BUFFER_TYPE _IOLBF
#endif #endif
void log_initialize(void); void igloo_log_initialize(void);
int log_open_file(FILE *file); int igloo_log_open_file(FILE *file);
int log_open(const char *filename); int igloo_log_open(const char *filename);
int log_open_with_buffer(const char *filename, int size); int igloo_log_open_with_buffer(const char *filename, int size);
void log_set_level(int log_id, unsigned level); void igloo_log_set_level(int log_id, unsigned level);
void log_set_trigger(int id, unsigned trigger); void igloo_log_set_trigger(int id, unsigned trigger);
int log_set_filename(int id, const char *filename); int igloo_log_set_filename(int id, const char *filename);
void log_set_lines_kept (int log_id, unsigned int count); void igloo_log_set_lines_kept (int log_id, unsigned int count);
void log_contents (int log_id, char **_contents, unsigned int *_len); void igloo_log_contents (int log_id, char **_contents, unsigned int *_len);
int log_set_archive_timestamp(int id, int value); int igloo_log_set_archive_timestamp(int id, int value);
void log_flush(int log_id); void igloo_log_flush(int log_id);
void log_reopen(int log_id); void igloo_log_reopen(int log_id);
void log_close(int log_id); void igloo_log_close(int log_id);
void log_shutdown(void); void igloo_log_shutdown(void);
void log_write(int log_id, unsigned priority, const char *cat, const char *func, void igloo_log_write(int log_id, unsigned priority, const char *cat, const char *func,
const char *fmt, ...); const char *fmt, ...);
void log_write_direct(int log_id, const char *fmt, ...); void igloo_log_write_direct(int log_id, const char *fmt, ...);
#endif /* __LOG_H__ */ #endif /* __LOG_H__ */

10
log/test.c
View File

@ -2,20 +2,20 @@
#define CATMODULE "test" #define CATMODULE "test"
#define LOG_ERR(x, y, z...) log_write(x, 1, CATMODULE "/" __FUNCTION__, y, ##z) #define LOG_ERR(x, y, z...) igloo_log_write(x, 1, CATMODULE "/" __FUNCTION__, y, ##z)
int main(void) int main(void)
{ {
int lid; int lid;
log_initialize(); igloo_log_initialize();
lid = log_open("test.log"); lid = igloo_log_open("test.log");
LOG_ERR(lid, "The log id is %d, damnit...", lid); LOG_ERR(lid, "The log id is %d, damnit...", lid);
log_close(lid); igloo_log_close(lid);
log_shutdown(); igloo_log_shutdown();
} }

38
net/resolver.c
View File

@ -45,7 +45,7 @@
#include <thread/thread.h> #include <thread/thread.h>
#else #else
#define thread_mutex_create(x) do{}while(0) #define thread_mutex_create(x) do{}while(0)
#define thread_mutex_destroy(x) do{}while(0) #define igloo_thread_mutex_destroy(x) do{}while(0)
#define thread_mutex_lock(x) do{}while(0) #define thread_mutex_lock(x) do{}while(0)
#define thread_mutex_unlock(x) do{}while(0) #define thread_mutex_unlock(x) do{}while(0)
#endif #endif
@ -60,9 +60,9 @@ static int _isip(const char *what);
/* internal data */ /* internal data */
#ifndef NO_THREAD #ifndef NO_THREAD
static mutex_t _resolver_mutex; static mutex_t igloo__resolver_mutex;
#endif #endif
static int _initialized = 0; static int igloo__initialized = 0;
#ifdef HAVE_INET_PTON #ifdef HAVE_INET_PTON
static int _isip(const char *what) static int _isip(const char *what)
@ -89,7 +89,7 @@ static int _isip(const char *what)
#if defined (HAVE_GETNAMEINFO) && defined (HAVE_GETADDRINFO) #if defined (HAVE_GETNAMEINFO) && defined (HAVE_GETADDRINFO)
char *resolver_getname(const char *ip, char *buff, int len) char *igloo_resolver_getname(const char *ip, char *buff, int len)
{ {
struct addrinfo *head = NULL, hints; struct addrinfo *head = NULL, hints;
char *ret = NULL; char *ret = NULL;
@ -120,7 +120,7 @@ char *resolver_getname(const char *ip, char *buff, int len)
} }
char *resolver_getip(const char *name, char *buff, int len) char *igloo_resolver_getip(const char *name, char *buff, int len)
{ {
struct addrinfo *head, hints; struct addrinfo *head, hints;
char *ret = NULL; char *ret = NULL;
@ -150,7 +150,7 @@ char *resolver_getip(const char *name, char *buff, int len)
#else #else
char *resolver_getname(const char *ip, char *buff, int len) char *igloo_resolver_getname(const char *ip, char *buff, int len)
{ {
struct hostent *host; struct hostent *host;
char *ret = NULL; char *ret = NULL;
@ -163,7 +163,7 @@ char *resolver_getname(const char *ip, char *buff, int len)
return buff; return buff;
} }
thread_mutex_lock(&_resolver_mutex); thread_mutex_lock(&igloo__resolver_mutex);
if (inet_aton (ip, &addr)) { if (inet_aton (ip, &addr)) {
/* casting &addr to const char* as it is recommended on win* */ /* casting &addr to const char* as it is recommended on win* */
if ((host=gethostbyaddr ((const char *)&addr, sizeof (struct in_addr), AF_INET))) if ((host=gethostbyaddr ((const char *)&addr, sizeof (struct in_addr), AF_INET)))
@ -173,11 +173,11 @@ char *resolver_getname(const char *ip, char *buff, int len)
} }
} }
thread_mutex_unlock(&_resolver_mutex); thread_mutex_unlock(&igloo__resolver_mutex);
return ret; return ret;
} }
char *resolver_getip(const char *name, char *buff, int len) char *igloo_resolver_getip(const char *name, char *buff, int len)
{ {
struct hostent *host; struct hostent *host;
char *ret = NULL; char *ret = NULL;
@ -188,7 +188,7 @@ char *resolver_getip(const char *name, char *buff, int len)
buff [len-1] = '\0'; buff [len-1] = '\0';
return buff; return buff;
} }
thread_mutex_lock(&_resolver_mutex); thread_mutex_lock(&igloo__resolver_mutex);
host = gethostbyname(name); host = gethostbyname(name);
if (host) if (host)
{ {
@ -196,21 +196,21 @@ char *resolver_getip(const char *name, char *buff, int len)
ret = strncpy(buff, temp, len); ret = strncpy(buff, temp, len);
buff [len-1] = '\0'; buff [len-1] = '\0';
} }
thread_mutex_unlock(&_resolver_mutex); thread_mutex_unlock(&igloo__resolver_mutex);
return ret; return ret;
} }
#endif #endif
void resolver_initialize() void igloo_resolver_initialize()
{ {
/* initialize the lib if we havne't done so already */ /* initialize the lib if we havne't done so already */
if (!_initialized) if (!igloo__initialized)
{ {
_initialized = 1; igloo__initialized = 1;
thread_mutex_create (&_resolver_mutex); thread_mutex_create (&igloo__resolver_mutex);
/* keep dns connects (TCP) open */ /* keep dns connects (TCP) open */
#ifdef HAVE_SETHOSTENT #ifdef HAVE_SETHOSTENT
@ -219,12 +219,12 @@ void resolver_initialize()
} }
} }
void resolver_shutdown(void) void igloo_resolver_shutdown(void)
{ {
if (_initialized) if (igloo__initialized)
{ {
thread_mutex_destroy(&_resolver_mutex); igloo_thread_mutex_destroy(&igloo__resolver_mutex);
_initialized = 0; igloo__initialized = 0;
#ifdef HAVE_ENDHOSTENT #ifdef HAVE_ENDHOSTENT
endhostent(); endhostent();
#endif #endif

8
net/resolver.h
View File

@ -39,11 +39,11 @@
** **
*/ */
void resolver_initialize(void); void igloo_resolver_initialize(void);
void resolver_shutdown(void); void igloo_resolver_shutdown(void);
char *resolver_getname(const char *ip, char *buff, int len); char *igloo_resolver_getname(const char *ip, char *buff, int len);
char *resolver_getip(const char *name, char *buff, int len); char *igloo_resolver_getip(const char *name, char *buff, int len);
#endif #endif

186
net/sock.c
View File

@ -67,60 +67,60 @@
# define AI_ADDRCONFIG 0 # define AI_ADDRCONFIG 0
#endif #endif
/* sock_initialize /* igloo_sock_initialize
** **
** initializes the socket library. you must call this ** initializes the socket library. you must call this
** before using the library! ** before using the library!
*/ */
void sock_initialize(void) void igloo_sock_initialize(void)
{ {
#ifdef _WIN32 #ifdef _WIN32
WSADATA wsad; WSADATA wsad;
WSAStartup(0x0101, &wsad); WSAStartup(0x0101, &wsad);
#endif #endif
resolver_initialize(); igloo_resolver_initialize();
} }
/* sock_shutdown /* igloo_sock_shutdown
** **
** shutdown the socket library. remember to call this when you're ** shutdown the socket library. remember to call this when you're
** through using the lib ** through using the lib
*/ */
void sock_shutdown(void) void igloo_sock_shutdown(void)
{ {
#ifdef _WIN32 #ifdef _WIN32
WSACleanup(); WSACleanup();
#endif #endif
resolver_shutdown(); igloo_resolver_shutdown();
} }
/* sock_get_localip /* igloo_sock_get_localip
** **
** gets the local ip address for the machine ** gets the local ip address for the machine
** the ip it returns *should* be on the internet. ** the ip it returns *should* be on the internet.
** in any case, it's as close as we can hope to get ** in any case, it's as close as we can hope to get
** unless someone has better ideas on how to do this ** unless someone has better ideas on how to do this
*/ */
char *sock_get_localip(char *buff, int len) char *igloo_sock_get_localip(char *buff, int len)
{ {
char temp[1024]; char temp[1024];
if (gethostname(temp, sizeof(temp)) != 0) if (gethostname(temp, sizeof(temp)) != 0)
return NULL; return NULL;
if (resolver_getip(temp, buff, len)) if (igloo_resolver_getip(temp, buff, len))
return buff; return buff;
return NULL; return NULL;
} }
/* sock_error /* igloo_sock_error
** **
** returns the last socket error ** returns the last socket error
*/ */
int sock_error(void) int igloo_sock_error(void)
{ {
#ifdef _WIN32 #ifdef _WIN32
return WSAGetLastError(); return WSAGetLastError();
@ -129,7 +129,7 @@ int sock_error(void)
#endif #endif
} }
void sock_set_error(int val) void igloo_sock_set_error(int val)
{ {
#ifdef _WIN32 #ifdef _WIN32
WSASetLastError (val); WSASetLastError (val);
@ -138,12 +138,12 @@ void sock_set_error(int val)
#endif #endif
} }
/* sock_recoverable /* igloo_sock_recoverable
** **
** determines if the socket error is recoverable ** determines if the socket error is recoverable
** in terms of non blocking sockets ** in terms of non blocking sockets
*/ */
int sock_recoverable(int error) int igloo_sock_recoverable(int error)
{ {
switch (error) switch (error)
{ {
@ -169,7 +169,7 @@ int sock_recoverable(int error)
} }
} }
int sock_stalled (int error) int igloo_sock_stalled (int error)
{ {
switch (error) switch (error)
{ {
@ -200,11 +200,11 @@ static int sock_connect_pending (int error)
return error == EINPROGRESS || error == EALREADY; return error == EINPROGRESS || error == EALREADY;
} }
/* sock_valid_socket /* igloo_sock_valid_socket
** **
** determines if a sock_t represents a valid socket ** determines if a sock_t represents a valid socket
*/ */
int sock_valid_socket(sock_t sock) int igloo_sock_valid_socket(sock_t sock)
{ {
int ret; int ret;
int optval; int optval;
@ -219,7 +219,7 @@ int sock_valid_socket(sock_t sock)
/* determines if the passed socket is still connected */ /* determines if the passed socket is still connected */
int sock_active (sock_t sock) int igloo_sock_active (sock_t sock)
{ {
char c; char c;
int l; int l;
@ -227,7 +227,7 @@ int sock_active (sock_t sock)
l = recv (sock, &c, 1, MSG_PEEK); l = recv (sock, &c, 1, MSG_PEEK);
if (l == 0) if (l == 0)
return 0; return 0;
if (l == SOCK_ERROR && sock_recoverable (sock_error())) if (l == SOCK_ERROR && igloo_sock_recoverable (igloo_sock_error()))
return 1; return 1;
return 0; return 0;
} }
@ -251,13 +251,13 @@ int inet_aton(const char *s, struct in_addr *a)
} }
#endif /* _WIN32 */ #endif /* _WIN32 */
/* sock_set_blocking /* igloo_sock_set_blocking
* *
* set the sock blocking or nonblocking * set the sock blocking or nonblocking
* 1 for blocking * 1 for blocking
* 0 for nonblocking * 0 for nonblocking
*/ */
int sock_set_blocking(sock_t sock, int block) int igloo_sock_set_blocking(sock_t sock, int block)
{ {
#ifdef _WIN32 #ifdef _WIN32
#ifdef __MINGW32__ #ifdef __MINGW32__
@ -267,7 +267,7 @@ int sock_set_blocking(sock_t sock, int block)
#endif #endif
#endif #endif
if ((!sock_valid_socket(sock)) || (block < 0) || (block > 1)) if ((!igloo_sock_valid_socket(sock)) || (block < 0) || (block > 1))
return SOCK_ERROR; return SOCK_ERROR;
#ifdef _WIN32 #ifdef _WIN32
@ -278,14 +278,14 @@ int sock_set_blocking(sock_t sock, int block)
#endif #endif
} }
int sock_set_nolinger(sock_t sock) int igloo_sock_set_nolinger(sock_t sock)
{ {
struct linger lin = { 0, 0 }; struct linger lin = { 0, 0 };
return setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *)&lin, return setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *)&lin,
sizeof(struct linger)); sizeof(struct linger));
} }
int sock_set_nodelay(sock_t sock) int igloo_sock_set_nodelay(sock_t sock)
{ {
int nodelay = 1; int nodelay = 1;
@ -293,18 +293,18 @@ int sock_set_nodelay(sock_t sock)
sizeof(int)); sizeof(int));
} }
int sock_set_keepalive(sock_t sock) int igloo_sock_set_keepalive(sock_t sock)
{ {
int keepalive = 1; int keepalive = 1;
return setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive, return setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepalive,
sizeof(int)); sizeof(int));
} }
/* sock_close /* igloo_sock_close
** **
** close the socket ** close the socket
*/ */
int sock_close(sock_t sock) int igloo_sock_close(sock_t sock)
{ {
#ifdef _WIN32 #ifdef _WIN32
return closesocket(sock); return closesocket(sock);
@ -313,20 +313,20 @@ int sock_close(sock_t sock)
#endif #endif
} }
/* sock_writev /* igloo_sock_writev
* *
* write multiple buffers at once, return bytes actually written * write multiple buffers at once, return bytes actually written
*/ */
#ifdef HAVE_WRITEV #ifdef HAVE_WRITEV
ssize_t sock_writev (sock_t sock, const struct iovec *iov, size_t count) ssize_t igloo_sock_writev (sock_t sock, const struct iovec *iov, size_t count)
{ {
return writev (sock, iov, count); return writev (sock, iov, count);
} }
#else #else
ssize_t sock_writev (sock_t sock, const struct iovec *iov, size_t count) ssize_t igloo_sock_writev (sock_t sock, const struct iovec *iov, size_t count)
{ {
int i = count, accum = 0, ret; int i = count, accum = 0, ret;
const struct iovec *v = iov; const struct iovec *v = iov;
@ -335,7 +335,7 @@ ssize_t sock_writev (sock_t sock, const struct iovec *iov, size_t count)
{ {
if (v->iov_base && v->iov_len) if (v->iov_base && v->iov_len)
{ {
ret = sock_write_bytes (sock, v->iov_base, v->iov_len); ret = igloo_sock_write_bytes (sock, v->iov_base, v->iov_len);
if (ret == -1 && accum==0) if (ret == -1 && accum==0)
return -1; return -1;
if (ret == -1) if (ret == -1)
@ -352,55 +352,55 @@ ssize_t sock_writev (sock_t sock, const struct iovec *iov, size_t count)
#endif #endif
/* sock_write_bytes /* igloo_sock_write_bytes
** **
** write bytes to the socket ** write bytes to the socket
** this function will _NOT_ block ** this function will _NOT_ block
*/ */
int sock_write_bytes(sock_t sock, const void *buff, size_t len) int igloo_sock_write_bytes(sock_t sock, const void *buff, size_t len)
{ {
/* sanity check */ /* sanity check */
if (!buff) { if (!buff) {
return SOCK_ERROR; return SOCK_ERROR;
} else if (len <= 0) { } else if (len <= 0) {
return SOCK_ERROR; return SOCK_ERROR;
} /*else if (!sock_valid_socket(sock)) { } /*else if (!igloo_sock_valid_socket(sock)) {
return SOCK_ERROR; return SOCK_ERROR;
} */ } */
return send(sock, buff, len, 0); return send(sock, buff, len, 0);
} }
/* sock_write_string /* igloo_sock_write_string
** **
** writes a string to a socket ** writes a string to a socket
** This function must only be called with a blocking socket. ** This function must only be called with a blocking socket.
*/ */
int sock_write_string(sock_t sock, const char *buff) int igloo_sock_write_string(sock_t sock, const char *buff)
{ {
return (sock_write_bytes(sock, buff, strlen(buff)) > 0); return (igloo_sock_write_bytes(sock, buff, strlen(buff)) > 0);
} }
/* sock_write /* igloo_sock_write
** **
** write a formatted string to the socket ** write a formatted string to the socket
** this function must only be called with a blocking socket. ** this function must only be called with a blocking socket.
** will truncate the string if it's greater than 1024 chars. ** will truncate the string if it's greater than 1024 chars.
*/ */
int sock_write(sock_t sock, const char *fmt, ...) int igloo_sock_write(sock_t sock, const char *fmt, ...)
{ {
int rc; int rc;
va_list ap; va_list ap;
va_start (ap, fmt); va_start (ap, fmt);
rc = sock_write_fmt (sock, fmt, ap); rc = igloo_sock_write_fmt (sock, fmt, ap);
va_end (ap); va_end (ap);
return rc; return rc;
} }
#ifdef HAVE_OLD_VSNPRINTF #ifdef HAVE_OLD_VSNPRINTF
int sock_write_fmt(sock_t sock, const char *fmt, va_list ap) int igloo_sock_write_fmt(sock_t sock, const char *fmt, va_list ap)
{ {
va_list ap_local; va_list ap_local;
unsigned int len = 1024; unsigned int len = 1024;
@ -419,7 +419,7 @@ int sock_write_fmt(sock_t sock, const char *fmt, va_list ap)
ret = vsnprintf (buff, len, fmt, ap_local); ret = vsnprintf (buff, len, fmt, ap_local);
if (ret > 0) if (ret > 0)
{ {
ret = sock_write_bytes (sock, buff, ret); ret = igloo_sock_write_bytes (sock, buff, ret);
break; break;
} }
len += 8192; len += 8192;
@ -428,7 +428,7 @@ int sock_write_fmt(sock_t sock, const char *fmt, va_list ap)
return ret; return ret;
} }
#else #else
int sock_write_fmt(sock_t sock, const char *fmt, va_list ap) int igloo_sock_write_fmt(sock_t sock, const char *fmt, va_list ap)
{ {
char buffer [1024], *buff = buffer; char buffer [1024], *buff = buffer;
int len; int len;
@ -442,7 +442,7 @@ int sock_write_fmt(sock_t sock, const char *fmt, va_list ap)
if (len > 0) if (len > 0)
{ {
if ((size_t)len < sizeof (buffer)) /* common case */ if ((size_t)len < sizeof (buffer)) /* common case */
rc = sock_write_bytes(sock, buff, (size_t)len); rc = igloo_sock_write_bytes(sock, buff, (size_t)len);
else else
{ {
/* truncated */ /* truncated */
@ -451,7 +451,7 @@ int sock_write_fmt(sock_t sock, const char *fmt, va_list ap)
{ {
len = vsnprintf (buff, len, fmt, ap_retry); len = vsnprintf (buff, len, fmt, ap_retry);
if (len > 0) if (len > 0)
rc = sock_write_bytes (sock, buff, len); rc = igloo_sock_write_bytes (sock, buff, len);
free (buff); free (buff);
} }
} }
@ -463,17 +463,17 @@ int sock_write_fmt(sock_t sock, const char *fmt, va_list ap)
#endif #endif
int sock_read_bytes(sock_t sock, char *buff, size_t len) int igloo_sock_read_bytes(sock_t sock, char *buff, size_t len)
{ {
/*if (!sock_valid_socket(sock)) return 0; */ /*if (!igloo_sock_valid_socket(sock)) return 0; */
if (!buff) return 0; if (!buff) return 0;
if (len <= 0) return 0; if (len <= 0) return 0;
return recv(sock, buff, len, 0); return recv(sock, buff, len, 0);
} }
/* sock_read_line /* igloo_sock_read_line
** **
** Read one line of at max len bytes from sock into buff. ** Read one line of at max len bytes from sock into buff.
** If ok, return 1 and nullterminate buff. Otherwize return 0. ** If ok, return 1 and nullterminate buff. Otherwize return 0.
@ -481,12 +481,12 @@ int sock_read_bytes(sock_t sock, char *buff, size_t len)
** **
** this function will probably not work on sockets in nonblocking mode ** this function will probably not work on sockets in nonblocking mode
*/ */
int sock_read_line(sock_t sock, char *buff, const int len) int igloo_sock_read_line(sock_t sock, char *buff, const int len)
{ {
char c = '\0'; char c = '\0';
int read_bytes, pos; int read_bytes, pos;
/*if (!sock_valid_socket(sock)) { /*if (!igloo_sock_valid_socket(sock)) {
return 0; return 0;
} else*/ if (!buff) { } else*/ if (!buff) {
return 0; return 0;
@ -523,7 +523,7 @@ int sock_read_line(sock_t sock, char *buff, const int len)
* return 1 for ok * return 1 for ok
*/ */
#ifdef HAVE_POLL #ifdef HAVE_POLL
int sock_connected (sock_t sock, int timeout) int igloo_sock_connected (sock_t sock, int timeout)
{ {
struct pollfd check; struct pollfd check;
int val = SOCK_ERROR; int val = SOCK_ERROR;
@ -540,11 +540,11 @@ int sock_connected (sock_t sock, int timeout)
{ {
if (val == 0) if (val == 0)
return 1; return 1;
sock_set_error (val); igloo_sock_set_error (val);
} }
/* fall through */ /* fall through */
case -1: case -1:
if (sock_recoverable (sock_error())) if (igloo_sock_recoverable (igloo_sock_error()))
return 0; return 0;
return SOCK_ERROR; return SOCK_ERROR;
} }
@ -552,7 +552,7 @@ int sock_connected (sock_t sock, int timeout)
#else #else
int sock_connected (sock_t sock, int timeout) int igloo_sock_connected (sock_t sock, int timeout)
{ {
fd_set wfds; fd_set wfds;
int val = SOCK_ERROR; int val = SOCK_ERROR;
@ -580,25 +580,25 @@ int sock_connected (sock_t sock, int timeout)
{ {
if (val == 0) if (val == 0)
return 1; return 1;
sock_set_error (val); igloo_sock_set_error (val);
} }
/* fall through */ /* fall through */
case -1: case -1:
if (sock_recoverable (sock_error())) if (igloo_sock_recoverable (igloo_sock_error()))
return 0; return 0;
return SOCK_ERROR; return SOCK_ERROR;
} }
} }
#endif #endif
sock_t sock_connect_wto (const char *hostname, int port, int timeout) sock_t igloo_sock_connect_wto (const char *hostname, int port, int timeout)
{ {
return sock_connect_wto_bind(hostname, port, NULL, timeout); return igloo_sock_connect_wto_bind(hostname, port, NULL, timeout);
} }
#ifdef HAVE_GETADDRINFO #ifdef HAVE_GETADDRINFO
sock_t sock_connect_non_blocking (const char *hostname, unsigned port) sock_t igloo_sock_connect_non_blocking (const char *hostname, unsigned port)
{ {
int sock = SOCK_ERROR; int sock = SOCK_ERROR;
struct addrinfo *ai, *head, hints; struct addrinfo *ai, *head, hints;
@ -619,11 +619,11 @@ sock_t sock_connect_non_blocking (const char *hostname, unsigned port)
if ((sock = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol)) if ((sock = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol))
> -1) > -1)
{ {
sock_set_blocking (sock, 0); igloo_sock_set_blocking (sock, 0);
if (connect(sock, ai->ai_addr, ai->ai_addrlen) < 0 && if (connect(sock, ai->ai_addr, ai->ai_addrlen) < 0 &&
!sock_connect_pending(sock_error())) !sock_connect_pending(igloo_sock_error()))
{ {
sock_close (sock); igloo_sock_close (sock);
sock = SOCK_ERROR; sock = SOCK_ERROR;
} }
else else
@ -640,7 +640,7 @@ sock_t sock_connect_non_blocking (const char *hostname, unsigned port)
* timeout is 0 or less then we will wait until the OS gives up on the connect * timeout is 0 or less then we will wait until the OS gives up on the connect
* The socket is returned * The socket is returned
*/ */
sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, int timeout) sock_t igloo_sock_connect_wto_bind (const char *hostname, int port, const char *bnd, int timeout)
{ {
sock_t sock = SOCK_ERROR; sock_t sock = SOCK_ERROR;
struct addrinfo *ai, *head, *b_head=NULL, hints; struct addrinfo *ai, *head, *b_head=NULL, hints;
@ -660,7 +660,7 @@ sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, i
if ((sock = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol)) >= 0) if ((sock = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol)) >= 0)
{ {
if (timeout > 0) if (timeout > 0)
sock_set_blocking (sock, 0); igloo_sock_set_blocking (sock, 0);
if (bnd) if (bnd)
{ {
@ -672,7 +672,7 @@ sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, i
if (getaddrinfo (bnd, NULL, &b_hints, &b_head) || if (getaddrinfo (bnd, NULL, &b_hints, &b_head) ||
bind (sock, b_head->ai_addr, b_head->ai_addrlen) < 0) bind (sock, b_head->ai_addr, b_head->ai_addrlen) < 0)
{ {
sock_close (sock); igloo_sock_close (sock);
sock = SOCK_ERROR; sock = SOCK_ERROR;
break; break;
} }
@ -684,19 +684,19 @@ sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, i
/* loop as the connect maybe async */ /* loop as the connect maybe async */
while (sock != SOCK_ERROR) while (sock != SOCK_ERROR)
{ {
if (sock_recoverable (sock_error())) if (igloo_sock_recoverable (igloo_sock_error()))
{ {
int connected = sock_connected (sock, timeout); int connected = igloo_sock_connected (sock, timeout);
if (connected == 0) /* try again, interrupted */ if (connected == 0) /* try again, interrupted */
continue; continue;
if (connected == 1) /* connected */ if (connected == 1) /* connected */
{ {
if (timeout >= 0) if (timeout >= 0)
sock_set_blocking(sock, 1); igloo_sock_set_blocking(sock, 1);
break; break;
} }
} }
sock_close (sock); igloo_sock_close (sock);
sock = SOCK_ERROR; sock = SOCK_ERROR;
} }
if (sock != SOCK_ERROR) if (sock != SOCK_ERROR)
@ -712,7 +712,7 @@ sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, i
} }
sock_t sock_get_server_socket (int port, const char *sinterface) sock_t igloo_sock_get_server_socket (int port, const char *sinterface)
{ {
struct sockaddr_storage sa; struct sockaddr_storage sa;
struct addrinfo hints, *res, *ai; struct addrinfo hints, *res, *ai;
@ -748,7 +748,7 @@ sock_t sock_get_server_socket (int port, const char *sinterface)
if (bind (sock, ai->ai_addr, ai->ai_addrlen) < 0) if (bind (sock, ai->ai_addr, ai->ai_addrlen) < 0)
{ {
sock_close (sock); igloo_sock_close (sock);
continue; continue;
} }
freeaddrinfo (res); freeaddrinfo (res);
@ -775,15 +775,15 @@ int sock_try_connection (sock_t sock, const char *hostname, unsigned int port)
memset(&sin, 0, sizeof(struct sockaddr_in)); memset(&sin, 0, sizeof(struct sockaddr_in));
memset(&server, 0, sizeof(struct sockaddr_in)); memset(&server, 0, sizeof(struct sockaddr_in));
if (!resolver_getip(hostname, ip, MAX_ADDR_LEN)) if (!igloo_resolver_getip(hostname, ip, MAX_ADDR_LEN))
{ {
sock_close (sock); igloo_sock_close (sock);
return -1; return -1;
} }
if (inet_aton(ip, (struct in_addr *)&sin.sin_addr) == 0) if (inet_aton(ip, (struct in_addr *)&sin.sin_addr) == 0)
{ {
sock_close(sock); igloo_sock_close(sock);
return -1; return -1;
} }
@ -795,7 +795,7 @@ int sock_try_connection (sock_t sock, const char *hostname, unsigned int port)
return connect(sock, (struct sockaddr *)&server, sizeof(server)); return connect(sock, (struct sockaddr *)&server, sizeof(server));
} }
sock_t sock_connect_non_blocking (const char *hostname, unsigned port) sock_t igloo_sock_connect_non_blocking (const char *hostname, unsigned port)
{ {
sock_t sock; sock_t sock;
@ -803,13 +803,13 @@ sock_t sock_connect_non_blocking (const char *hostname, unsigned port)
if (sock == SOCK_ERROR) if (sock == SOCK_ERROR)
return SOCK_ERROR; return SOCK_ERROR;
sock_set_blocking (sock, 0); igloo_sock_set_blocking (sock, 0);
sock_try_connection (sock, hostname, port); sock_try_connection (sock, hostname, port);
return sock; return sock;
} }
sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, int timeout) sock_t igloo_sock_connect_wto_bind (const char *hostname, int port, const char *bnd, int timeout)
{ {
sock_t sock; sock_t sock;
@ -827,30 +827,30 @@ sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, i
if (inet_aton (bnd, &sa.sin_addr) == 0 || if (inet_aton (bnd, &sa.sin_addr) == 0 ||
bind (sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) bind (sock, (struct sockaddr *)&sa, sizeof(sa)) < 0)
{ {
sock_close (sock); igloo_sock_close (sock);
return SOCK_ERROR; return SOCK_ERROR;
} }
} }
if (timeout) if (timeout)
{ {
sock_set_blocking (sock, 0); igloo_sock_set_blocking (sock, 0);
if (sock_try_connection (sock, hostname, port) < 0) if (sock_try_connection (sock, hostname, port) < 0)
{ {
int ret = sock_connected (sock, timeout); int ret = igloo_sock_connected (sock, timeout);
if (ret <= 0) if (ret <= 0)
{ {
sock_close (sock); igloo_sock_close (sock);
return SOCK_ERROR; return SOCK_ERROR;
} }
} }
sock_set_blocking(sock, 1); igloo_sock_set_blocking(sock, 1);
} }
else else
{ {
if (sock_try_connection (sock, hostname, port) < 0) if (sock_try_connection (sock, hostname, port) < 0)
{ {
sock_close (sock); igloo_sock_close (sock);
sock = SOCK_ERROR; sock = SOCK_ERROR;
} }
} }
@ -858,13 +858,13 @@ sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, i
} }
/* sock_get_server_socket /* igloo_sock_get_server_socket
** **
** create a socket for incoming requests on a specified port and ** create a socket for incoming requests on a specified port and
** interface. if interface is null, listen on all interfaces. ** interface. if interface is null, listen on all interfaces.
** returns the socket, or SOCK_ERROR on failure ** returns the socket, or SOCK_ERROR on failure
*/ */
sock_t sock_get_server_socket(int port, const char *sinterface) sock_t igloo_sock_get_server_socket(int port, const char *sinterface)
{ {
struct sockaddr_in sa; struct sockaddr_in sa;
int error, opt; int error, opt;
@ -879,7 +879,7 @@ sock_t sock_get_server_socket(int port, const char *sinterface)
/* set the interface to bind to if specified */ /* set the interface to bind to if specified */
if (sinterface != NULL) { if (sinterface != NULL) {
if (!resolver_getip(sinterface, ip, sizeof (ip))) if (!igloo_resolver_getip(sinterface, ip, sizeof (ip)))
return SOCK_ERROR; return SOCK_ERROR;
if (!inet_aton(ip, &sa.sin_addr)) { if (!inet_aton(ip, &sa.sin_addr)) {
@ -913,14 +913,14 @@ sock_t sock_get_server_socket(int port, const char *sinterface)
#endif #endif
void sock_set_send_buffer (sock_t sock, int win_size) void igloo_sock_set_send_buffer (sock_t sock, int win_size)
{ {
setsockopt (sock, SOL_SOCKET, SO_SNDBUF, (char *) &win_size, sizeof(win_size)); setsockopt (sock, SOL_SOCKET, SO_SNDBUF, (char *) &win_size, sizeof(win_size));
} }
int sock_listen(sock_t serversock, int backlog) int igloo_sock_listen(sock_t serversock, int backlog)
{ {
if (!sock_valid_socket(serversock)) if (!igloo_sock_valid_socket(serversock))
return 0; return 0;
if (backlog <= 0) if (backlog <= 0)
@ -929,7 +929,7 @@ int sock_listen(sock_t serversock, int backlog)
return (listen(serversock, backlog) == 0); return (listen(serversock, backlog) == 0);
} }
sock_t sock_accept(sock_t serversock, char *ip, size_t len) sock_t igloo_sock_accept(sock_t serversock, char *ip, size_t len)
{ {
#ifdef HAVE_GETNAMEINFO #ifdef HAVE_GETNAMEINFO
struct sockaddr_storage sa; struct sockaddr_storage sa;
@ -939,7 +939,7 @@ sock_t sock_accept(sock_t serversock, char *ip, size_t len)
sock_t ret; sock_t ret;
socklen_t slen; socklen_t slen;
if (ip == NULL || len == 0 || !sock_valid_socket(serversock)) if (ip == NULL || len == 0 || !igloo_sock_valid_socket(serversock))
return SOCK_ERROR; return SOCK_ERROR;
slen = sizeof(sa); slen = sizeof(sa);
@ -954,8 +954,8 @@ sock_t sock_accept(sock_t serversock, char *ip, size_t len)
/* inet_ntoa is not reentrant, we should protect this */ /* inet_ntoa is not reentrant, we should protect this */
strncpy(ip, inet_ntoa(sa.sin_addr), len); strncpy(ip, inet_ntoa(sa.sin_addr), len);
#endif #endif
sock_set_nolinger(ret); igloo_sock_set_nolinger(ret);
sock_set_keepalive(ret); igloo_sock_set_keepalive(ret);
} }
return ret; return ret;

60
net/sock.h
View File

@ -72,47 +72,47 @@ struct iovec
#define SOCK_TIMEOUT -2 #define SOCK_TIMEOUT -2
/* sock connect macro */ /* sock connect macro */
#define sock_connect(h, p) sock_connect_wto(h, p, 0) #define sock_connect(h, p) igloo_sock_connect_wto(h, p, 0)
/* Misc socket functions */ /* Misc socket functions */
void sock_initialize(void); void igloo_sock_initialize(void);
void sock_shutdown(void); void igloo_sock_shutdown(void);
char *sock_get_localip(char *buff, int len); char *igloo_sock_get_localip(char *buff, int len);
int sock_error(void); int igloo_sock_error(void);
int sock_recoverable(int error); int igloo_sock_recoverable(int error);
int sock_stalled(int error); int igloo_sock_stalled(int error);
int sock_valid_socket(sock_t sock); int igloo_sock_valid_socket(sock_t sock);
int sock_active (sock_t sock); int igloo_sock_active (sock_t sock);
int sock_set_blocking(sock_t sock, int block); int igloo_sock_set_blocking(sock_t sock, int block);
int sock_set_nolinger(sock_t sock); int igloo_sock_set_nolinger(sock_t sock);
int sock_set_keepalive(sock_t sock); int igloo_sock_set_keepalive(sock_t sock);
int sock_set_nodelay(sock_t sock); int igloo_sock_set_nodelay(sock_t sock);
void sock_set_send_buffer (sock_t sock, int win_size); void igloo_sock_set_send_buffer (sock_t sock, int win_size);
void sock_set_error(int val); void igloo_sock_set_error(int val);
int sock_close(sock_t sock); int igloo_sock_close(sock_t sock);
/* Connection related socket functions */ /* Connection related socket functions */
sock_t sock_connect_wto(const char *hostname, int port, int timeout); sock_t igloo_sock_connect_wto(const char *hostname, int port, int timeout);
sock_t sock_connect_wto_bind(const char *hostname, int port, const char *bnd, int timeout); sock_t igloo_sock_connect_wto_bind(const char *hostname, int port, const char *bnd, int timeout);
sock_t sock_connect_non_blocking(const char *host, unsigned port); sock_t igloo_sock_connect_non_blocking(const char *host, unsigned port);
int sock_connected(sock_t sock, int timeout); int igloo_sock_connected(sock_t sock, int timeout);
/* Socket write functions */ /* Socket write functions */
int sock_write_bytes(sock_t sock, const void *buff, size_t len); int igloo_sock_write_bytes(sock_t sock, const void *buff, size_t len);
int sock_write(sock_t sock, const char *fmt, ...); int igloo_sock_write(sock_t sock, const char *fmt, ...);
int sock_write_fmt(sock_t sock, const char *fmt, va_list ap); int igloo_sock_write_fmt(sock_t sock, const char *fmt, va_list ap);
int sock_write_string(sock_t sock, const char *buff); int igloo_sock_write_string(sock_t sock, const char *buff);
ssize_t sock_writev (sock_t sock, const struct iovec *iov, size_t count); ssize_t igloo_sock_writev (sock_t sock, const struct iovec *iov, size_t count);
/* Socket read functions */ /* Socket read functions */
int sock_read_bytes(sock_t sock, char *buff, size_t len); int igloo_sock_read_bytes(sock_t sock, char *buff, size_t len);
int sock_read_line(sock_t sock, char *string, const int len); int igloo_sock_read_line(sock_t sock, char *string, const int len);
/* server socket functions */ /* server socket functions */
sock_t sock_get_server_socket(int port, const char *sinterface); sock_t igloo_sock_get_server_socket(int port, const char *sinterface);
int sock_listen(sock_t serversock, int backlog); int igloo_sock_listen(sock_t serversock, int backlog);
sock_t sock_accept(sock_t serversock, char *ip, size_t len); sock_t igloo_sock_accept(sock_t serversock, char *ip, size_t len);
#ifdef _WIN32 #ifdef _WIN32
int inet_aton(const char *s, struct in_addr *a); int inet_aton(const char *s, struct in_addr *a);

6
net/test_resolver.c
View File

@ -7,10 +7,10 @@ int main()
{ {
char buff[1024]; char buff[1024];
resolver_initialize(); igloo_resolver_initialize();
printf("I got %s, when looking up %s.\n", resolver_getip("bach.greenwitch.com", buff, 1024), "bach.greenwitch.com"); printf("I got %s, when looking up %s.\n", igloo_resolver_getip("bach.greenwitch.com", buff, 1024), "bach.greenwitch.com");
printf("I got %s, when looking up %s.\n", resolver_getname("207.181.249.14", buff, 1024), "207.181.249.14"); printf("I got %s, when looking up %s.\n", igloo_resolver_getname("207.181.249.14", buff, 1024), "207.181.249.14");
return 0; return 0;
} }

224
thread/thread.c
View File

@ -59,22 +59,22 @@
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
#define CATMODULE "thread" #define CATMODULE "thread"
#define LOG_ERROR(y) log_write(_logid, 1, CATMODULE "/", __FUNCTION__, y) #define LOG_ERROR(y) igloo_log_write(_logid, 1, CATMODULE "/", __FUNCTION__, y)
#define LOG_ERROR3(y, z1, z2, z3) log_write(_logid, 1, CATMODULE "/", __FUNCTION__, y, z1, z2, z3) #define LOG_ERROR3(y, z1, z2, z3) igloo_log_write(_logid, 1, CATMODULE "/", __FUNCTION__, y, z1, z2, z3)
#define LOG_ERROR7(y, z1, z2, z3, z4, z5, z6, z7) log_write(_logid, 1, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5, z6, z7) #define LOG_ERROR7(y, z1, z2, z3, z4, z5, z6, z7) igloo_log_write(_logid, 1, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5, z6, z7)
#define LOG_WARN(y) log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y) #define LOG_WARN(y) igloo_log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y)
#define LOG_WARN3(y, z1, z2, z3) log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y, z1, z2, z3) #define LOG_WARN3(y, z1, z2, z3) igloo_log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y, z1, z2, z3)
#define LOG_WARN5(y, z1, z2, z3, z4, z5) log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5) #define LOG_WARN5(y, z1, z2, z3, z4, z5) igloo_log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5)
#define LOG_WARN7(y, z1, z2, z3, z4, z5, z6, z7) log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5, z6, z7) #define LOG_WARN7(y, z1, z2, z3, z4, z5, z6, z7) igloo_log_write(_logid, 2, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5, z6, z7)
#define LOG_INFO(y) log_write(_logid, 3, CATMODULE "/", __FUNCTION__, y) #define LOG_INFO(y) igloo_log_write(_logid, 3, CATMODULE "/", __FUNCTION__, y)
#define LOG_INFO4(y, z1, z2, z3, z4) log_write(_logid, 3, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4) #define LOG_INFO4(y, z1, z2, z3, z4) igloo_log_write(_logid, 3, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4)
#define LOG_INFO5(y, z1, z2, z3, z4, z5) log_write(_logid, 3, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5) #define LOG_INFO5(y, z1, z2, z3, z4, z5) igloo_log_write(_logid, 3, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5)
#define LOG_DEBUG(y) log_write(_logid, 4, CATMODULE "/", __FUNCTION__, y) #define LOG_DEBUG(y) igloo_log_write(_logid, 4, CATMODULE "/", __FUNCTION__, y)
#define LOG_DEBUG2(y, z1, z2) log_write(_logid, 4, CATMODULE "/", __FUNCTION__, y, z1, z2) #define LOG_DEBUG2(y, z1, z2) igloo_log_write(_logid, 4, CATMODULE "/", __FUNCTION__, y, z1, z2)
#define LOG_DEBUG5(y, z1, z2, z3, z4, z5) log_write(_logid, 4, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5) #define LOG_DEBUG5(y, z1, z2, z3, z4, z5) igloo_log_write(_logid, 4, CATMODULE "/", __FUNCTION__, y, z1, z2, z3, z4, z5)
#endif #endif
/* thread starting structure */ /* thread starting structure */
@ -90,15 +90,15 @@ typedef struct thread_start_tag {
pthread_t sys_thread; pthread_t sys_thread;
} thread_start_t; } thread_start_t;
static long _next_thread_id = 0; static long igloo__next_thread_id = 0;
static int _initialized = 0; static int igloo__initialized = 0;
static avl_tree *_threadtree = NULL; static avl_tree *igloo__threadtree = NULL;
#ifdef DEBUG_MUTEXES #ifdef DEBUG_MUTEXES
static mutex_t _threadtree_mutex = { -1, NULL, MUTEX_STATE_UNINIT, NULL, -1, static mutex_t igloo__threadtree_mutex = { -1, NULL, MUTEX_STATE_UNINIT, NULL, -1,
PTHREAD_MUTEX_INITIALIZER}; PTHREAD_MUTEX_INITIALIZER};
#else #else
static mutex_t _threadtree_mutex = { PTHREAD_MUTEX_INITIALIZER }; static mutex_t igloo__threadtree_mutex = { PTHREAD_MUTEX_INITIALIZER };
#endif #endif
@ -113,10 +113,10 @@ static mutex_t _mutextree_mutex = { -1, NULL, MUTEX_STATE_UNINIT, NULL, -1,
#endif #endif
#ifdef DEBUG_MUTEXES #ifdef DEBUG_MUTEXES
static mutex_t _library_mutex = { -1, NULL, MUTEX_STATE_UNINIT, NULL, -1, static mutex_t igloo__library_mutex = { -1, NULL, MUTEX_STATE_UNINIT, NULL, -1,
PTHREAD_MUTEX_INITIALIZER}; PTHREAD_MUTEX_INITIALIZER};
#else #else
static mutex_t _library_mutex = { PTHREAD_MUTEX_INITIALIZER }; static mutex_t igloo__library_mutex = { PTHREAD_MUTEX_INITIALIZER };
#endif #endif
/* INTERNAL FUNCTIONS */ /* INTERNAL FUNCTIONS */
@ -127,8 +127,8 @@ static int _compare_mutexes(void *compare_arg, void *a, void *b);
static int _free_mutex(void *key); static int _free_mutex(void *key);
#endif #endif
static int _compare_threads(void *compare_arg, void *a, void *b); static int igloo__compare_threads(void *compare_arg, void *a, void *b);
static int _free_thread(void *key); static int igloo__free_thread(void *key);
/* mutex fuctions */ /* mutex fuctions */
static void _mutex_create(mutex_t *mutex); static void _mutex_create(mutex_t *mutex);
@ -136,28 +136,28 @@ static void _mutex_lock(mutex_t *mutex);
static void _mutex_unlock(mutex_t *mutex); static void _mutex_unlock(mutex_t *mutex);
/* misc thread stuff */ /* misc thread stuff */
static void *_start_routine(void *arg); static void *igloo__start_routine(void *arg);
static void _catch_signals(void); static void _catch_signals(void);
static void _block_signals(void); static void _block_signals(void);
/* LIBRARY INITIALIZATION */ /* LIBRARY INITIALIZATION */
void thread_initialize(void) void igloo_thread_initialize(void)
{ {
thread_type *thread; thread_type *thread;
/* set up logging */ /* set up logging */
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
log_initialize(); igloo_log_initialize();
_logid = log_open("thread.log"); _logid = igloo_log_open("thread.log");
log_set_level(_logid, THREAD_DEBUG); igloo_log_set_level(_logid, THREAD_DEBUG);
#endif #endif
#ifdef DEBUG_MUTEXES #ifdef DEBUG_MUTEXES
/* create all the internal mutexes, and initialize the mutex tree */ /* create all the internal mutexes, and initialize the mutex tree */
_mutextree = avl_tree_new(_compare_mutexes, NULL); _mutextree = igloo_avl_tree_new(_compare_mutexes, NULL);
/* we have to create this one by hand, because there's no /* we have to create this one by hand, because there's no
** mutextree_mutex to lock yet! ** mutextree_mutex to lock yet!
@ -165,49 +165,49 @@ void thread_initialize(void)
_mutex_create(&_mutextree_mutex); _mutex_create(&_mutextree_mutex);
_mutextree_mutex.mutex_id = _next_mutex_id++; _mutextree_mutex.mutex_id = _next_mutex_id++;
avl_insert(_mutextree, (void *)&_mutextree_mutex); igloo_avl_insert(_mutextree, (void *)&_mutextree_mutex);
#endif #endif
thread_mutex_create(&_threadtree_mutex); thread_mutex_create(&igloo__threadtree_mutex);
thread_mutex_create(&_library_mutex); thread_mutex_create(&igloo__library_mutex);
/* initialize the thread tree and insert the main thread */ /* initialize the thread tree and insert the main thread */
_threadtree = avl_tree_new(_compare_threads, NULL); igloo__threadtree = igloo_avl_tree_new(igloo__compare_threads, NULL);
thread = (thread_type *)malloc(sizeof(thread_type)); thread = (thread_type *)malloc(sizeof(thread_type));
thread->thread_id = _next_thread_id++; thread->thread_id = igloo__next_thread_id++;
thread->line = 0; thread->line = 0;
thread->file = strdup("main.c"); thread->file = strdup("main.c");
thread->sys_thread = pthread_self(); thread->sys_thread = pthread_self();
thread->create_time = time(NULL); thread->create_time = time(NULL);
thread->name = strdup("Main Thread"); thread->name = strdup("Main Thread");
avl_insert(_threadtree, (void *)thread); igloo_avl_insert(igloo__threadtree, (void *)thread);
_catch_signals(); _catch_signals();
_initialized = 1; igloo__initialized = 1;
} }
void thread_shutdown(void) void igloo_thread_shutdown(void)
{ {
if (_initialized == 1) { if (igloo__initialized == 1) {
thread_mutex_destroy(&_library_mutex); igloo_thread_mutex_destroy(&igloo__library_mutex);
thread_mutex_destroy(&_threadtree_mutex); igloo_thread_mutex_destroy(&igloo__threadtree_mutex);
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
thread_mutex_destroy(&_mutextree_mutex); igloo_thread_mutex_destroy(&_mutextree_mutex);
avl_tree_free(_mutextree, _free_mutex); igloo_avl_tree_free(_mutextree, _free_mutex);
#endif #endif
avl_tree_free(_threadtree, _free_thread); igloo_avl_tree_free(igloo__threadtree, igloo__free_thread);
_threadtree = NULL; igloo__threadtree = NULL;
} }
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
log_close(_logid); igloo_log_close(_logid);
log_shutdown(); igloo_log_shutdown();
#endif #endif
} }
@ -268,7 +268,7 @@ static void _catch_signals(void)
} }
thread_type *thread_create_c(char *name, void *(*start_routine)(void *), thread_type *igloo_thread_create_c(char *name, void *(*start_routine)(void *),
void *arg, int detached, int line, char *file) void *arg, int detached, int line, char *file)
{ {
thread_type *thread = NULL; thread_type *thread = NULL;
@ -288,9 +288,9 @@ thread_type *thread_create_c(char *name, void *(*start_routine)(void *),
thread->line = line; thread->line = line;
thread->file = strdup(file); thread->file = strdup(file);
_mutex_lock (&_threadtree_mutex); _mutex_lock (&igloo__threadtree_mutex);
thread->thread_id = _next_thread_id++; thread->thread_id = igloo__next_thread_id++;
_mutex_unlock (&_threadtree_mutex); _mutex_unlock (&igloo__threadtree_mutex);
thread->name = strdup(name); thread->name = strdup(name);
thread->create_time = time(NULL); thread->create_time = time(NULL);
@ -311,7 +311,7 @@ thread_type *thread_create_c(char *name, void *(*start_routine)(void *),
thread->detached = 1; thread->detached = 1;
} }
if (pthread_create (&thread->sys_thread, &attr, _start_routine, start) == 0) if (pthread_create (&thread->sys_thread, &attr, igloo__start_routine, start) == 0)
{ {
pthread_attr_destroy (&attr); pthread_attr_destroy (&attr);
return thread; return thread;
@ -343,35 +343,35 @@ static void _mutex_create(mutex_t *mutex)
pthread_mutex_init(&mutex->sys_mutex, NULL); pthread_mutex_init(&mutex->sys_mutex, NULL);
} }
void thread_mutex_create_c(mutex_t *mutex, int line, char *file) void igloo_thread_mutex_create_c(mutex_t *mutex, int line, char *file)
{ {
_mutex_create(mutex); _mutex_create(mutex);
#ifdef DEBUG_MUTEXES #ifdef DEBUG_MUTEXES
_mutex_lock(&_mutextree_mutex); _mutex_lock(&_mutextree_mutex);
mutex->mutex_id = _next_mutex_id++; mutex->mutex_id = _next_mutex_id++;
avl_insert(_mutextree, (void *)mutex); igloo_avl_insert(_mutextree, (void *)mutex);
_mutex_unlock(&_mutextree_mutex); _mutex_unlock(&_mutextree_mutex);
#endif #endif
} }
void thread_mutex_destroy (mutex_t *mutex) void igloo_thread_mutex_destroy (mutex_t *mutex)
{ {
pthread_mutex_destroy(&mutex->sys_mutex); pthread_mutex_destroy(&mutex->sys_mutex);
#ifdef DEBUG_MUTEXES #ifdef DEBUG_MUTEXES
_mutex_lock(&_mutextree_mutex); _mutex_lock(&_mutextree_mutex);
avl_delete(_mutextree, mutex, _free_mutex); igloo_avl_delete(_mutextree, mutex, _free_mutex);
_mutex_unlock(&_mutextree_mutex); _mutex_unlock(&_mutextree_mutex);
#endif #endif
} }
void thread_mutex_lock_c(mutex_t *mutex, int line, char *file) void igloo_thread_mutex_lock_c(mutex_t *mutex, int line, char *file)
{ {
#ifdef DEBUG_MUTEXES #ifdef DEBUG_MUTEXES
thread_type *th = thread_self(); thread_type *th = igloo_thread_self();
if (!th) LOG_WARN("No mt record for %u in lock [%s:%d]", thread_self(), file, line); if (!th) LOG_WARN("No mt record for %u in lock [%s:%d]", igloo_thread_self(), file, line);
LOG_DEBUG5("Locking %p (%s) on line %d in file %s by thread %d", mutex, mutex->name, line, file, th ? th->thread_id : -1); LOG_DEBUG5("Locking %p (%s) on line %d in file %s by thread %d", mutex, mutex->name, line, file, th ? th->thread_id : -1);
@ -387,7 +387,7 @@ void thread_mutex_lock_c(mutex_t *mutex, int line, char *file)
_mutex_lock(&_mutextree_mutex); _mutex_lock(&_mutextree_mutex);
node = avl_get_first (_mutextree); node = igloo_avl_get_first (_mutextree);
while (node) { while (node) {
tmutex = (mutex_t *)node->key; tmutex = (mutex_t *)node->key;
@ -406,7 +406,7 @@ void thread_mutex_lock_c(mutex_t *mutex, int line, char *file)
locks++; locks++;
} }
node = avl_get_next(node); node = igloo_avl_get_next(node);
} }
if (locks > 0) { if (locks > 0) {
@ -438,13 +438,13 @@ void thread_mutex_lock_c(mutex_t *mutex, int line, char *file)
#endif /* DEBUG_MUTEXES */ #endif /* DEBUG_MUTEXES */
} }
void thread_mutex_unlock_c(mutex_t *mutex, int line, char *file) void igloo_thread_mutex_unlock_c(mutex_t *mutex, int line, char *file)
{ {
#ifdef DEBUG_MUTEXES #ifdef DEBUG_MUTEXES
thread_type *th = thread_self(); thread_type *th = igloo_thread_self();
if (!th) { if (!th) {
LOG_ERROR3("No record for %u in unlock [%s:%d]", thread_self(), file, line); LOG_ERROR3("No record for %u in unlock [%s:%d]", igloo_thread_self(), file, line);
} }
LOG_DEBUG5("Unlocking %p (%s) on line %d in file %s by thread %d", mutex, mutex->name, line, file, th ? th->thread_id : -1); LOG_DEBUG5("Unlocking %p (%s) on line %d in file %s by thread %d", mutex, mutex->name, line, file, th ? th->thread_id : -1);
@ -473,7 +473,7 @@ void thread_mutex_unlock_c(mutex_t *mutex, int line, char *file)
locks++; locks++;
} }
node = avl_get_next (node); node = igloo_avl_get_next (node);
} }
if ((locks > 0) && (_multi_mutex.thread_id != th->thread_id)) { if ((locks > 0) && (_multi_mutex.thread_id != th->thread_id)) {
@ -503,29 +503,29 @@ void thread_mutex_unlock_c(mutex_t *mutex, int line, char *file)
#endif /* DEBUG_MUTEXES */ #endif /* DEBUG_MUTEXES */
} }
void thread_cond_create_c(cond_t *cond, int line, char *file) void igloo_thread_cond_create_c(cond_t *cond, int line, char *file)
{ {
pthread_cond_init(&cond->sys_cond, NULL); pthread_cond_init(&cond->sys_cond, NULL);
pthread_mutex_init(&cond->cond_mutex, NULL); pthread_mutex_init(&cond->cond_mutex, NULL);
} }
void thread_cond_destroy(cond_t *cond) void igloo_thread_cond_destroy(cond_t *cond)
{ {
pthread_mutex_destroy(&cond->cond_mutex); pthread_mutex_destroy(&cond->cond_mutex);
pthread_cond_destroy(&cond->sys_cond); pthread_cond_destroy(&cond->sys_cond);
} }
void thread_cond_signal_c(cond_t *cond, int line, char *file) void igloo_thread_cond_signal_c(cond_t *cond, int line, char *file)
{ {
pthread_cond_signal(&cond->sys_cond); pthread_cond_signal(&cond->sys_cond);
} }
void thread_cond_broadcast_c(cond_t *cond, int line, char *file) void igloo_thread_cond_broadcast_c(cond_t *cond, int line, char *file)
{ {
pthread_cond_broadcast(&cond->sys_cond); pthread_cond_broadcast(&cond->sys_cond);
} }
void thread_cond_timedwait_c(cond_t *cond, int millis, int line, char *file) void igloo_thread_cond_timedwait_c(cond_t *cond, int millis, int line, char *file)
{ {
struct timespec time; struct timespec time;
@ -537,41 +537,41 @@ void thread_cond_timedwait_c(cond_t *cond, int millis, int line, char *file)
pthread_mutex_unlock(&cond->cond_mutex); pthread_mutex_unlock(&cond->cond_mutex);
} }
void thread_cond_wait_c(cond_t *cond, int line, char *file) void igloo_thread_cond_wait_c(cond_t *cond, int line, char *file)
{ {
pthread_mutex_lock(&cond->cond_mutex); pthread_mutex_lock(&cond->cond_mutex);
pthread_cond_wait(&cond->sys_cond, &cond->cond_mutex); pthread_cond_wait(&cond->sys_cond, &cond->cond_mutex);
pthread_mutex_unlock(&cond->cond_mutex); pthread_mutex_unlock(&cond->cond_mutex);
} }
void thread_rwlock_create_c(rwlock_t *rwlock, int line, char *file) void igloo_thread_rwlock_create_c(rwlock_t *rwlock, int line, char *file)
{ {
pthread_rwlock_init(&rwlock->sys_rwlock, NULL); pthread_rwlock_init(&rwlock->sys_rwlock, NULL);
} }
void thread_rwlock_destroy(rwlock_t *rwlock) void igloo_thread_rwlock_destroy(rwlock_t *rwlock)
{ {
pthread_rwlock_destroy(&rwlock->sys_rwlock); pthread_rwlock_destroy(&rwlock->sys_rwlock);
} }
void thread_rwlock_rlock_c(rwlock_t *rwlock, int line, char *file) void igloo_thread_rwlock_rlock_c(rwlock_t *rwlock, int line, char *file)
{ {
pthread_rwlock_rdlock(&rwlock->sys_rwlock); pthread_rwlock_rdlock(&rwlock->sys_rwlock);
} }
void thread_rwlock_wlock_c(rwlock_t *rwlock, int line, char *file) void igloo_thread_rwlock_wlock_c(rwlock_t *rwlock, int line, char *file)
{ {
pthread_rwlock_wrlock(&rwlock->sys_rwlock); pthread_rwlock_wrlock(&rwlock->sys_rwlock);
} }
void thread_rwlock_unlock_c(rwlock_t *rwlock, int line, char *file) void igloo_thread_rwlock_unlock_c(rwlock_t *rwlock, int line, char *file)
{ {
pthread_rwlock_unlock(&rwlock->sys_rwlock); pthread_rwlock_unlock(&rwlock->sys_rwlock);
} }
void thread_exit_c(long val, int line, char *file) void igloo_thread_exit_c(long val, int line, char *file)
{ {
thread_type *th = thread_self(); thread_type *th = igloo_thread_self();
#if defined(DEBUG_MUTEXES) && defined(CHECK_MUTEXES) #if defined(DEBUG_MUTEXES) && defined(CHECK_MUTEXES)
if (th) { if (th) {
@ -589,7 +589,7 @@ void thread_exit_c(long val, int line, char *file)
th->thread_id, th->name, file, line, mutex_to_string(tmutex, name)); th->thread_id, th->name, file, line, mutex_to_string(tmutex, name));
} }
node = avl_get_next (node); node = igloo_avl_get_next (node);
} }
_mutex_unlock(&_mutextree_mutex); _mutex_unlock(&_mutextree_mutex);
@ -602,16 +602,16 @@ void thread_exit_c(long val, int line, char *file)
LOG_INFO4("Removing thread %d [%s] started at [%s:%d], reason: 'Thread Exited'", th->thread_id, th->name, th->file, th->line); LOG_INFO4("Removing thread %d [%s] started at [%s:%d], reason: 'Thread Exited'", th->thread_id, th->name, th->file, th->line);
#endif #endif
_mutex_lock(&_threadtree_mutex); _mutex_lock(&igloo__threadtree_mutex);
avl_delete(_threadtree, th, _free_thread); igloo_avl_delete(igloo__threadtree, th, igloo__free_thread);
_mutex_unlock(&_threadtree_mutex); _mutex_unlock(&igloo__threadtree_mutex);
} }
pthread_exit ((void*)val); pthread_exit ((void*)val);
} }
/* sleep for a number of microseconds */ /* sleep for a number of microseconds */
void thread_sleep(unsigned long len) void igloo_thread_sleep(unsigned long len)
{ {
#ifdef _WIN32 #ifdef _WIN32
Sleep(len / 1000); Sleep(len / 1000);
@ -642,7 +642,7 @@ void thread_sleep(unsigned long len)
#endif #endif
} }
static void *_start_routine(void *arg) static void *igloo__start_routine(void *arg)
{ {
thread_start_t *start = (thread_start_t *)arg; thread_start_t *start = (thread_start_t *)arg;
void *(*start_routine)(void *) = start->start_routine; void *(*start_routine)(void *) = start->start_routine;
@ -652,10 +652,10 @@ static void *_start_routine(void *arg)
_block_signals(); _block_signals();
/* insert thread into thread tree here */ /* insert thread into thread tree here */
_mutex_lock(&_threadtree_mutex); _mutex_lock(&igloo__threadtree_mutex);
thread->sys_thread = pthread_self(); thread->sys_thread = pthread_self();
avl_insert(_threadtree, (void *)thread); igloo_avl_insert(igloo__threadtree, (void *)thread);
_mutex_unlock(&_threadtree_mutex); _mutex_unlock(&igloo__threadtree_mutex);
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
LOG_INFO4("Added thread %d [%s] started at [%s:%d]", thread->thread_id, thread->name, thread->file, thread->line); LOG_INFO4("Added thread %d [%s] started at [%s:%d]", thread->thread_id, thread->name, thread->file, thread->line);
@ -671,43 +671,43 @@ static void *_start_routine(void *arg)
if (thread->detached) if (thread->detached)
{ {
_mutex_lock (&_threadtree_mutex); _mutex_lock (&igloo__threadtree_mutex);
avl_delete (_threadtree, thread, _free_thread); igloo_avl_delete (igloo__threadtree, thread, igloo__free_thread);
_mutex_unlock (&_threadtree_mutex); _mutex_unlock (&igloo__threadtree_mutex);
} }
return NULL; return NULL;
} }
thread_type *thread_self(void) thread_type *igloo_thread_self(void)
{ {
avl_node *node; avl_node *node;
thread_type *th; thread_type *th;
pthread_t sys_thread = pthread_self(); pthread_t sys_thread = pthread_self();
_mutex_lock(&_threadtree_mutex); _mutex_lock(&igloo__threadtree_mutex);
if (_threadtree == NULL) { if (igloo__threadtree == NULL) {
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
LOG_WARN("Thread tree is empty, this must be wrong!"); LOG_WARN("Thread tree is empty, this must be wrong!");
#endif #endif
_mutex_unlock(&_threadtree_mutex); _mutex_unlock(&igloo__threadtree_mutex);
return NULL; return NULL;
} }
node = avl_get_first(_threadtree); node = igloo_avl_get_first(igloo__threadtree);
while (node) { while (node) {
th = (thread_type *)node->key; th = (thread_type *)node->key;
if (th && pthread_equal(sys_thread, th->sys_thread)) { if (th && pthread_equal(sys_thread, th->sys_thread)) {
_mutex_unlock(&_threadtree_mutex); _mutex_unlock(&igloo__threadtree_mutex);
return th; return th;
} }
node = avl_get_next(node); node = igloo_avl_get_next(node);
} }
_mutex_unlock(&_threadtree_mutex); _mutex_unlock(&igloo__threadtree_mutex);
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
@ -717,11 +717,11 @@ thread_type *thread_self(void)
return NULL; return NULL;
} }
void thread_rename(const char *name) void igloo_thread_rename(const char *name)
{ {
thread_type *th; thread_type *th;
th = thread_self(); th = igloo_thread_self();
if (th->name) free(th->name); if (th->name) free(th->name);
th->name = strdup(name); th->name = strdup(name);
@ -738,24 +738,24 @@ static void _mutex_unlock(mutex_t *mutex)
} }
void thread_library_lock(void) void igloo_thread_library_lock(void)
{ {
_mutex_lock(&_library_mutex); _mutex_lock(&igloo__library_mutex);
} }
void thread_library_unlock(void) void igloo_thread_library_unlock(void)
{ {
_mutex_unlock(&_library_mutex); _mutex_unlock(&igloo__library_mutex);
} }
void thread_join(thread_type *thread) void igloo_thread_join(thread_type *thread)
{ {
void *ret; void *ret;
pthread_join(thread->sys_thread, &ret); pthread_join(thread->sys_thread, &ret);
_mutex_lock(&_threadtree_mutex); _mutex_lock(&igloo__threadtree_mutex);
avl_delete(_threadtree, thread, _free_thread); igloo_avl_delete(igloo__threadtree, thread, igloo__free_thread);
_mutex_unlock(&_threadtree_mutex); _mutex_unlock(&igloo__threadtree_mutex);
} }
/* AVL tree functions */ /* AVL tree functions */
@ -776,7 +776,7 @@ static int _compare_mutexes(void *compare_arg, void *a, void *b)
} }
#endif #endif
static int _compare_threads(void *compare_arg, void *a, void *b) static int igloo__compare_threads(void *compare_arg, void *a, void *b)
{ {
thread_type *t1, *t2; thread_type *t1, *t2;
@ -808,7 +808,7 @@ static int _free_mutex(void *key)
} }
#endif #endif
static int _free_thread(void *key) static int igloo__free_thread(void *key)
{ {
thread_type *t; thread_type *t;
@ -826,26 +826,26 @@ static int _free_thread(void *key)
#ifdef HAVE_PTHREAD_SPIN_LOCK #ifdef HAVE_PTHREAD_SPIN_LOCK
void thread_spin_create (spin_t *spin) void igloo_thread_spin_create (spin_t *spin)
{ {
int x = pthread_spin_init (&spin->lock, PTHREAD_PROCESS_PRIVATE); int x = pthread_spin_init (&spin->lock, PTHREAD_PROCESS_PRIVATE);
if (x) if (x)
abort(); abort();
} }
void thread_spin_destroy (spin_t *spin) void igloo_thread_spin_destroy (spin_t *spin)
{ {
pthread_spin_destroy (&spin->lock); pthread_spin_destroy (&spin->lock);
} }
void thread_spin_lock (spin_t *spin) void igloo_thread_spin_lock (spin_t *spin)
{ {
int x = pthread_spin_lock (&spin->lock); int x = pthread_spin_lock (&spin->lock);
if (x != 0) if (x != 0)
abort(); abort();
} }
void thread_spin_unlock (spin_t *spin) void igloo_thread_spin_unlock (spin_t *spin)
{ {
pthread_spin_unlock (&spin->lock); pthread_spin_unlock (&spin->lock);
} }

96
thread/thread.h
View File

@ -101,32 +101,32 @@ typedef struct
pthread_spinlock_t lock; pthread_spinlock_t lock;
} spin_t; } spin_t;
void thread_spin_create (spin_t *spin); void igloo_thread_spin_create (spin_t *spin);
void thread_spin_destroy (spin_t *spin); void igloo_thread_spin_destroy (spin_t *spin);
void thread_spin_lock (spin_t *spin); void igloo_thread_spin_lock (spin_t *spin);
void thread_spin_unlock (spin_t *spin); void igloo_thread_spin_unlock (spin_t *spin);
#else #else
typedef mutex_t spin_t; typedef mutex_t spin_t;
#define thread_spin_create(x) thread_mutex_create(x) #define igloo_thread_spin_create(x) thread_mutex_create(x)
#define thread_spin_destroy(x) thread_mutex_destroy(x) #define igloo_thread_spin_destroy(x) igloo_thread_mutex_destroy(x)
#define thread_spin_lock(x) thread_mutex_lock(x) #define igloo_thread_spin_lock(x) thread_mutex_lock(x)
#define thread_spin_unlock(x) thread_mutex_unlock(x) #define igloo_thread_spin_unlock(x) thread_mutex_unlock(x)
#endif #endif
#define thread_create(n,x,y,z) thread_create_c(n,x,y,z,__LINE__,__FILE__) #define thread_create(n,x,y,z) igloo_thread_create_c(n,x,y,z,__LINE__,__FILE__)
#define thread_mutex_create(x) thread_mutex_create_c(x,__LINE__,__FILE__) #define thread_mutex_create(x) igloo_thread_mutex_create_c(x,__LINE__,__FILE__)
#define thread_mutex_lock(x) thread_mutex_lock_c(x,__LINE__,__FILE__) #define thread_mutex_lock(x) igloo_thread_mutex_lock_c(x,__LINE__,__FILE__)
#define thread_mutex_unlock(x) thread_mutex_unlock_c(x,__LINE__,__FILE__) #define thread_mutex_unlock(x) igloo_thread_mutex_unlock_c(x,__LINE__,__FILE__)
#define thread_cond_create(x) thread_cond_create_c(x,__LINE__,__FILE__) #define thread_cond_create(x) igloo_thread_cond_create_c(x,__LINE__,__FILE__)
#define thread_cond_signal(x) thread_cond_signal_c(x,__LINE__,__FILE__) #define thread_cond_signal(x) igloo_thread_cond_signal_c(x,__LINE__,__FILE__)
#define thread_cond_broadcast(x) thread_cond_broadcast_c(x,__LINE__,__FILE__) #define thread_cond_broadcast(x) igloo_thread_cond_broadcast_c(x,__LINE__,__FILE__)
#define thread_cond_wait(x) thread_cond_wait_c(x,__LINE__,__FILE__) #define thread_cond_wait(x) igloo_thread_cond_wait_c(x,__LINE__,__FILE__)
#define thread_cond_timedwait(x,t) thread_cond_wait_c(x,t,__LINE__,__FILE__) #define thread_cond_timedwait(x,t) igloo_thread_cond_wait_c(x,t,__LINE__,__FILE__)
#define thread_rwlock_create(x) thread_rwlock_create_c(x,__LINE__,__FILE__) #define thread_rwlock_create(x) igloo_thread_rwlock_create_c(x,__LINE__,__FILE__)
#define thread_rwlock_rlock(x) thread_rwlock_rlock_c(x,__LINE__,__FILE__) #define thread_rwlock_rlock(x) igloo_thread_rwlock_rlock_c(x,__LINE__,__FILE__)
#define thread_rwlock_wlock(x) thread_rwlock_wlock_c(x,__LINE__,__FILE__) #define thread_rwlock_wlock(x) igloo_thread_rwlock_wlock_c(x,__LINE__,__FILE__)
#define thread_rwlock_unlock(x) thread_rwlock_unlock_c(x,__LINE__,__FILE__) #define thread_rwlock_unlock(x) igloo_thread_rwlock_unlock_c(x,__LINE__,__FILE__)
#define thread_exit(x) thread_exit_c(x,__LINE__,__FILE__) #define thread_exit(x) igloo_thread_exit_c(x,__LINE__,__FILE__)
#define MUTEX_STATE_NOTLOCKED -1 #define MUTEX_STATE_NOTLOCKED -1
#define MUTEX_STATE_NEVERLOCKED -2 #define MUTEX_STATE_NEVERLOCKED -2
@ -135,45 +135,45 @@ typedef mutex_t spin_t;
#define THREAD_ATTACHED 0 #define THREAD_ATTACHED 0
/* init/shutdown of the library */ /* init/shutdown of the library */
void thread_initialize(void); void igloo_thread_initialize(void);
void thread_initialize_with_log_id(int log_id); void thread_initialize_with_log_id(int log_id);
void thread_shutdown(void); void igloo_thread_shutdown(void);
/* creation, destruction, locking, unlocking, signalling and waiting */ /* creation, destruction, locking, unlocking, signalling and waiting */
thread_type *thread_create_c(char *name, void *(*start_routine)(void *), thread_type *igloo_thread_create_c(char *name, void *(*start_routine)(void *),
void *arg, int detached, int line, char *file); void *arg, int detached, int line, char *file);
void thread_mutex_create_c(mutex_t *mutex, int line, char *file); void igloo_thread_mutex_create_c(mutex_t *mutex, int line, char *file);
void thread_mutex_lock_c(mutex_t *mutex, int line, char *file); void igloo_thread_mutex_lock_c(mutex_t *mutex, int line, char *file);
void thread_mutex_unlock_c(mutex_t *mutex, int line, char *file); void igloo_thread_mutex_unlock_c(mutex_t *mutex, int line, char *file);
void thread_mutex_destroy(mutex_t *mutex); void igloo_thread_mutex_destroy(mutex_t *mutex);
void thread_cond_create_c(cond_t *cond, int line, char *file); void igloo_thread_cond_create_c(cond_t *cond, int line, char *file);
void thread_cond_signal_c(cond_t *cond, int line, char *file); void igloo_thread_cond_signal_c(cond_t *cond, int line, char *file);
void thread_cond_broadcast_c(cond_t *cond, int line, char *file); void igloo_thread_cond_broadcast_c(cond_t *cond, int line, char *file);
void thread_cond_wait_c(cond_t *cond, int line, char *file); void igloo_thread_cond_wait_c(cond_t *cond, int line, char *file);
void thread_cond_timedwait_c(cond_t *cond, int millis, int line, char *file); void igloo_thread_cond_timedwait_c(cond_t *cond, int millis, int line, char *file);
void thread_cond_destroy(cond_t *cond); void igloo_thread_cond_destroy(cond_t *cond);
void thread_rwlock_create_c(rwlock_t *rwlock, int line, char *file); void igloo_thread_rwlock_create_c(rwlock_t *rwlock, int line, char *file);
void thread_rwlock_rlock_c(rwlock_t *rwlock, int line, char *file); void igloo_thread_rwlock_rlock_c(rwlock_t *rwlock, int line, char *file);
void thread_rwlock_wlock_c(rwlock_t *rwlock, int line, char *file); void igloo_thread_rwlock_wlock_c(rwlock_t *rwlock, int line, char *file);
void thread_rwlock_unlock_c(rwlock_t *rwlock, int line, char *file); void igloo_thread_rwlock_unlock_c(rwlock_t *rwlock, int line, char *file);
void thread_rwlock_destroy(rwlock_t *rwlock); void igloo_thread_rwlock_destroy(rwlock_t *rwlock);
void thread_exit_c(long val, int line, char *file); void igloo_thread_exit_c(long val, int line, char *file);
/* sleeping */ /* sleeping */
void thread_sleep(unsigned long len); void igloo_thread_sleep(unsigned long len);
/* for using library functions which aren't threadsafe */ /* for using library functions which aren't threadsafe */
void thread_library_lock(void); void igloo_thread_library_lock(void);
void thread_library_unlock(void); void igloo_thread_library_unlock(void);
#define PROTECT_CODE(code) { thread_library_lock(); code; thread_library_unlock(); } #define PROTECT_CODE(code) { igloo_thread_library_lock(); code; igloo_thread_library_unlock(); }
/* thread information functions */ /* thread information functions */
thread_type *thread_self(void); thread_type *igloo_thread_self(void);
/* renames current thread */ /* renames current thread */
void thread_rename(const char *name); void igloo_thread_rename(const char *name);
/* waits until thread_exit is called for another thread */ /* waits until thread_exit is called for another thread */
void thread_join(thread_type *thread); void igloo_thread_join(thread_type *thread);
#endif /* __THREAD_H__ */ #endif /* __THREAD_H__ */

4
timing/timing.c
View File

@ -64,7 +64,7 @@
/* /*
* Returns milliseconds no matter what. * Returns milliseconds no matter what.
*/ */
uint64_t timing_get_time(void) uint64_t igloo_timing_get_time(void)
{ {
#ifdef HAVE_GETTIMEOFDAY #ifdef HAVE_GETTIMEOFDAY
struct timeval mtv; struct timeval mtv;
@ -83,7 +83,7 @@ uint64_t timing_get_time(void)
} }
void timing_sleep(uint64_t sleeptime) void igloo_timing_sleep(uint64_t sleeptime)
{ {
struct timeval sleeper; struct timeval sleeper;

4
timing/timing.h
View File

@ -40,7 +40,7 @@ typedef __int64 int64_t;
typedef unsigned __int64 uint64_t; typedef unsigned __int64 uint64_t;
#endif #endif
uint64_t timing_get_time(void); uint64_t igloo_timing_get_time(void);
void timing_sleep(uint64_t sleeptime); void igloo_timing_sleep(uint64_t sleeptime);
#endif /* __TIMING_H__ */ #endif /* __TIMING_H__ */