Initial revision

svn path=/trunk/avl/; revision=1997

avl/BUILDING

+defines that affect compilation
+
+none
+
+library dependencies
+
+none

avl/Makefile.am

+## Process this with automake to create Makefile.in
+
+AUTOMAKE_OPTIONS = foreign
+
+noinst_LTLIBRARIES = libiceavl.la
+noinst_HEADERS = avl.h
+
+libiceavl_la_SOURCES = avl.c
+
+INCLUDES = -I$(srcdir)/../thread
+
+# SCCS stuff (for BitKeeper)
+GET = true
+
+debug:
+        $(MAKE) all CFLAGS="@DEBUG@"
+
+profile:
+        $(MAKE) all CFLAGS="@PROFILE@"
+

avl/README

+this is the avl tree library.
+
+lgpl
+
+by sam rushing <rushing@nightmare.com>
+modified by jack moffitt <jack@icecast.org>

avl/TODO

+- avl_get_last()
+- a little more cleanup probably

avl/avl.dsp

+# Microsoft Developer Studio Project File - Name="avl" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=avl - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "avl.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "avl.mak" CFG="avl - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "avl - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "avl - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "avl - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "avl - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ  /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ  /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "avl - Win32 Release"
+# Name "avl - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\avl.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\avl.h
+# End Source File
+# End Group
+# End Target
+# End Project

avl/avl.h

+/*
+ * Copyright (C) 1995 by Sam Rushing <rushing@nightmare.com>
+ */
+
+/* $Id: avl.h,v 1.1 2001/09/10 02:28:03 jack Exp $ */
+
+#ifndef __AVL_H
+#define __AVL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct avl_node_tag {
+  void *		key;
+  struct avl_node_tag *	left;
+  struct avl_node_tag *	right;  
+  struct avl_node_tag *	parent;
+  /*
+   * The lower 2 bits of <rank_and_balance> specify the balance
+   * factor: 00==-1, 01==0, 10==+1.
+   * The rest of the bits are used for <rank>
+   */
+  unsigned long		rank_and_balance;
+
+  rwlock_t rwlock;
+} avl_node;
+
+#define AVL_GET_BALANCE(n)	((int)(((n)->rank_and_balance & 3) - 1))
+
+#define AVL_GET_RANK(n)	(((n)->rank_and_balance >> 2))
+
+#define AVL_SET_BALANCE(n,b) \
+  ((n)->rank_and_balance) = \
+    (((n)->rank_and_balance & (~3)) | ((int)((b) + 1)))
+
+#define AVL_SET_RANK(n,r) \
+  ((n)->rank_and_balance) = \
+    (((n)->rank_and_balance & 3) | (r << 2))
+
+struct _avl_tree;
+
+typedef int (*avl_key_compare_fun_type)	(void * compare_arg, void * a, void * b);
+typedef int (*avl_iter_fun_type)	(void * key, void * iter_arg);
+typedef int (*avl_iter_index_fun_type)	(unsigned long index, void * key, void * iter_arg);
+typedef int (*avl_free_key_fun_type)	(void * key);
+typedef int (*avl_key_printer_fun_type)	(char *, void *);
+
+/*
+ * <compare_fun> and <compare_arg> let us associate a particular compare
+ * function with each tree, separately.
+ */
+
+typedef struct _avl_tree {
+  avl_node *			root;
+  unsigned long			height;
+  unsigned long			length;
+  avl_key_compare_fun_type	compare_fun;
+  void * 			compare_arg;
+
+  rwlock_t rwlock;
+} avl_tree;
+
+avl_tree * avl_tree_new (avl_key_compare_fun_type compare_fun, void * compare_arg);
+avl_node * avl_node_new (void * key, avl_node * parent);
+
+void avl_tree_free (
+  avl_tree *		tree,
+  avl_free_key_fun_type	free_key_fun
+  );
+
+int avl_insert (
+  avl_tree *		ob,
+  void *		key
+  );
+
+int avl_delete (
+  avl_tree *		tree,
+  void *		key,
+  avl_free_key_fun_type	free_key_fun
+  );
+
+int avl_get_by_index (
+  avl_tree *		tree,
+  unsigned long		index,
+  void **		value_address
+  );
+
+int avl_get_by_key (
+  avl_tree *		tree,
+  void *		key,
+  void **		value_address
+  );
+
+int avl_iterate_inorder (
+  avl_tree *		tree,
+  avl_iter_fun_type	iter_fun,
+  void *		iter_arg
+  );
+
+int avl_iterate_index_range (
+  avl_tree *		tree,
+  avl_iter_index_fun_type iter_fun,
+  unsigned long		low,
+  unsigned long		high,
+  void *		iter_arg
+  );
+
+int avl_get_span_by_key (
+  avl_tree *		tree,
+  void *		key,
+  unsigned long *	low,
+  unsigned long *	high
+  );
+
+int avl_get_span_by_two_keys (
+  avl_tree *		tree,
+  void *		key_a,
+  void *		key_b,
+  unsigned long *	low,
+  unsigned long *	high
+  );
+
+int avl_verify (avl_tree * tree);
+
+void avl_print_tree (
+  avl_tree *		tree,
+  avl_key_printer_fun_type key_printer
+  );
+
+avl_node *avl_get_first(avl_tree *tree);
+
+avl_node *avl_get_prev(avl_node * node);
+
+avl_node *avl_get_next(avl_node * node);
+
+/* These two are from David Ascher <david_ascher@brown.edu> */
+
+int avl_get_item_by_key_most (
+  avl_tree *		tree,
+  void *		key,
+  void **		value_address
+  );
+
+int avl_get_item_by_key_least (
+  avl_tree *		tree,
+  void *		key,
+  void **		value_address
+  );
+
+/* optional locking stuff */
+void avl_tree_rlock(avl_tree *tree);
+void avl_tree_wlock(avl_tree *tree);
+void avl_tree_unlock(avl_tree *tree);
+void avl_node_rlock(avl_node *node);
+void avl_node_wlock(avl_node *node);
+void avl_node_unlock(avl_node *node);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __AVL_H */
+
+
+
+

avl/test.c

+#include <stdio.h>
+#include "avl.h"
+
+#ifdef _WIN32
+#define snprintf _snprintf
+#endif
+
+int _compare(void *compare_arg, void *a, void *b);
+int _free(void *key);
+int _printer(char *buff, void *key);
+
+int main(int argc, char **argv)
+{
+	int i, max_nodes;
+	avl_tree *tree;
+	avl_node *node;
+
+	max_nodes = 25;
+
+	if (argc == 2) {
+		max_nodes = atoi(argv[1]);
+		if (max_nodes == 0)
+			max_nodes = 10;
+	}
+
+	printf("avl test... max_nodes = %d...\n", max_nodes);
+
+	tree = avl_tree_new(_compare, NULL);
+
+	printf("Filling tree...\n");
+	for (i = 0; i < max_nodes; i++) {
+		avl_insert(tree, (void *)rand());
+	}
+	
+	printf("Traversing tree...\n");
+	node = avl_get_first(tree);
+	while (node) {
+		i = (int)node->key;
+
+		printf("...%5d\n", i);
+
+		node = avl_get_next(node);
+	}
+
+	printf("Trying to go backwards...\n");
+	node = tree->root->right;
+	while (node) {
+		i = (int)node->key;
+		printf("...%5d\n", i);
+		node = avl_get_prev(node);
+	}
+
+	printf("Printing tree...\n");
+	avl_print_tree(tree, _printer);
+
+	avl_tree_free(tree, _free);
+	
+	return 0;
+}
+
+int _compare(void *compare_arg, void *a, void *b)
+{
+	int i, j;
+
+	i = (int)a;
+	j = (int)b;
+
+	if (i > j)
+		return 1;
+	if (j > i)
+		return -1;
+	return 0;
+}
+
+int _free(void *key) 
+{
+	return 1;
+}
+
+int _printer(char *buff, void *key)
+{
+	return snprintf(buff, 25, "%d", (int)key);
+}
+
+
+
+
+
+
+
+
+
+
+
+

httpp/BUILDING

+defines that affect compilation
+
+none
+
+library dependencies
+
+uses avl

httpp/Makefile.am

+## Process this with automake to create Makefile.in
+
+AUTOMAKE_OPTIONS = foreign
+
+noinst_LTLIBRARIES = libicehttpp.la
+noinst_HEADERS = httpp.h
+
+libicehttpp_la_SOURCES = httpp.c
+
+INCLUDES = -I$(srcdir)/../avl -I$(srcdir)/../thread
+
+# SCCS stuff (for BitKeeper)
+GET = true
+
+debug:
+        $(MAKE) all CFLAGS="@DEBUG@"
+
+profile:
+        $(MAKE) all CFLAGS="@PROFILE@"
+

httpp/README

+httpp is a simple http parser
+
+licensed under the lgpl
+
+created by jack moffitt <jack@icecast.org>

httpp/TODO

+- nothing i can think of

httpp/httpp.c

+/* Httpp.c
+**
+** http parsing engine
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "thread.h"
+#include "avl.h"
+#include "httpp.h"
+
+/* internal functions */
+
+/* misc */
+char *_lowercase(char *str);
+
+/* for avl trees */
+int _compare_vars(void *compare_arg, void *a, void *b);
+int _free_vars(void *key);
+
+http_parser_t *httpp_create_parser(void)
+{
+	return (http_parser_t *)malloc(sizeof(http_parser_t));
+}
+
+void httpp_initialize(http_parser_t *parser, http_varlist_t *defaults)
+{
+	http_varlist_t *list;
+
+	parser->req_type = httpp_req_none;
+	parser->uri = NULL;
+	parser->vars = avl_tree_new(_compare_vars, NULL);
+
+	/* now insert the default variables */
+	list = defaults;
+	while (list != NULL) {
+		httpp_setvar(parser, list->var.name, list->var.value);
+		list = list->next;
+	}
+}
+
+int httpp_parse(http_parser_t *parser, char *http_data, unsigned long len)
+{
+	char *data, *tmp;
+	char *line[32]; /* limited to 32 lines, should be more than enough */
+	int i, l, retlen;
+	int lines;
+	char *req_type;
+	char *uri;
+	char *version;
+	char *name, *value;
+	int whitespace, where;
+	int slen;
+
+	if (http_data == NULL)
+		return 0;
+
+	/* make a local copy of the data */
+	data = (char *)malloc(len);
+	if (data == NULL) return 0;
+	memcpy(data, http_data, len);
+
+	/* first we count how many lines there are 
+	** and set up the line[] array	 
+	*/
+	lines = 0;
+	line[lines] = data;
+	for (i = 0; i < len; i++) {
+		if (data[i] == '\r')
+			data[i] = '\0';
+		if (data[i] == '\n') {
+			lines++;
+			if (i + 1 < len)
+				if (data[i + 1] == '\n' || data[i + 1] == '\r') {
+					data[i] = '\0';
+					break;
+				}
+			data[i] = '\0';
+			if (i < len - 1)
+				line[lines] = &data[i + 1];
+		}
+	}
+
+	i++;
+	while (data[i] == '\n') i++;
+	retlen = i;
+
+	/* parse the first line special
+	** the format is:
+	** REQ_TYPE URI VERSION
+	** eg:
+	** GET /index.html HTTP/1.0
+	*/
+	where = 0;
+	whitespace = 0;
+	slen = strlen(line[0]);
+	req_type = line[0];
+	for (i = 0; i < slen; i++) {
+		if (line[0][i] == ' ') {
+			whitespace = 1;
+			line[0][i] = '\0';
+		} else {
+			/* we're just past the whitespace boundry */
+			if (whitespace) {
+				whitespace = 0;
+				where++;
+				switch (where) {
+				case 1:
+					uri = &line[0][i];
+					break;
+				case 2:
+					version = &line[0][i];
+					break;
+				}
+			}
+		}
+	}
+
+	if (strcasecmp("GET", req_type) == 0) {
+		parser->req_type = httpp_req_get;
+	} else if (strcasecmp("POST", req_type) == 0) {
+		parser->req_type = httpp_req_post;
+	} else if (strcasecmp("HEAD", req_type) == 0) {
+		parser->req_type = httpp_req_head;
+	} else if (strcasecmp("SOURCE", req_type) == 0) {
+		parser->req_type = httpp_req_source;
+	} else if (strcasecmp("PLAY", req_type) == 0) {
+		parser->req_type = httpp_req_play;
+	} else if (strcasecmp("STATS", req_type) == 0) {
+		parser->req_type = httpp_req_stats;
+	} else {
+		parser->req_type = httpp_req_unknown;
+	}
+
+	if (uri != NULL && strlen(uri) > 0)
+		parser->uri = strdup(uri);
+	else
+		parser->uri = NULL;
+
+	if ((version != NULL) && ((tmp = strchr(version, '/')) != NULL)) {
+		tmp[0] = '\0';
+		if ((strlen(version) > 0) && (strlen(&tmp[1]) > 0)) {
+			httpp_setvar(parser, HTTPP_VAR_PROTOCOL, _lowercase(version));
+			httpp_setvar(parser, HTTPP_VAR_VERSION, &tmp[1]);
+		} else {
+			free(data);
+			return 0;
+		}
+	} else {
+		free(data);
+		return 0;
+	}
+
+	if (parser->req_type != httpp_req_none && parser->req_type != httpp_req_unknown) {
+		switch (parser->req_type) {
+		case httpp_req_get:
+			httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "get");
+			break;
+		case httpp_req_post:
+			httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "post");
+			break;
+		case httpp_req_head:
+			httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "head");
+			break;
+		case httpp_req_source:
+			httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "source");
+			break;
+		case httpp_req_play:
+			httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "play");
+			break;
+		case httpp_req_stats:
+			httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "stats");
+			break;
+		default:
+			break;
+		}
+	} else {
+		free(data);
+		return 0;
+	}
+
+        if (parser->uri != NULL) {
+		httpp_setvar(parser, HTTPP_VAR_URI, parser->uri);
+	} else {
+		free(data);
+		return 0;
+	}
+
+	/* parse the name: value lines. */
+	for (l = 1; l < lines; l++) {
+		where = 0;
+		whitespace = 0;
+		name = line[l];
+		value = NULL;
+		slen = strlen(line[l]);
+		for (i = 0; i < slen; i++) {
+			if (line[l][i] == ':') {
+				whitespace = 1;
+				line[l][i] = '\0';
+			} else {
+				if (whitespace) {
+					whitespace = 0;
+					while (i < slen && line[l][i] == ' ')
+						i++;
+
+					if (i < slen)
+						value = &line[l][i];
+					
+					break;
+				}
+			}
+		}
+		
+		if (name != NULL && value != NULL) {
+			httpp_setvar(parser, _lowercase(name), value);
+			name = NULL; 
+			value = NULL;
+		}
+	}
+
+	free(data);
+
+	return retlen;
+}
+
+void httpp_setvar(http_parser_t *parser, char *name, char *value)
+{
+	http_var_t *var;
+
+	if (name == NULL || value == NULL)
+		return;
+
+	var = (http_var_t *)malloc(sizeof(http_var_t));
+	if (var == NULL) return;
+
+	var->name = strdup(name);
+	var->value = strdup(value);
+
+	if (httpp_getvar(parser, name) == NULL) {
+		avl_insert(parser->vars, (void *)var);
+	} else {
+		avl_delete(parser->vars, (void *)var, _free_vars);
+		avl_insert(parser->vars, (void *)var);
+	}
+}
+
+char *httpp_getvar(http_parser_t *parser, char *name)
+{
+	http_var_t var;
+	http_var_t *found;