upload http

JIRA: BOTTLENECK-10

Change-Id: I7598427ff904df438ce77c2819ee48ac75ffa8da
Signed-off-by: hongbotian <hongbo.tianhongbo@huawei.com>

15 files changed, 2047 insertions, 0 deletions

diff --git a/rubbos/app/httpd-2.0.64/test/.deps b/rubbos/app/httpd-2.0.64/test/.deps
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/.deps
diff --git a/rubbos/app/httpd-2.0.64/test/.indent.pro b/rubbos/app/httpd-2.0.64/test/.indent.pro
new file mode 100644
index 00000000..a9fbe9f9
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/.indent.pro
@@ -0,0 +1,54 @@
+-i4 -npsl -di0 -br -nce -d0 -cli0 -npcs -nfc1
+-TBUFF
+-TFILE
+-TTRANS
+-TUINT4
+-T_trans
+-Tallow_options_t
+-Tapache_sfio
+-Tarray_header
+-Tbool_int
+-Tbuf_area
+-Tbuff_struct
+-Tbuffy
+-Tcmd_how
+-Tcmd_parms
+-Tcommand_rec
+-Tcommand_struct
+-Tconn_rec
+-Tcore_dir_config
+-Tcore_server_config
+-Tdir_maker_func
+-Tevent
+-Tglobals_s
+-Thandler_func
+-Thandler_rec
+-Tjoblist_s
+-Tlisten_rec
+-Tmerger_func
+-Tmode_t
+-Tmodule
+-Tmodule_struct
+-Tmutex
+-Tn_long
+-Tother_child_rec
+-Toverrides_t
+-Tparent_score
+-Tpid_t
+-Tpiped_log
+-Tpool
+-Trequest_rec
+-Trequire_line
+-Trlim_t
+-Tscoreboard
+-Tsemaphore
+-Tserver_addr_rec
+-Tserver_rec
+-Tserver_rec_chain
+-Tshort_score
+-Ttable
+-Ttable_entry
+-Tthread
+-Tu_wide_int
+-Tvtime_t
+-Twide_int
diff --git a/rubbos/app/httpd-2.0.64/test/Makefile b/rubbos/app/httpd-2.0.64/test/Makefile
new file mode 100644
index 00000000..31afa4a2
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/Makefile
@@ -0,0 +1,25 @@
+top_srcdir   = /bottlenecks/rubbos/app/httpd-2.0.64
+top_builddir = /bottlenecks/rubbos/app/httpd-2.0.64
+srcdir       = /bottlenecks/rubbos/app/httpd-2.0.64/test
+builddir     = /bottlenecks/rubbos/app/httpd-2.0.64/test
+VPATH        = /bottlenecks/rubbos/app/httpd-2.0.64/test
+
+# no targets: we don't want to build anything by default. if you want the
+# test programs, then "make test"
+TARGETS =
+
+PROGRAMS =
+
+PROGRAM_LDADD        = $(EXTRA_LDFLAGS) $(PROGRAM_DEPENDENCIES) $(EXTRA_LIBS)
+PROGRAM_DEPENDENCIES =  \
+	$(top_srcdir)/srclib/apr-util/libaprutil.la \
+	$(top_srcdir)/srclib/apr/libapr.la
+
+include $(top_builddir)/build/rules.mk
+
+test: $(PROGRAMS)
+
+# example for building a test proggie
+# dbu_OBJECTS = dbu.lo
+# dbu: $(dbu_OBJECTS)
+#	$(LINK) $(dbu_OBJECTS) $(PROGRAM_LDADD)
diff --git a/rubbos/app/httpd-2.0.64/test/Makefile.in b/rubbos/app/httpd-2.0.64/test/Makefile.in
new file mode 100644
index 00000000..6d834054
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/Makefile.in
@@ -0,0 +1,20 @@
+
+# no targets: we don't want to build anything by default. if you want the
+# test programs, then "make test"
+TARGETS =
+
+PROGRAMS =
+
+PROGRAM_LDADD        = $(EXTRA_LDFLAGS) $(PROGRAM_DEPENDENCIES) $(EXTRA_LIBS)
+PROGRAM_DEPENDENCIES =  \
+	$(top_srcdir)/srclib/apr-util/libaprutil.la \
+	$(top_srcdir)/srclib/apr/libapr.la
+
+include $(top_builddir)/build/rules.mk
+
+test: $(PROGRAMS)
+
+# example for building a test proggie
+# dbu_OBJECTS = dbu.lo
+# dbu: $(dbu_OBJECTS)
+#	$(LINK) $(dbu_OBJECTS) $(PROGRAM_LDADD)
diff --git a/rubbos/app/httpd-2.0.64/test/README b/rubbos/app/httpd-2.0.64/test/README
new file mode 100644
index 00000000..9f8be502
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/README
@@ -0,0 +1,3 @@
+This directory contains useful test code for testing various bits
+of Apache functionality.  This stuff is for the developers only,
+so we might remove it on public releases.
diff --git a/rubbos/app/httpd-2.0.64/test/check_chunked b/rubbos/app/httpd-2.0.64/test/check_chunked
new file mode 100644
index 00000000..50c56eb0
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/check_chunked
@@ -0,0 +1,58 @@
+#!/usr/bin/perl -w
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+# This is meant to be used on the raw output of an HTTP/1.1 connection
+# to check that the chunks are all correctly laid out.  It's easiest
+# to use a tool like netcat to generate the output.  This script
+# *insists* that \r exist in the output.
+#
+# You can find netcat at avian.org:/src/hacks/nc110.tgz.
+
+use strict;
+
+my $is_chunked = 0;
+
+# must toss headers
+while(<>) {
+    if (/^Transfer-Encoding:\s+chunked/i) {
+	$is_chunked = 1;
+    }
+    last if ($_ eq "\r\n");
+}
+
+$is_chunked || die "wasn't chunked\n";
+
+for(;;) {
+    $_ = <> || die "unexpected end of file!\n";
+
+    m#^([0-9a-f]+) *\r$#i || die "bogus chunklen: $_";
+
+    my $chunklen = hex($1);
+
+    exit 0 if ($chunklen == 0);
+
+    chop; chop;
+    print "$_ ";
+
+    my $data = '';
+    read(ARGV, $data, $chunklen) == $chunklen || die "short read!\n";
+
+    $_ = <> || die "unexpected end of file!\n";
+
+    $_ eq "\r\n" || die "missing chunk trailer!\n";
+}
diff --git a/rubbos/app/httpd-2.0.64/test/cls.c b/rubbos/app/httpd-2.0.64/test/cls.c
new file mode 100644
index 00000000..bb0a85d1
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/cls.c
@@ -0,0 +1,182 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ctype.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+/*
+ * Compare a string to a mask
+ * Mask characters:
+ *   @ - uppercase letter
+ *   # - lowercase letter
+ *   & - hex digit
+ *   # - digit
+ *   * - swallow remaining characters 
+ *  <x> - exact match for any other character
+ */
+static int checkmask(const char *data, const char *mask)
+{
+    int i, ch, d;
+
+    for (i = 0; mask[i] != '\0' && mask[i] != '*'; i++) {
+	ch = mask[i];
+	d = data[i];
+	if (ch == '@') {
+	    if (!isupper(d))
+		return 0;
+	}
+	else if (ch == '$') {
+	    if (!islower(d))
+		return 0;
+	}
+	else if (ch == '#') {
+	    if (!isdigit(d))
+		return 0;
+	}
+	else if (ch == '&') {
+	    if (!isxdigit(d))
+		return 0;
+	}
+	else if (ch != d)
+	    return 0;
+    }
+
+    if (mask[i] == '*')
+	return 1;
+    else
+	return (data[i] == '\0');
+}
+
+/*
+ * Converts 8 hex digits to a time integer
+ */
+static int hex2sec(const char *x)
+{
+    int i, ch;
+    unsigned int j;
+
+    for (i = 0, j = 0; i < 8; i++) {
+	ch = x[i];
+	j <<= 4;
+	if (isdigit(ch))
+	    j |= ch - '0';
+	else if (isupper(ch))
+	    j |= ch - ('A' - 10);
+	else
+	    j |= ch - ('a' - 10);
+    }
+    if (j == 0xffffffff)
+	return -1;		/* so that it works with 8-byte ints */
+    else
+	return j;
+}
+
+int main(int argc, char **argv)
+{
+    int i, ver;
+    DIR *d;
+    struct dirent *e;
+    const char *s;
+    FILE *fp;
+    char path[FILENAME_MAX + 1];
+    char line[1035];
+    time_t date, lmod, expire;
+    unsigned int len;
+    struct tm ts;
+    char sdate[30], slmod[30], sexpire[30];
+    const char time_format[] = "%e %b %Y %R";
+
+    if (argc != 2) {
+	printf("Usage: cls directory\n");
+	exit(0);
+    }
+
+    d = opendir(argv[1]);
+    if (d == NULL) {
+	perror("opendir");
+	exit(1);
+    }
+
+    for (;;) {
+	e = readdir(d);
+	if (e == NULL)
+	    break;
+	s = e->d_name;
+	if (s[0] == '.' || s[0] == '#')
+	    continue;
+	sprintf(path, "%s/%s", argv[1], s);
+	fp = fopen(path, "r");
+	if (fp == NULL) {
+	    perror("fopen");
+	    continue;
+	}
+	if (fgets(line, 1034, fp) == NULL) {
+	    perror("fgets");
+	    fclose(fp);
+	    continue;
+	}
+	if (!checkmask(line, "&&&&&&&& &&&&&&&& &&&&&&&& &&&&&&&& &&&&&&&&\n")) {
+	    fprintf(stderr, "Bad cache file\n");
+	    fclose(fp);
+	    continue;
+	}
+	date = hex2sec(line);
+	lmod = hex2sec(line + 9);
+	expire = hex2sec(line + 18);
+	ver = hex2sec(line + 27);
+	len = hex2sec(line + 35);
+	if (fgets(line, 1034, fp) == NULL) {
+	    perror("fgets");
+	    fclose(fp);
+	    continue;
+	}
+	fclose(fp);
+	i = strlen(line);
+	if (strncmp(line, "X-URL: ", 7) != 0 || line[i - 1] != '\n') {
+	    fprintf(stderr, "Bad cache file\n");
+	    continue;
+	}
+	line[i - 1] = '\0';
+	if (date != -1) {
+	    ts = *gmtime(&date);
+	    strftime(sdate, 30, time_format, &ts);
+	}
+	else
+	    strcpy(sdate, "-");
+
+	if (lmod != -1) {
+	    ts = *gmtime(&lmod);
+	    strftime(slmod, 30, time_format, &ts);
+	}
+	else
+	    strcpy(slmod, "-");
+
+	if (expire != -1) {
+	    ts = *gmtime(&expire);
+	    strftime(sexpire, 30, time_format, &ts);
+	}
+	else
+	    strcpy(sexpire, "-");
+
+	printf("%s: %d; %s  %s  %s\n", line + 7, ver, sdate, slmod, sexpire);
+    }
+
+    closedir(d);
+    return 0;
+}
diff --git a/rubbos/app/httpd-2.0.64/test/tcpdumpscii.txt b/rubbos/app/httpd-2.0.64/test/tcpdumpscii.txt
new file mode 100644
index 00000000..9c1060ed
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/tcpdumpscii.txt
@@ -0,0 +1,50 @@
+
+From marcs@znep.com Fri Apr 17 15:16:16 1998
+Date: Sat, 22 Nov 1997 20:44:10 -0700 (MST)
+From: Marc Slemko <marcs@znep.com>
+To: TLOSAP <new-httpd@apache.org>
+Subject: Re: Getting ethernet packets content under FreeBSD?  (fwd)
+Reply-To: new-httpd@apache.org
+
+Anyone too lazy to hack tcpdump (eg. my tcpdump has a -X option to display
+the data in ASCII) can use something like the below to grab HTTP headers
+when debugging broken clients.
+
+Nothing complicated, but handy.
+
+---------- Forwarded message ----------
+Date: Sat, 22 Nov 1997 14:35:23 PST
+From: Bill Fenner <fenner@parc.xerox.com>
+To: Nate Williams <nate@mt.sri.com>
+Cc: bmah@ca.sandia.gov, hackers@FreeBSD.ORG
+Subject: Re: Getting ethernet packets content under FreeBSD? 
+
+I usually just use this perl script, which I call "tcpdumpscii".
+Then run "tcpdumpscii -s 1500 -x [other tcpdump args]".
+
+  Bill
+
+#!/import/misc/bin/perl
+#
+#
+open(TCPDUMP,"tcpdump -l @ARGV|");
+while (<TCPDUMP>) {
+	if (/^\s+(\S\S)+/) {
+		$sav = $_;
+		$asc = "";
+		while (s/\s*(\S\S)\s*//) {
+			$i = hex($1);
+			if ($i < 32 || $i > 126) {
+				$asc .= ".";
+			} else {
+				$asc .= pack(C,hex($1));
+			}
+		}
+		$foo = "." x length($asc);
+		$_ = $sav;
+		s/\t/        /g;
+		s/^$foo/$asc/;
+	}
+	print;
+}
+
diff --git a/rubbos/app/httpd-2.0.64/test/test-writev.c b/rubbos/app/httpd-2.0.64/test/test-writev.c
new file mode 100644
index 00000000..9e7f04aa
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/test-writev.c
@@ -0,0 +1,101 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+    test-writev: use this to figure out if your writev() does intelligent
+    things on the network.  Some writev()s when given multiple buffers
+    will break them up into multiple packets, which is a waste.
+
+    Linux prior to 2.0.31 has this problem.
+
+    Solaris 2.5, 2.5.1 doesn't appear to, 2.6 hasn't been tested.
+
+    IRIX 5.3 doesn't have this problem.
+
+    To use this you want to snoop the wire with tcpdump, and then run
+    "test-writev a.b.c.d port#" ... against some TCP service on another
+    box.  For example you can run it against port 80 on another server.
+    You want to look to see how many data packets are sent, you're hoping
+    only one of size 300 is sent.
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/uio.h>
+#include <errno.h>
+
+#ifndef INADDR_NONE
+#define INADDR_NONE (-1ul)
+#endif
+
+void main( int argc, char **argv )
+{
+    struct sockaddr_in server_addr;
+    int s;
+    struct iovec vector[3];
+    char buf[100];
+    int i;
+    const int just_say_no = 1;
+
+    if( argc != 3 ) {
+usage:
+	fprintf( stderr, "usage: test-writev a.b.c.d port#\n" );
+	exit( 1 );
+    }
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_addr.s_addr = inet_addr( argv[1] );
+    if( server_addr.sin_addr.s_addr == INADDR_NONE ) {
+	fprintf( stderr, "bogus address\n" );
+	goto usage;
+    }
+    server_addr.sin_port = htons( atoi( argv[2] ) );
+
+    s = socket( AF_INET, SOCK_STREAM, 0 );
+    if( s < 0 ) {
+	perror("socket");
+	exit(1);
+    }
+    if( connect( s, (struct sockaddr *)&server_addr, sizeof( server_addr ) )
+	!= 0 ) {
+	perror("connect");
+	exit(1);
+    }
+
+    if( setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&just_say_no,
+	sizeof(just_say_no)) != 0 ) {
+	perror( "TCP_NODELAY" );
+	exit(1);
+    }
+    /* now build up a two part writev and write it out */
+    for( i = 0; i < sizeof( buf ); ++i ) {
+	buf[i] = 'x';
+    }
+    vector[0].iov_base = buf;
+    vector[0].iov_len = sizeof(buf);
+    vector[1].iov_base = buf;
+    vector[1].iov_len = sizeof(buf);
+    vector[2].iov_base = buf;
+    vector[2].iov_len = sizeof(buf);
+
+    i = writev( s, &vector[0], 3 );
+    fprintf( stdout, "i=%d, errno=%d\n", i, errno );
+    exit(0);
+}
diff --git a/rubbos/app/httpd-2.0.64/test/test_find.c b/rubbos/app/httpd-2.0.64/test/test_find.c
new file mode 100644
index 00000000..0f401ffd
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/test_find.c
@@ -0,0 +1,78 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This program tests the ap_find_list_item routine in ../main/util.c.
+ *
+ * The defines in this sample compile line are specific to Roy's system.
+ * They should match whatever was used to compile Apache first.
+ *
+     gcc -g -O2 -I../os/unix -I../include -o test_find \
+            -DSOLARIS2=250 -Wall -DALLOC_DEBUG -DPOOL_DEBUG \
+            ../main/alloc.o ../main/buff.o ../main/util.o \
+            ../ap/libap.a -lsocket -lnsl test_find.c
+ * 
+ * Roy Fielding, 1999
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "httpd.h"
+#include "apr_general.h"
+
+/*
+ * Dummy a bunch of stuff just to get a compile
+ */
+uid_t ap_user_id;
+gid_t ap_group_id;
+void *ap_dummy_mutex = &ap_dummy_mutex;
+char *ap_server_argv0;
+
+AP_DECLARE(void) ap_block_alarms(void)
+{
+    ;
+}
+
+AP_DECLARE(void) ap_unblock_alarms(void)
+{
+    ;
+}
+
+AP_DECLARE(void) ap_log_error(const char *file, int line, int level,
+                              const request_rec *r, const char *fmt, ...)
+{
+    ;
+}
+
+int main (void)
+{
+    apr_pool_t *p;
+    char line[512];
+    char tok[512];
+
+    p = apr_pool_alloc_init();
+
+    printf("Enter field value to find items within:\n");
+    if (!gets(line))
+        exit(0);
+
+    printf("Enter search item:\n");
+    while (gets(tok)) {
+        printf("  [%s] == %s\n", tok, ap_find_list_item(p, line, tok)
+                                  ? "Yes" : "No");
+        printf("Enter search item:\n");
+    }
+    
+    exit(0);
+}
diff --git a/rubbos/app/httpd-2.0.64/test/test_limits.c b/rubbos/app/httpd-2.0.64/test/test_limits.c
new file mode 100644
index 00000000..8dca825b
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/test_limits.c
@@ -0,0 +1,200 @@
+/**************************************************************
+ * test_limits.c
+ *
+ * A simple program for sending abusive requests to a server, based
+ * on the sioux.c exploit code that this nimrod posted (see below).
+ * Roy added options for testing long header fieldsize (-t h), long
+ * request-lines (-t r), and a long request body (-t b).
+ *
+ * FreeBSD 2.2.x, FreeBSD 3.0, IRIX 5.3, IRIX 6.2:
+ *   gcc -o test_limits test_limits.c
+ * 
+ * Solaris 2.5.1:
+ *   gcc -o test_limits test_limits.c -lsocket -lnsl
+ * 
+ *
+ * Message-ID: <861zqspvtw.fsf@niobe.ewox.org>
+ * Date: 	Fri, 7 Aug 1998 19:04:27 +0200
+ * Sender: Bugtraq List <BUGTRAQ@netspace.org>
+ * From: Dag-Erling Coidan =?ISO-8859-1?Q?Sm=F8rgrav?= <finrod@EWOX.ORG>
+ * Subject:      YA Apache DoS attack
+ * 
+ * Copyright (c) 1998 Dag-Erling Codan Smrgrav
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*
+ * Kudos to Mark Huizer who originally suggested this on freebsd-current
+ */
+
+#include <sys/types.h>
+#include <sys/uio.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define TEST_LONG_REQUEST_LINE      1
+#define TEST_LONG_REQUEST_FIELDS    2
+#define TEST_LONG_REQUEST_FIELDSIZE 3
+#define TEST_LONG_REQUEST_BODY      4
+
+void
+usage(void)
+{
+    fprintf(stderr,
+      "usage: test_limits [-t (r|n|h|b)] [-a address] [-p port] [-n num]\n");
+    exit(1);
+}
+
+int
+main(int argc, char *argv[])
+{
+    struct sockaddr_in sin;
+    struct hostent *he;
+    FILE *f;
+    int o, sd;
+
+    /* default parameters */
+    char *addr = "localhost";
+    int port = 80;
+    int num = 1000;
+    int testtype = TEST_LONG_REQUEST_FIELDS;
+
+    /* get options */
+    while ((o = getopt(argc, argv, "t:a:p:n:")) != EOF)
+        switch (o) {
+        case 't':
+            if (*optarg == 'r')
+                testtype = TEST_LONG_REQUEST_LINE;
+            else if (*optarg == 'n')
+                testtype = TEST_LONG_REQUEST_FIELDS;
+            else if (*optarg == 'h')
+                testtype = TEST_LONG_REQUEST_FIELDSIZE;
+            else if (*optarg == 'b')
+                testtype = TEST_LONG_REQUEST_BODY;
+            break;
+        case 'a':
+            addr = optarg;
+            break;
+        case 'p':
+            port = atoi(optarg);
+            break;
+        case 'n':
+            num = atoi(optarg);
+            break;
+        default:
+            usage();
+        }
+
+    if (argc != optind)
+        usage();
+
+    /* connect */
+    if ((he = gethostbyname(addr)) == NULL) {
+        perror("gethostbyname");
+        exit(1);
+    }
+    bzero(&sin, sizeof(sin));
+    bcopy(he->h_addr, (char *)&sin.sin_addr, he->h_length);
+    sin.sin_family = he->h_addrtype;
+    sin.sin_port = htons(port);
+
+    if ((sd = socket(sin.sin_family, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+        perror("socket");
+        exit(1);
+    }
+
+    if (connect(sd, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
+        perror("connect");
+        exit(1);
+    }
+
+    if ((f = fdopen(sd, "r+")) == NULL) {
+        perror("fdopen");
+        exit(1);
+    }
+
+    /* attack! */
+    fprintf(stderr, "Testing like a plague of locusts on %s\n", addr);
+
+    if (testtype == TEST_LONG_REQUEST_LINE) {
+        fprintf(f, "GET ");
+        while (num-- && !ferror(f)) {
+            fprintf(f, "/123456789");
+            fflush(f);
+        }
+        fprintf(f, " HTTP/1.0\r\n\r\n");
+    }
+    else {
+        fprintf(f, "GET /fred/foo HTTP/1.0\r\n");
+
+        if (testtype == TEST_LONG_REQUEST_FIELDSIZE) {
+            while (num-- && !ferror(f)) {
+                fprintf(f, "User-Agent: sioux");
+                fflush(f);
+            }
+            fprintf(f, "\r\n");
+        }
+        else if (testtype == TEST_LONG_REQUEST_FIELDS) {
+            while (num-- && !ferror(f))
+                fprintf(f, "User-Agent: sioux\r\n");
+            fprintf(f, "\r\n");
+        }
+        else if (testtype == TEST_LONG_REQUEST_BODY) {
+            fprintf(f, "User-Agent: sioux\r\n");
+            fprintf(f, "Content-Length: 33554433\r\n");
+            fprintf(f, "\r\n");
+            while (num-- && !ferror(f))
+                fprintf(f, "User-Agent: sioux\r\n");
+        }
+        else {
+            fprintf(f, "\r\n");
+        }
+    }
+    fflush(f);
+
+    {
+        apr_ssize_t len;
+        char buff[512];
+
+        while ((len = read(sd, buff, 512)) > 0)
+            len = write(1, buff, len);
+    }
+    if (ferror(f)) {
+        perror("fprintf");
+        exit(1);
+    }
+
+    fclose(f);
+    exit(0);
+}
diff --git a/rubbos/app/httpd-2.0.64/test/test_parser.c b/rubbos/app/httpd-2.0.64/test/test_parser.c
new file mode 100644
index 00000000..fc17a725
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/test_parser.c
@@ -0,0 +1,75 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This program tests the ap_get_list_item routine in ../main/util.c.
+ *
+ * The defines in this sample compile line are specific to Roy's system.
+ * They should match whatever was used to compile Apache first.
+ *
+     gcc -g -O2 -I../os/unix -I../include -o test_parser \
+            -DSOLARIS2=250 -Wall -DALLOC_DEBUG -DPOOL_DEBUG \
+            ../main/alloc.o ../main/buff.o ../main/util.o \
+            ../ap/libap.a -lsocket -lnsl test_parser.c
+ * 
+ * Roy Fielding, 1999
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "httpd.h"
+#include "apr_general.h"
+
+/*
+ * Dummy a bunch of stuff just to get a compile
+ */
+uid_t ap_user_id;
+gid_t ap_group_id;
+void *ap_dummy_mutex = &ap_dummy_mutex;
+char *ap_server_argv0;
+
+AP_DECLARE(void) ap_block_alarms(void)
+{
+    ;
+}
+
+AP_DECLARE(void) ap_unblock_alarms(void)
+{
+    ;
+}
+
+AP_DECLARE(void) ap_log_error(const char *file, int line, int level,
+                               const request_rec *r, const char *fmt, ...)
+{
+    ;
+}
+
+int main (void)
+{
+    apr_pool_t *p;
+    const char *field;
+    char *newstr;
+    char instr[512];
+
+    p = apr_pool_alloc_init();
+
+    while (gets(instr)) {
+        printf("  [%s] ==\n", instr);
+        field = instr;
+        while ((newstr = ap_get_list_item(p, &field)) != NULL)
+            printf("  <%s> ..\n", newstr);
+    }
+    
+    exit(0);
+}
diff --git a/rubbos/app/httpd-2.0.64/test/test_select.c b/rubbos/app/httpd-2.0.64/test/test_select.c
new file mode 100644
index 00000000..af110356
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/test_select.c
@@ -0,0 +1,46 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This is just a quick test program to see how long a wait is
+ * produced by a select loop with an exponential backoff.
+ *
+ *   gcc -g -O2 -o test_select test_select.c
+ *   test_select
+ *
+ * Roy Fielding, 1996
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+int main (void)
+{
+    int srv;
+    long waittime = 4096;
+    struct timeval tv;
+
+    printf("Start\n");
+    while ((waittime > 0) && (waittime < 3000000)) {
+        printf("%d\n", waittime);
+        tv.tv_sec  = waittime/1000000;
+        tv.tv_usec = waittime%1000000;
+        waittime <<= 1;
+        srv = select(0, NULL, NULL, NULL, &tv);
+    }
+    printf("End\n");
+    exit(0);
+}
diff --git a/rubbos/app/httpd-2.0.64/test/time-sem.c b/rubbos/app/httpd-2.0.64/test/time-sem.c
new file mode 100644
index 00000000..bdf09316
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/time-sem.c
@@ -0,0 +1,588 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+time-sem.c has the basics of the semaphores we use in http_main.c.  It's
+intended for timing differences between various methods on an
+architecture.  In practice we've found many things affect which semaphore
+to be used:
+
+    - NFS filesystems absolutely suck for fcntl() and flock()
+
+    - uslock absolutely sucks on single-processor IRIX boxes, but
+	absolutely rocks on multi-processor boxes.  The converse
+	is true for fcntl.  sysvsem seems a moderate balance.
+
+    - Under Solaris you can't have too many processes use SEM_UNDO, there
+	might be a tuneable somewhere that increases the limit from 29.
+	We're not sure what the tunable is, so there's a define
+	NO_SEM_UNDO which can be used to simulate us trapping/blocking
+	signals to be able to properly release the semaphore on a clean
+	child death.  You'll also need to define NEED_UNION_SEMUN
+	under solaris.
+
+You'll need to define USE_SHMGET_SCOREBOARD if anonymous shared mmap()
+doesn't work on your system (i.e. linux).
+
+argv[1] is the #children, argv[2] is the #iterations per child
+
+You should run each over many different #children inputs, and choose
+#iter such that the program runs for at least a second or so... or even
+longer depending on your patience.
+
+compile with:
+
+gcc -o time-FCNTL -Wall -O time-sem.c -DUSE_FCNTL_SERIALIZED_ACCEPT
+gcc -o time-FLOCK -Wall -O time-sem.c -DUSE_FLOCK_SERIALIZED_ACCEPT
+gcc -o time-SYSVSEM -Wall -O time-sem.c -DUSE_SYSVSEM_SERIALIZED_ACCEPT
+gcc -o time-SYSVSEM2 -Wall -O time-sem.c -DUSE_SYSVSEM_SERIALIZED_ACCEPT -DNO_SEM_UNDO
+gcc -o time-PTHREAD -Wall -O time-sem.c -DUSE_PTHREAD_SERIALIZED_ACCEPT -lpthread
+gcc -o time-USLOCK -Wall -O time-sem.c -DUSE_USLOCK_SERIALIZED_ACCEPT
+
+not all versions work on all systems.
+*/
+
+#include <errno.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <signal.h>
+
+#if defined(USE_FCNTL_SERIALIZED_ACCEPT)
+
+static struct flock lock_it;
+static struct flock unlock_it;
+
+static int fcntl_fd=-1;
+
+#define accept_mutex_child_init()
+#define accept_mutex_cleanup()
+
+/*
+ * Initialize mutex lock.
+ * Must be safe to call this on a restart.
+ */
+void
+accept_mutex_init(void)
+{
+
+    lock_it.l_whence = SEEK_SET;   /* from current point */
+    lock_it.l_start  = 0;          /* -"- */
+    lock_it.l_len    = 0;          /* until end of file */
+    lock_it.l_type   = F_WRLCK;    /* set exclusive/write lock */
+    lock_it.l_pid    = 0;          /* pid not actually interesting */
+    unlock_it.l_whence = SEEK_SET; /* from current point */
+    unlock_it.l_start  = 0;        /* -"- */
+    unlock_it.l_len    = 0;        /* until end of file */
+    unlock_it.l_type   = F_UNLCK;  /* set exclusive/write lock */
+    unlock_it.l_pid    = 0;        /* pid not actually interesting */
+
+    printf("opening test-lock-thing in current directory\n");
+    fcntl_fd = open("test-lock-thing", O_CREAT | O_WRONLY | O_EXCL, 0644);
+    if (fcntl_fd == -1)
+    {
+	perror ("open");
+	fprintf (stderr, "Cannot open lock file: %s\n", "test-lock-thing");
+	exit (1);
+    }
+    unlink("test-lock-thing");
+}
+
+void accept_mutex_on(void)
+{
+    int ret;
+    
+    while ((ret = fcntl(fcntl_fd, F_SETLKW, &lock_it)) < 0 && errno == EINTR)
+	continue;
+
+    if (ret < 0) {
+	perror ("fcntl lock_it");
+	exit(1);
+    }
+}
+
+void accept_mutex_off(void)
+{
+    if (fcntl (fcntl_fd, F_SETLKW, &unlock_it) < 0)
+    {
+	perror ("fcntl unlock_it");
+	exit(1);
+    }
+}
+
+#elif defined(USE_FLOCK_SERIALIZED_ACCEPT)
+
+#include <sys/file.h>
+
+static int flock_fd=-1;
+
+#define FNAME "test-lock-thing"
+
+/*
+ * Initialize mutex lock.
+ * Must be safe to call this on a restart.
+ */
+void accept_mutex_init(void)
+{
+
+    printf("opening " FNAME " in current directory\n");
+    flock_fd = open(FNAME, O_CREAT | O_WRONLY | O_EXCL, 0644);
+    if (flock_fd == -1)
+    {
+	perror ("open");
+	fprintf (stderr, "Cannot open lock file: %s\n", "test-lock-thing");
+	exit (1);
+    }
+}
+
+void accept_mutex_child_init(void)
+{
+    flock_fd = open(FNAME, O_WRONLY, 0600);
+    if (flock_fd == -1) {
+	perror("open");
+	exit(1);
+    }
+}
+
+void accept_mutex_cleanup(void)
+{
+    unlink(FNAME);
+}
+
+void accept_mutex_on(void)
+{
+    int ret;
+    
+    while ((ret = flock(flock_fd, LOCK_EX)) < 0 && errno == EINTR)
+	continue;
+
+    if (ret < 0) {
+	perror ("flock(LOCK_EX)");
+	exit(1);
+    }
+}
+
+void accept_mutex_off(void)
+{
+    if (flock (flock_fd, LOCK_UN) < 0)
+    {
+	perror ("flock(LOCK_UN)");
+	exit(1);
+    }
+}
+
+#elif defined (USE_SYSVSEM_SERIALIZED_ACCEPT)
+
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+
+static   int sem_id = -1;
+#ifdef NO_SEM_UNDO
+static sigset_t accept_block_mask;
+static sigset_t accept_previous_mask;
+#endif
+
+#define accept_mutex_child_init()
+#define accept_mutex_cleanup()
+
+void accept_mutex_init(void)
+{
+#ifdef NEED_UNION_SEMUN
+    /* believe it or not, you need to define this under solaris */
+    union semun {
+	int val;
+	struct semid_ds *buf;
+	ushort *array;
+    };
+#endif
+
+    union semun ick;
+
+    sem_id = semget(999, 1, IPC_CREAT | 0666);
+    if (sem_id < 0) {
+       perror ("semget");
+       exit (1);
+    }
+    ick.val = 1;
+    if (semctl(sem_id, 0, SETVAL, ick) < 0) {
+       perror ("semctl");
+        exit(1);
+    }
+#ifdef NO_SEM_UNDO
+    sigfillset(&accept_block_mask);
+    sigdelset(&accept_block_mask, SIGHUP);
+    sigdelset(&accept_block_mask, SIGTERM);
+    sigdelset(&accept_block_mask, SIGUSR1);
+#endif
+}
+
+void accept_mutex_on()
+{
+    struct sembuf op;
+
+#ifdef NO_SEM_UNDO
+    if (sigprocmask(SIG_BLOCK, &accept_block_mask, &accept_previous_mask)) {
+	perror("sigprocmask(SIG_BLOCK)");
+	exit (1);
+    }
+    op.sem_flg = 0;
+#else
+    op.sem_flg = SEM_UNDO;
+#endif
+    op.sem_num = 0;
+    op.sem_op  = -1;
+    if (semop(sem_id, &op, 1) < 0) {
+	perror ("accept_mutex_on");
+	exit (1);
+    }
+}
+
+void accept_mutex_off()
+{
+    struct sembuf op;
+
+    op.sem_num = 0;
+    op.sem_op  = 1;
+#ifdef NO_SEM_UNDO
+    op.sem_flg = 0;
+#else
+    op.sem_flg = SEM_UNDO;
+#endif
+    if (semop(sem_id, &op, 1) < 0) {
+	perror ("accept_mutex_off");
+        exit (1);
+    }
+#ifdef NO_SEM_UNDO
+    if (sigprocmask(SIG_SETMASK, &accept_previous_mask, NULL)) {
+	perror("sigprocmask(SIG_SETMASK)");
+	exit (1);
+    }
+#endif
+}
+
+#elif defined (USE_PTHREAD_SERIALIZED_ACCEPT)
+
+/* note: pthread mutexes aren't released on child death, hence the
+ * signal goop ... in a real implementation we'd do special things
+ * during hup, term, usr1.
+ */
+
+#include <pthread.h>
+
+static pthread_mutex_t *mutex;
+static sigset_t accept_block_mask;
+static sigset_t accept_previous_mask;
+
+#define accept_mutex_child_init()
+#define accept_mutex_cleanup()
+
+void accept_mutex_init(void)
+{
+    pthread_mutexattr_t mattr;
+    int fd;
+
+    fd = open ("/dev/zero", O_RDWR);
+    if (fd == -1) {
+	perror ("open(/dev/zero)");
+	exit (1);
+    }
+    mutex = (pthread_mutex_t *)mmap ((caddr_t)0, sizeof (*mutex),
+		    PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+    if (mutex == (void *)(caddr_t)-1) {
+	perror ("mmap");
+	exit (1);
+    }
+    close (fd);
+    if (pthread_mutexattr_init(&mattr)) {
+	perror ("pthread_mutexattr_init");
+	exit (1);
+    }
+    if (pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED)) {
+	perror ("pthread_mutexattr_setpshared");
+	exit (1);
+    }
+    if (pthread_mutex_init(mutex, &mattr)) {
+	perror ("pthread_mutex_init");
+	exit (1);
+    }
+    sigfillset(&accept_block_mask);
+    sigdelset(&accept_block_mask, SIGHUP);
+    sigdelset(&accept_block_mask, SIGTERM);
+    sigdelset(&accept_block_mask, SIGUSR1);
+}
+
+void accept_mutex_on()
+{
+    if (sigprocmask(SIG_BLOCK, &accept_block_mask, &accept_previous_mask)) {
+	perror("sigprocmask(SIG_BLOCK)");
+	exit (1);
+    }
+    if (pthread_mutex_lock (mutex)) {
+	perror ("pthread_mutex_lock");
+	exit (1);
+    }
+}
+
+void accept_mutex_off()
+{
+    if (pthread_mutex_unlock (mutex)) {
+	perror ("pthread_mutex_unlock");
+	exit (1);
+    }
+    if (sigprocmask(SIG_SETMASK, &accept_previous_mask, NULL)) {
+	perror("sigprocmask(SIG_SETMASK)");
+	exit (1);
+    }
+}
+
+#elif defined (USE_USLOCK_SERIALIZED_ACCEPT)
+
+#include <ulocks.h>
+
+static usptr_t *us = NULL;
+static ulock_t uslock = NULL;
+
+#define accept_mutex_child_init()
+#define accept_mutex_cleanup()
+
+void accept_mutex_init(void)
+{
+    ptrdiff_t old;
+    /* default is 8 */
+#define CONF_INITUSERS_MAX 15
+    if ((old = usconfig(CONF_INITUSERS, CONF_INITUSERS_MAX)) == -1) {
+        perror("usconfig");
+        exit(-1);
+    }
+    if ((old = usconfig(CONF_LOCKTYPE, US_NODEBUG)) == -1) {
+        perror("usconfig");
+        exit(-1);
+    }
+    if ((old = usconfig(CONF_ARENATYPE, US_SHAREDONLY)) == -1) {
+        perror("usconfig");
+        exit(-1);
+    }
+    if ((us = usinit("/dev/zero")) == NULL) {
+        perror("usinit");
+        exit(-1);
+    }
+    if ((uslock = usnewlock(us)) == NULL) {
+        perror("usnewlock");
+        exit(-1);
+    }
+}
+void accept_mutex_on()
+{
+    switch(ussetlock(uslock)) {
+        case 1:
+            /* got lock */
+            break;
+        case 0:
+            fprintf(stderr, "didn't get lock\n");
+            exit(-1);
+        case -1:
+            perror("ussetlock");
+            exit(-1);
+    }
+}
+void accept_mutex_off()
+{
+    if (usunsetlock(uslock) == -1) {
+        perror("usunsetlock");
+        exit(-1);
+    }
+}
+#endif
+
+
+#ifndef USE_SHMGET_SCOREBOARD
+static void *get_shared_mem(apr_size_t size)
+{
+    void *result;
+
+    /* allocate shared memory for the shared_counter */
+    result = (unsigned long *)mmap ((caddr_t)0, size,
+		    PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
+    if (result == (void *)(caddr_t)-1) {
+	perror ("mmap");
+	exit (1);
+    }
+    return result;
+}
+#else
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+static void *get_shared_mem(apr_size_t size)
+{
+    key_t shmkey = IPC_PRIVATE;
+    int shmid = -1;
+    void *result;
+#ifdef MOVEBREAK
+    char *obrk;
+#endif
+
+    if ((shmid = shmget(shmkey, size, IPC_CREAT | SHM_R | SHM_W)) == -1) {
+	perror("shmget");
+	exit(1);
+    }
+
+#ifdef MOVEBREAK
+    /*
+     * Some SysV systems place the shared segment WAY too close
+     * to the dynamic memory break point (sbrk(0)). This severely
+     * limits the use of malloc/sbrk in the program since sbrk will
+     * refuse to move past that point.
+     *
+     * To get around this, we move the break point "way up there",
+     * attach the segment and then move break back down. Ugly
+     */
+    if ((obrk = sbrk(MOVEBREAK)) == (char *) -1) {
+	perror("sbrk");
+    }
+#endif
+
+#define BADSHMAT	((void *)(-1))
+    if ((result = shmat(shmid, 0, 0)) == BADSHMAT) {
+	perror("shmat");
+    }
+    /*
+     * We must avoid leaving segments in the kernel's
+     * (small) tables.
+     */
+    if (shmctl(shmid, IPC_RMID, NULL) != 0) {
+	perror("shmctl(IPC_RMID)");
+    }
+    if (result == BADSHMAT)	/* now bailout */
+	exit(1);
+
+#ifdef MOVEBREAK
+    if (obrk == (char *) -1)
+	return;			/* nothing else to do */
+    if (sbrk(-(MOVEBREAK)) == (char *) -1) {
+	perror("sbrk 2");
+    }
+#endif
+    return result;
+}
+#endif
+
+#ifdef _POSIX_PRIORITY_SCHEDULING
+/* don't ask */
+#define _P __P
+#include <sched.h>
+#define YIELD	sched_yield()
+#else
+#define YIELD	do { struct timeval zero; zero.tv_sec = zero.tv_usec = 0; select(0,0,0,0,&zero); } while(0)
+#endif
+
+void main (int argc, char **argv)
+{
+    int num_iter;
+    int num_child;
+    int i;
+    struct timeval first;
+    struct timeval last;
+    long ms;
+    int pid;
+    unsigned long *shared_counter;
+
+    if (argc != 3) {
+	fprintf (stderr, "Usage: time-sem num-child num iter\n");
+	exit (1);
+    }
+
+    num_child = atoi (argv[1]);
+    num_iter = atoi (argv[2]);
+
+    /* allocate shared memory for the shared_counter */
+    shared_counter = get_shared_mem(sizeof(*shared_counter));
+
+    /* initialize counter to 0 */
+    *shared_counter = 0;
+
+    accept_mutex_init ();
+
+    /* parent grabs mutex until done spawning children */
+    accept_mutex_on ();
+
+    for (i = 0; i < num_child; ++i) {
+	pid = fork();
+	if (pid == 0) {
+	    /* child, do our thing */
+	    accept_mutex_child_init();
+	    for (i = 0; i < num_iter; ++i) {
+		unsigned long tmp;
+
+		accept_mutex_on ();
+		tmp = *shared_counter;
+		YIELD;
+		*shared_counter = tmp + 1;
+		accept_mutex_off ();
+	    }
+	    exit (0);
+	} else if (pid == -1) {
+	    perror ("fork");
+	    exit (1);
+	}
+    }
+
+    /* a quick test to see that nothing is screwed up */
+    if (*shared_counter != 0) {
+	puts ("WTF! shared_counter != 0 before the children have been started!");
+	exit (1);
+    }
+
+    gettimeofday (&first, NULL);
+    /* launch children into action */
+    accept_mutex_off ();
+    for (i = 0; i < num_child; ++i) {
+	if (wait(NULL) == -1) {
+	    perror ("wait");
+	}
+    }
+    gettimeofday (&last, NULL);
+
+    if (*shared_counter != num_child * num_iter) {
+	printf ("WTF! shared_counter != num_child * num_iter!\n"
+		"shared_counter = %lu\nnum_child = %d\nnum_iter=%d\n",
+		*shared_counter,
+		num_child, num_iter);
+    }
+
+    last.tv_sec -= first.tv_sec;
+    ms = last.tv_usec - first.tv_usec;
+    if (ms < 0) {
+	--last.tv_sec;
+	ms += 1000000;
+    }
+    last.tv_usec = ms;
+    printf ("%8lu.%06lu\n", last.tv_sec, last.tv_usec);
+
+    accept_mutex_cleanup();
+
+    exit(0);
+}
+
diff --git a/rubbos/app/httpd-2.0.64/test/zb.c b/rubbos/app/httpd-2.0.64/test/zb.c
new file mode 100644
index 00000000..0a6666eb
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/test/zb.c
@@ -0,0 +1,567 @@
+
+/*                          ZeusBench V1.01
+			    ===============
+
+This program is Copyright (C) Zeus Technology Limited 1996.
+
+This program may be used and copied freely providing this copyright notice
+is not removed.
+
+This software is provided "as is" and any express or implied waranties, 
+including but not limited to, the implied warranties of merchantability and
+fitness for a particular purpose are disclaimed.  In no event shall 
+Zeus Technology Ltd. be liable for any direct, indirect, incidental, special, 
+exemplary, or consequential damaged (including, but not limited to, 
+procurement of substitute good or services; loss of use, data, or profits;
+or business interruption) however caused and on theory of liability.  Whether
+in contract, strict liability or tort (including negligence or otherwise) 
+arising in any way out of the use of this software, even if advised of the
+possibility of such damage.
+
+     Written by Adam Twiss (adam@zeus.co.uk).  March 1996
+
+Thanks to the following people for their input:
+  Mike Belshe (mbelshe@netscape.com) 
+  Michael Campanella (campanella@stevms.enet.dec.com)
+
+*/
+
+/* -------------------- Notes on compiling ------------------------------
+
+This should compile unmodified using gcc on HP-UX, FreeBSD, Linux,
+IRIX, Solaris, AIX and Digital Unix (OSF).  On Solaris 2.x you will
+need to compile with "-lnsl -lsocket" options.  If you have any
+difficulties compiling then let me know.
+
+On SunOS 4.x.x you may need to compile with -DSUNOS4 to add the following 
+two lines of code which appear not to exist in my SunOS headers */
+
+#ifdef SUNOS4
+extern char *optarg; 
+extern int optind, opterr, optopt;   
+#endif
+
+/*  -------------------------------------------------------------------- */
+
+/* affects include files on Solaris */
+#define BSD_COMP
+
+#include <sys/time.h> 
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h> 
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <string.h>
+
+/* ------------------- DEFINITIONS -------------------------- */
+
+/* maximum number of requests on a time limited test */
+#define MAX_REQUESTS 50000 
+
+/* good old state machine */
+#define STATE_UNCONNECTED 0
+#define STATE_CONNECTING  1
+#define STATE_READ        2
+
+#define CBUFFSIZE       512
+
+struct connection 
+{
+  int fd;
+  int state;
+  int read;       /* amount of bytes read */
+  int bread;      /* amount of body read */
+  int length;     /* Content-Length value used for keep-alive */
+  char cbuff[CBUFFSIZE];  /* a buffer to store server response header */
+  int cbx;                /* offset in cbuffer */
+  int keepalive;          /* non-zero if a keep-alive request */
+  int gotheader;          /* non-zero if we have the entire header in cbuff */
+  struct timeval start, connect, done; 
+};
+
+struct data 
+{
+  int read;      /* number of bytes read */
+  int ctime;     /* time in ms to connect */
+  int time;      /* time in ms for connection */
+};
+
+#define min(a,b) ((a)<(b))?(a):(b)
+#define max(a,b) ((a)>(b))?(a):(b)
+
+/* --------------------- GLOBALS ---------------------------- */
+
+int requests = 1;      /* Number of requests to make */
+int concurrency = 1;   /* Number of multiple requests to make */
+int tlimit = 0;        /* time limit in cs */
+int keepalive = 0;     /* try and do keepalive connections */
+char *machine;         /* Machine name */
+char *file;            /* file name to use */
+char server_name[80];  /* name that server reports */
+int port = 80;         /* port to use */
+
+int doclen = 0;        /* the length the document should be */
+int totalread = 0;     /* total number of bytes read */
+int totalbread = 0;    /* totoal amount of entity body read */
+int done=0;            /* number of requests we have done */
+int doneka=0;          /* number of keep alive connections done */
+int good=0, bad=0;     /* number of good and bad requests */
+
+/* store error cases */
+int err_length = 0, err_conn = 0, err_except = 0;
+
+struct timeval start, endtime;
+
+/* global request (and its length) */
+char request[512];
+int reqlen;
+
+/* one global throw-away buffer to read stuff into */
+char buffer[4096];
+
+struct connection *con;      /* connection array */
+struct data *stats;          /* date for each request */
+
+fd_set readbits, writebits;  /* bits for select */
+struct sockaddr_in server;   /* server addr structure */
+
+/* --------------------------------------------------------- */
+
+/* simple little function to perror and exit */
+
+static void err(char *s) 
+{
+  perror(s);
+  exit(errno);
+}
+
+/* --------------------------------------------------------- */
+
+/* write out request to a connection - assumes we can write 
+   (small) request out in one go into our new socket buffer  */
+
+void write_request(struct connection *c)
+{
+  gettimeofday(&c->connect,0);
+  write(c->fd,request, reqlen);  
+  c->state = STATE_READ;
+  FD_SET(c->fd, &readbits);
+  FD_CLR(c->fd, &writebits);
+}
+
+/* --------------------------------------------------------- */
+
+/* make an fd non blocking */
+
+void nonblock(int fd) 
+{
+  int i=1;
+  ioctl(fd, FIONBIO, &i);
+}
+
+/* --------------------------------------------------------- */
+
+/* returns the time in ms between two timevals */
+
+int timedif(struct timeval a, struct timeval b)
+{
+  register int us,s;
+
+  us = a.tv_usec - b.tv_usec;
+  us /= 1000;
+  s = a.tv_sec - b.tv_sec;
+  s *= 1000;
+  return s+us;
+}
+
+/* --------------------------------------------------------- */
+
+/* calculate and output results and exit */
+
+void output_results()
+{
+  int timetaken;
+  
+  gettimeofday(&endtime,0);
+  timetaken = timedif(endtime, start);
+  
+  printf("\n---\n");
+  printf("Server:                 %s\n", server_name);
+  printf("Document Length:        %d\n", doclen);  
+  printf("Concurency Level:       %d\n", concurrency);
+  printf("Time taken for tests:   %d.%03d seconds\n", 
+	 timetaken/1000, timetaken%1000);
+  printf("Complete requests:      %d\n", done);
+  printf("Failed requests:        %d\n", bad);
+  if(bad) printf("   (Connect: %d, Length: %d, Exceptions: %d)\n",
+		 err_conn, err_length, err_except);
+  if(keepalive) printf("Keep-Alive requests:    %d\n", doneka);
+  printf("Bytes transfered:       %d\n", totalread);
+  printf("HTML transfered:        %d\n", totalbread);
+  
+  /* avoid divide by zero */
+  if(timetaken) {
+    printf("Requests per seconds:   %.2f\n", 1000*(float)(done)/timetaken);
+    printf("Transfer rate:          %.2f kb/s\n", 
+	   (float)(totalread)/timetaken);
+  }
+
+  {
+    /* work out connection times */
+    int i;
+    int totalcon=0, total=0;
+    int mincon=9999999, mintot=999999;
+    int maxcon=0, maxtot=0;
+
+    for(i=0; i<requests; i++) {
+      struct data s = stats[i];
+      mincon = min(mincon, s.ctime);
+      mintot = min(mintot, s.time);
+      maxcon = max(maxcon, s.ctime);
+      maxtot = max(maxtot, s.time);
+      totalcon += s.ctime;
+      total += s.time;
+    }
+    printf("\nConnnection Times (ms)\n");
+    printf("           min   avg   max\n");
+    printf("Connect: %5d %5d %5d\n",mincon, totalcon/requests, maxcon );
+    printf("Total:   %5d %5d %5d\n", mintot, total/requests, maxtot);
+    printf("---\n\n");
+  }
+
+  exit(0);
+}
+
+/* --------------------------------------------------------- */
+
+/* start asnchronous non-blocking connection */
+
+void start_connect(struct connection *c)
+{
+  c->read = 0;
+  c->bread = 0;
+  c->keepalive = 0;
+  c->cbx = 0; 
+  c->gotheader = 0;
+
+  c->fd = socket(AF_INET, SOCK_STREAM, 0);
+  if(c->fd<0) err("socket");
+
+  nonblock(c->fd);
+  gettimeofday(&c->start,0);
+
+  if(connect(c->fd, (struct sockaddr *) &server, sizeof(server))<0) {
+    if(errno==EINPROGRESS) {
+      c->state = STATE_CONNECTING;
+      FD_SET(c->fd, &writebits);
+      return;
+    }
+    else {
+      close(c->fd);
+      err_conn++;
+      if(bad++>10) {
+	printf("\nTest aborted after 10 failures\n\n");
+	exit(1);
+      } 
+      start_connect(c);
+    }      
+  }
+  
+  /* connected first time */
+  write_request(c);
+}
+
+/* --------------------------------------------------------- */
+
+/* close down connection and save stats */
+
+void close_connection(struct connection *c)
+{
+  if(c->read == 0 && c->keepalive) {
+    /* server has legitiamately shut down an idle keep alive request */
+    good--;  /* connection never happend */
+  } 
+  else {
+    if(good==1) {
+      /* first time here */
+      doclen = c->bread;
+    } else if (c->bread!=doclen) { 
+      bad++; 
+      err_length++; 
+    }
+    
+    /* save out time */
+    if(done < requests) {
+      struct data s;
+      gettimeofday(&c->done,0);
+      s.read = c->read;
+      s.ctime = timedif(c->connect, c->start);
+      s.time = timedif(c->done, c->start);
+      stats[done++] = s;
+    }
+  }
+
+  close(c->fd);
+  FD_CLR(c->fd, &readbits);
+  FD_CLR(c->fd, &writebits);
+
+  /* connect again */
+  start_connect(c); 
+  return;
+}
+
+/* --------------------------------------------------------- */
+
+/* read data from connection */
+
+void read_connection(struct connection *c)
+{
+  int r;
+  
+  r=read(c->fd,buffer,sizeof(buffer));
+  if(r==0 || (r<0 && errno!=EAGAIN)) {
+    good++;
+    close_connection(c);
+    return;
+  } 
+  
+  if(r<0 && errno==EAGAIN) return;
+
+  c->read += r;
+  totalread += r;
+  
+  if(!c->gotheader) {
+    char *s;
+    int l=4;
+    int space = CBUFFSIZE - c->cbx - 1; /* -1 to allow for 0 terminator */
+    int tocopy = (space<r)?space:r;
+    memcpy(c->cbuff+c->cbx, buffer, space);
+    c->cbx += tocopy; space -= tocopy;
+    c->cbuff[c->cbx] = 0; /* terminate for benefit of strstr */
+    s = strstr(c->cbuff, "\r\n\r\n");
+    /* this next line is so that we talk to NCSA 1.5 which blatantly breaks 
+       the http specifaction */
+    if(!s) { s = strstr(c->cbuff,"\n\n"); l=2; }
+
+    if(!s) {
+       /* read rest next time */
+      if(space) 
+	return;
+      else {
+	/* header is in invalid or too big - close connection */
+	close(c->fd);
+	if(bad++>10) {
+	  printf("\nTest aborted after 10 failures\n\n");
+	  exit(1);
+	} 
+	FD_CLR(c->fd, &writebits);
+	start_connect(c);
+      }	
+    }
+    else {
+      /* have full header */
+      if(!good) {
+	/* this is first time, extract some interesting info */
+	char *p, *q;
+	p = strstr(c->cbuff, "Server:");
+	q = server_name;
+	if(p) { p+=8; while(*p>32) *q++ = *p++; }
+	*q = 0;
+      }
+	
+      c->gotheader = 1;
+      *s = 0; /* terminate at end of header */
+      if(keepalive && 
+	 (strstr(c->cbuff, "Keep-Alive") 
+	  || strstr(c->cbuff, "keep-alive")))  /* for benefit of MSIIS */
+	{
+	char *cl;
+	cl = strstr(c->cbuff, "Content-Length:");
+	/* for cacky servers like NCSA which break the spec and send a 
+	   lower case 'l' */
+	if(!cl) cl = strstr(c->cbuff, "Content-length:");
+	if(cl) {
+	  c->keepalive=1;
+	  c->length = atoi(cl+16);
+	}
+      }
+      c->bread += c->cbx - (s+l-c->cbuff) + r-tocopy;
+      totalbread += c->bread;
+    }
+  }  
+  else {
+    /* outside header, everything we have read is entity body */
+    c->bread += r;
+    totalbread += r;
+  }
+
+  if(c->keepalive && (c->bread >= c->length)) {
+    /* finished a keep-alive connection */
+    good++; doneka++;
+    /* save out time */
+    if(good==1) {
+      /* first time here */
+      doclen = c->bread;
+    } else if(c->bread!=doclen) { bad++; err_length++; }
+    if(done < requests) {
+      struct data s;
+      gettimeofday(&c->done,0);
+      s.read = c->read;
+      s.ctime = timedif(c->connect, c->start);
+      s.time = timedif(c->done, c->start);
+      stats[done++] = s;
+    }
+    c->keepalive = 0; c->length = 0; c->gotheader=0; c->cbx = 0;
+    c->read = c->bread = 0;
+    write_request(c);
+    c->start = c->connect; /* zero connect time with keep-alive */
+  }
+}
+
+/* --------------------------------------------------------- */
+
+/* run the tests */
+
+int test() 
+{
+  struct timeval timeout, now;
+  fd_set sel_read, sel_except, sel_write;
+  int i;
+  
+  {
+    /* get server information */
+    struct hostent *he;
+    he = gethostbyname(machine);
+    if (!he) err("gethostbyname");
+    server.sin_family      = he->h_addrtype;
+    server.sin_port        = htons(port);
+    server.sin_addr.s_addr = ((unsigned long *)(he->h_addr_list[0]))[0];
+  }
+
+  con = malloc(concurrency*sizeof(struct connection));
+  memset(con,0,concurrency*sizeof(struct connection));
+  
+  stats = malloc(requests * sizeof(struct data));
+
+  FD_ZERO(&readbits);
+  FD_ZERO(&writebits);
+
+  /* setup request */
+  sprintf(request,"GET %s HTTP/1.0\r\nUser-Agent: ZeusBench/1.0\r\n"
+	  "%sHost: %s\r\nAccept: */*\r\n\r\n", file, 
+	  keepalive?"Connection: Keep-Alive\r\n":"", machine );
+    
+  reqlen = strlen(request);
+
+  /* ok - lets start */
+  gettimeofday(&start,0);
+
+  /* initialise lots of requests */
+  for(i=0; i<concurrency; i++) start_connect(&con[i]);
+
+  while(done<requests) {
+    int n;
+    /* setup bit arrays */
+    memcpy(&sel_except, &readbits, sizeof(readbits));
+    memcpy(&sel_read, &readbits, sizeof(readbits));
+    memcpy(&sel_write, &writebits, sizeof(readbits));
+
+    /* check for time limit expiry */
+    gettimeofday(&now,0);
+    if(tlimit && timedif(now,start) > (tlimit*1000)) {
+      requests=done;   /* so stats are correct */
+      output_results();
+    }
+
+    /* Timeout of 30 seconds. */
+    timeout.tv_sec=30; timeout.tv_usec=0;
+    n=select(256, &sel_read, &sel_write, &sel_except, &timeout);
+    if(!n) {
+      printf("\nServer timed out\n\n");
+      exit(1);
+    }
+    if(n<1) err("select");
+
+    for(i=0; i<concurrency; i++) {
+      int s = con[i].fd;
+      if(FD_ISSET(s, &sel_except)) {
+	bad++; 
+	err_except++;
+	start_connect(&con[i]);
+	continue;
+      }
+      if(FD_ISSET(s, &sel_read)) read_connection(&con[i]);
+      if(FD_ISSET(s, &sel_write)) write_request(&con[i]);
+    }
+    if(done>=requests) output_results();
+  }
+  return 0;
+}
+
+/* ------------------------------------------------------- */
+
+/* display usage information */
+
+void usage(char *progname) {
+  printf("\nZeusBench v1.0\n\n");
+  printf("Usage: %s <machine> <file> [-k] [-n requests | -t timelimit (sec)]"
+	 "\n\t\t[-c concurrency] [-p port] \n",progname);
+  printf("Filename should start with a '/' e.g. /index.html\n\n");
+  exit(EINVAL);
+}
+
+/* ------------------------------------------------------- */
+
+/* sort out command-line args and call test */
+
+int main(int argc, char **argv) {
+  int c;
+  if (argc < 3) usage(argv[0]);
+  
+  machine = argv[1]; 
+  file = argv[2];
+  optind = 3;
+  while ((c = getopt(argc,argv,"p:n:c:d:t:d:k"))>0) {
+    switch(c) {
+    case 'd':
+      break;
+    case 'n': 
+      requests = atoi(optarg);
+      if(!requests) {
+	printf("Invalid number of requests\n");
+	exit(1);
+      }
+      break;
+    case 'k':
+      keepalive=1;
+      break;
+    case 'c':
+      concurrency = atoi(optarg);
+      break;
+    case 'p':
+      port = atoi(optarg);
+      break;
+    case 't':
+      tlimit = atoi(optarg);
+      requests = MAX_REQUESTS;  /* need to size data array on something */
+      break;
+    default:
+      usage(argv[0]);
+      break;
+    }
+  }   
+  test();
+  return 0;
+}
+
+
+
+
+
+