diff -urN linux-2.4.1/.cvsignore linux-2.4.1-korbit/.cvsignore
--- linux-2.4.1/.cvsignore	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/.cvsignore	Thu Feb  1 11:46:48 2001
@@ -0,0 +1 @@
+makekorbit.sh
diff -urN linux-2.4.1/KORBit.Announce linux-2.4.1-korbit/KORBit.Announce
--- linux-2.4.1/KORBit.Announce	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/KORBit.Announce	Thu Feb  1 11:46:48 2001
@@ -0,0 +1,62 @@
+From sabre@nondot.org Fri Dec  8 15:15:43 2000
+Date: Fri, 8 Dec 2000 17:10:47 -0600 (CST)
+From: Chris Lattner <sabre@nondot.org>
+To: linux-kernel@vger.kernel.org, orbit-list@gnome.org
+Cc: korbit-cvs@lists.sourceforge.net
+Subject: ANNOUNCE: Linux Kernel ORB: kORBit
+
+
+This email is here to announce the availability of a port of ORBit (the
+GNOME ORB) to the Linux kernel.  This ORB, named kORBit, is available from
+our sourceforge web site (http://korbit.sourceforge.net/).  A kernel ORB
+allows you to write kernel extensions in CORBA and have the kernel call
+into them, or to call into the kernel through CORBA.  This opens the door
+to a wide range of experiments/hacks:
+
+* We can now write device drivers in perl, and let them run on the iMAC
+  across the hall from you. :)
+* Through the use of a LD_PRELOAD'd syscall wrapper library, you can
+  forward system calls through CORBA to an arbitrary local/remote machine.
+* CORBA servers are implemented as Linux kernel modules, so they may be
+  dynamically loaded or unloaded from a running system at any time.  CORBA
+  servers expose their IOR's through a /proc/corba filesystem.
+* Filesystems may be implemented as remote CORBA objects and mounted on
+  the local machine, by using 'mount -t corbafs -o IOR:... none /mnt/corba'
+
+This are just some of the features available _RIGHT_NOW_ that are
+supported by kORBit.  I'm sure that YOU can think of many more.
+
+Implementation:
+We implemented this port by providing a user->kernel mapping layer that
+consists of providing standard system header files for the "user" code to
+#include.  In these header files, we do the mapping required.  For
+example, we implement a <stdio.h> that #defines printf to printk (as a
+trivial example).  Only user level code sees or uses these wrappers... all
+of our modifications to the Linux kernel are contained within the
+linux/net/korbit subdirectory.  
+
+This is currently implemented with a 2.4.0test10 kernel, although forward
+porting should be very easy.  This project was implemented as a cs423
+semester project by Chris Lattner, Fredrik Vraalsen, Andy Reitz, and Keith
+Wessel at the University of Illinois @ Urbana Champaign.
+
+Unresolved issues:
+* Our poll model is not optimial.  Currently we actually do a real poll on
+  a (struct socket *) set.  This causes relatively high latencies (on the
+  order 1 second, worst case) for CORBA requests.  Our waitqueues are not
+  working quite as well as they should.  :)
+* Security is completely unimplemented.  Someone could use corba
+  interfaces to read any file on your system, for example (if the
+  CORBA-FileServer module is installed).  Thus, this is really more for
+  prototyping and development than actual real world use. :)
+
+If you have any questions or comments, please feel free to contact us at:
+
+Chris Lattner, Fredrik Vraalsen, Andy Reitz, Keith Wessel
+<korbit-cvs@lists.sourceforge.net>
+
+btw, yes we are quite crazy, but what good is it to be normal and
+conformist afterall?  :)
+
+
+
diff -urN linux-2.4.1/Makefile linux-2.4.1-korbit/Makefile
--- linux-2.4.1/Makefile	Tue Jan 30 09:19:26 2001
+++ linux-2.4.1-korbit/Makefile	Thu Feb  1 15:48:45 2001
@@ -70,7 +70,7 @@
 # images.  Uncomment if you want to place them anywhere other than root.
 #
 
-#export	INSTALL_PATH=/boot
+export	INSTALL_PATH=/boot
 
 #
 # INSTALL_MOD_PATH specifies a prefix to MODLIB for module directory
diff -urN linux-2.4.1/README.korbit linux-2.4.1-korbit/README.korbit
--- linux-2.4.1/README.korbit	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/README.korbit	Thu Feb  1 11:46:48 2001
@@ -0,0 +1,83 @@
+			 ====================
+			 KORBit: A CORBA ORB
+			 For The Linux Kernel
+			 ====================
+
+	       Submitted as a final project in CS423 by
+		  Chris Lattner <lattner@uiuc.edu>,
+		    Andy Reitz <areitz@uiuc.edu>,
+	      Fredrik Vraalsen <vraalsen@uiuc.edu>, and
+		   Keith Wessel <kwessel@uiuc.edu>
+
+			   December 8, 2000
+
+
+About:
+======
+KORBit is a port of the CORBA Object Request Broker ORBit to the Linux
+kernel.  For more information, see http://korbit.sourceforge.net/
+
+In order to use this code, you need to have ORBit-0.5.3 or later
+installed (including the development environment). The KORBit server
+modules make use of the ORBit IDL Compiler during the build process.
+
+Building The Code:
+==================
+In order to compile and run KORBit you need a recent 2.4.0-test
+version of the Linux kernel (KORBit is developed on 2.4.0-test10).
+
+To obtain a copy of the KORBit source code, see the webpage above.
+Once you have untar'ed the source code, copy the contents of the linux
+subdirectory of KORBit into the Linux root source directory
+(e.g. /usr/src/linux).
+
+Run your favourite configuration option for Linux (e.g. 'make
+menuconfig').  To enable KORBit support in the kernel, go into the
+'Networking options' section of the configuration and enable 'Kernel
+ORB'.  Then add the various CORBA services that you wish to run in the
+kernel.
+
+NOTE: The Kernel ORB *must* be compiled statically into the kernel
+(answer 'Y') and CORBA services *must* be compiled as modules (answer
+'M') at the moment.
+
+Then compile and install the Linux kernel in the standard way, e.g.:
+
+make dep ; make clean ; make bzImage ; make modules ; make modules_install
+
+Copy System.map and arch/<i386|whatever>/boot/bzImage to the proper
+places (/boot), edit your lilo.conf, run lilo and reboot.
+
+You should now be able to use CORBA in your Linux kernel!  Remember,
+this is *pre-alpha* software!  Use on your own risk!  Don't come to us
+crying if your machine blows up...
+
+Using Our Example KORBit Objects:
+=================================
+The "CORBA Echo Server" is effectively our "hello world" object. Once
+loaded into the kernel, module will instantiate an object that
+implements the "echoString()" interface. This method allows the client
+to send a string, which will be printed on the system console. Then,
+it will return a random number, which the client will print. Thus,
+after running this test, you will verify that two-way communication is
+working between KORBit and your ORB of choice.
+
+To insert this module into your newly-compiled kernel, type 
+
+insmod /lib/modules/2.4.0-test10/kernel/net/korbit/modules/Echo/server/corba-echo-server.o 
+
+Next verify that this module is actually loaded, by invoking
+"lsmod". You should see something like this:
+
+	Module			Size  Used by
+	corba-echo-server	3344   0 (unused)
+
+Now, you can grab the IOR to this object by typing "cat
+/proc/corba/echo-server". Now, you need to build the echo client,
+which will use this IOR in order to connect to the echo server. This
+can be accomplished by simply changing to the
+"/usr/src/linux/net/korbit/modules/Echo/client" directory, and then
+typing "make". Once finished, simply type "./echo-client `cat
+/proc/corba/echo-server`", and then cross your fingers!
+
+
diff -urN linux-2.4.1/Rules.make linux-2.4.1-korbit/Rules.make
--- linux-2.4.1/Rules.make	Sat Dec 30 00:07:19 2000
+++ linux-2.4.1-korbit/Rules.make	Thu Feb  1 15:46:07 2001
@@ -222,9 +222,9 @@
 
 $(MODINCL)/%.ver: %.c
 	@if [ ! -r $(MODINCL)/$*.stamp -o $(MODINCL)/$*.stamp -ot $< ]; then \
-		echo '$(CC) $(CFLAGS) -E -D__GENKSYMS__ $<'; \
+		echo '$(CC) $(CFLAGS) $(EXTRA_CFLAGS) -E -D__GENKSYMS__ $<'; \
 		echo '| $(GENKSYMS) $(genksyms_smp_prefix) -k $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) > $@.tmp'; \
-		$(CC) $(CFLAGS) -E -D__GENKSYMS__ $< \
+		$(CC) $(CFLAGS) $(EXTRA_CFLAGS) -E -D__GENKSYMS__ $< \
 		| $(GENKSYMS) $(genksyms_smp_prefix) -k $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) > $@.tmp; \
 		if [ -r $@ ] && cmp -s $@ $@.tmp; then echo $@ is unchanged; rm -f $@.tmp; \
 		else echo mv $@.tmp $@; mv -f $@.tmp $@; fi; \
diff -urN linux-2.4.1/korbit.patch linux-2.4.1-korbit/korbit.patch
--- linux-2.4.1/korbit.patch	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/korbit.patch	Thu Feb  1 11:46:48 2001
@@ -0,0 +1,43 @@
+--- linux/Rules.make.orig	Wed Jan 31 22:50:40 2001
++++ linux/Rules.make	Thu Feb  1 01:39:46 2001
+@@ -222,9 +222,9 @@
+ 
+ $(MODINCL)/%.ver: %.c
+ 	@if [ ! -r $(MODINCL)/$*.stamp -o $(MODINCL)/$*.stamp -ot $< ]; then \
+-		echo '$(CC) $(CFLAGS) -E -D__GENKSYMS__ $<'; \
++		echo '$(CC) $(CFLAGS) $(EXTRA_CFLAGS) -E -D__GENKSYMS__ $<'; \
+ 		echo '| $(GENKSYMS) $(genksyms_smp_prefix) -k $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) > $@.tmp'; \
+-		$(CC) $(CFLAGS) -E -D__GENKSYMS__ $< \
++		$(CC) $(CFLAGS) $(EXTRA_CFLAGS) -E -D__GENKSYMS__ $< \
+ 		| $(GENKSYMS) $(genksyms_smp_prefix) -k $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) > $@.tmp; \
+ 		if [ -r $@ ] && cmp -s $@ $@.tmp; then echo $@ is unchanged; rm -f $@.tmp; \
+ 		else echo mv $@.tmp $@; mv -f $@.tmp $@; fi; \
+--- linux/net/Config.in.orig	Wed Jan 31 22:39:32 2001
++++ linux/net/Config.in	Thu Feb  1 01:40:02 2001
+@@ -30,6 +30,7 @@
+    fi
+    if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
+       source net/khttpd/Config.in
++      source net/korbit/Config.in
+    fi
+ fi
+ if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
+--- linux/net/Makefile.orig	Thu Feb  1 01:41:42 2001
++++ linux/net/Makefile	Thu Feb  1 01:41:35 2001
+@@ -7,7 +7,7 @@
+ 
+ O_TARGET :=	network.o
+ 
+-mod-subdirs :=	ipv4/netfilter ipv6/netfilter ipx irda atm netlink sched
++mod-subdirs :=	ipv4/netfilter ipv6/netfilter ipx irda atm netlink sched korbit
+ export-objs :=	netsyms.o
+ 
+ subdir-y :=	core ethernet
+@@ -27,6 +27,7 @@
+ endif
+ 
+ subdir-$(CONFIG_KHTTPD)		+= khttpd
++subdir-$(CONFIG_KORBIT)		+= korbit
+ subdir-$(CONFIG_NETLINK)	+= netlink
+ subdir-$(CONFIG_PACKET)		+= packet
+ subdir-$(CONFIG_NET_SCHED)	+= sched
diff -urN linux-2.4.1/makekorbit.sh linux-2.4.1-korbit/makekorbit.sh
--- linux-2.4.1/makekorbit.sh	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/makekorbit.sh	Thu Feb  1 11:46:48 2001
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+make CFLAGS="-D__KERNEL__ -I`pwd`/include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strict-aliasing -pipe -march=k6  -DHAVE_CONFIG_H -DHAVE_UNISTD_H -I. -I.. -I../include -nostdinc" -C  net/korbit TOPDIR=`pwd`
+
diff -urN linux-2.4.1/net/CVS/Entries linux-2.4.1-korbit/net/CVS/Entries
--- linux-2.4.1/net/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/CVS/Entries	Thu Feb  1 11:46:49 2001
@@ -0,0 +1 @@
+D
diff -urN linux-2.4.1/net/CVS/Entries.Log linux-2.4.1-korbit/net/CVS/Entries.Log
--- linux-2.4.1/net/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/CVS/Entries.Log	Thu Feb  1 11:46:49 2001
@@ -0,0 +1 @@
+A D/korbit////
diff -urN linux-2.4.1/net/CVS/Repository linux-2.4.1-korbit/net/CVS/Repository
--- linux-2.4.1/net/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/CVS/Repository	Thu Feb  1 11:46:49 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net
diff -urN linux-2.4.1/net/CVS/Root linux-2.4.1-korbit/net/CVS/Root
--- linux-2.4.1/net/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/CVS/Root	Thu Feb  1 11:46:49 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/Config.in linux-2.4.1-korbit/net/Config.in
--- linux-2.4.1/net/Config.in	Tue Oct 10 19:33:52 2000
+++ linux-2.4.1-korbit/net/Config.in	Thu Feb  1 15:46:07 2001
@@ -30,6 +30,7 @@
    fi
    if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
       source net/khttpd/Config.in
+      source net/korbit/Config.in
    fi
 fi
 if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
diff -urN linux-2.4.1/net/Makefile linux-2.4.1-korbit/net/Makefile
--- linux-2.4.1/net/Makefile	Sat Dec 30 00:07:24 2000
+++ linux-2.4.1-korbit/net/Makefile	Thu Feb  1 15:46:07 2001
@@ -7,7 +7,7 @@
 
 O_TARGET :=	network.o
 
-mod-subdirs :=	ipv4/netfilter ipv6/netfilter ipx irda atm netlink sched
+mod-subdirs :=	ipv4/netfilter ipv6/netfilter ipx irda atm netlink sched korbit
 export-objs :=	netsyms.o
 
 subdir-y :=	core ethernet
@@ -27,6 +27,7 @@
 endif
 
 subdir-$(CONFIG_KHTTPD)		+= khttpd
+subdir-$(CONFIG_KORBIT)		+= korbit
 subdir-$(CONFIG_NETLINK)	+= netlink
 subdir-$(CONFIG_PACKET)		+= packet
 subdir-$(CONFIG_NET_SCHED)	+= sched
diff -urN linux-2.4.1/net/korbit/CVS/Entries linux-2.4.1-korbit/net/korbit/CVS/Entries
--- linux-2.4.1/net/korbit/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/CVS/Entries	Thu Feb  1 11:46:49 2001
@@ -0,0 +1,6 @@
+/Config.in/1.3/Thu Feb  1 09:46:49 2001//
+/Makefile/1.7/Thu Feb  1 09:46:49 2001//
+/config.h/1.2/Thu Feb  1 09:46:49 2001//
+/exported_symbols.c/1.8/Thu Feb  1 09:46:49 2001//
+/korbit.h/1.2/Thu Feb  1 09:46:49 2001//
+D
diff -urN linux-2.4.1/net/korbit/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/CVS/Entries.Log
--- linux-2.4.1/net/korbit/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/CVS/Entries.Log	Thu Feb  1 11:47:15 2001
@@ -0,0 +1,7 @@
+A D/IIOP////
+A D/ORBitutil////
+A D/include////
+A D/kglib////
+A D/modules////
+A D/orb////
+A D/sup////
diff -urN linux-2.4.1/net/korbit/CVS/Repository linux-2.4.1-korbit/net/korbit/CVS/Repository
--- linux-2.4.1/net/korbit/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/CVS/Repository	Thu Feb  1 11:46:49 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit
diff -urN linux-2.4.1/net/korbit/CVS/Root linux-2.4.1-korbit/net/korbit/CVS/Root
--- linux-2.4.1/net/korbit/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/CVS/Root	Thu Feb  1 11:46:49 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/Config.in linux-2.4.1-korbit/net/korbit/Config.in
--- linux-2.4.1/net/korbit/Config.in	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/Config.in	Thu Feb  1 11:46:49 2001
@@ -0,0 +1,8 @@
+#
+# KORBit
+#
+
+#tristate '  Kernel ORB (EXPERIMENTAL)' CONFIG_KORBIT
+bool '  Kernel ORB (EXPERIMENTAL)' CONFIG_KORBIT
+
+source net/korbit/modules/Config.in
diff -urN linux-2.4.1/net/korbit/IIOP/CVS/Entries linux-2.4.1-korbit/net/korbit/IIOP/CVS/Entries
--- linux-2.4.1/net/korbit/IIOP/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/CVS/Entries	Thu Feb  1 11:46:51 2001
@@ -0,0 +1,15 @@
+/IIOP-config.h/1.1.1.1/Thu Feb  1 09:46:50 2001//
+/IIOP-design.txt/1.1.1.1/Thu Feb  1 09:46:50 2001//
+/IIOP-private.h/1.2/Thu Feb  1 09:46:50 2001//
+/IIOP-types.h/1.1.1.1/Thu Feb  1 09:46:50 2001//
+/IIOP.h/1.1.1.1/Thu Feb  1 09:46:50 2001//
+/Makefile/1.4/Thu Feb  1 09:46:51 2001//
+/connection.c/1.19/Thu Feb  1 09:46:51 2001//
+/encoders.c/1.1.1.1/Thu Feb  1 09:46:51 2001//
+/giop-msg-buffer.c/1.12/Thu Feb  1 09:46:51 2001//
+/giop-msg-buffer.h/1.1.1.1/Thu Feb  1 09:46:51 2001//
+/iiop-encoders.h/1.1.1.1/Thu Feb  1 09:46:51 2001//
+/iiop-endian.c/1.1.1.1/Thu Feb  1 09:46:51 2001//
+/iiop-endian.h/1.1.1.1/Thu Feb  1 09:46:51 2001//
+/iiop-endianP.h/1.1.1.1/Thu Feb  1 09:46:51 2001//
+D
diff -urN linux-2.4.1/net/korbit/IIOP/CVS/Repository linux-2.4.1-korbit/net/korbit/IIOP/CVS/Repository
--- linux-2.4.1/net/korbit/IIOP/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/CVS/Repository	Thu Feb  1 11:46:50 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/IIOP
diff -urN linux-2.4.1/net/korbit/IIOP/CVS/Root linux-2.4.1-korbit/net/korbit/IIOP/CVS/Root
--- linux-2.4.1/net/korbit/IIOP/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/CVS/Root	Thu Feb  1 11:46:49 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/IIOP/IIOP-config.h linux-2.4.1-korbit/net/korbit/IIOP/IIOP-config.h
--- linux-2.4.1/net/korbit/IIOP/IIOP-config.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/IIOP-config.h	Thu Feb  1 11:46:50 2001
@@ -0,0 +1,5 @@
+/* The size of the chunks that are used for indirect pieces of messages.
+   Too low, and you'll have a lot of malloc overhead. Too high, and you'll
+   get wasted mem.
+*/
+#define GIOP_INDIRECT_CHUNK_SIZE 1024
diff -urN linux-2.4.1/net/korbit/IIOP/IIOP-design.txt linux-2.4.1-korbit/net/korbit/IIOP/IIOP-design.txt
--- linux-2.4.1/net/korbit/IIOP/IIOP-design.txt	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/IIOP-design.txt	Thu Feb  1 11:46:50 2001
@@ -0,0 +1,14 @@
+
+void Hello_hello(CORBA_Object anobj, const char *arg1, CORBA_Environment *ev)
+
+If we're doing a local call (i.e. shared library object activation),
+just do it.
+
+If we're doing a remote call, we need to setup generic header
+(utilfunc), setup request header (utilfunc), encode arguments (stubs),
+send the message headers & body (utilfunc) and wait for a reply (XXX
+define more clearly).  When we get the reply, we need to read the
+reply(utilfunc), decode the return value & out/inout arguments(stubs)
+& fill them in (or decode the exception that resulted (utilfunc)), and 
+return.
+
diff -urN linux-2.4.1/net/korbit/IIOP/IIOP-private.h linux-2.4.1-korbit/net/korbit/IIOP/IIOP-private.h
--- linux-2.4.1/net/korbit/IIOP/IIOP-private.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/IIOP-private.h	Thu Feb  1 11:46:50 2001
@@ -0,0 +1,46 @@
+#ifndef IIOP_PRIVATE_H
+#define IIOP_PRIVATE_H 1
+
+
+#include "config.h"
+
+#if defined(HAVE_POLL) && defined(I_WANT_POLL)
+#define USE_POLL
+#else
+#undef USE_POLL
+#endif
+
+#ifdef HAVE_SYS_POLL_H
+#include <sys/poll.h>
+#endif
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <glib.h>
+
+typedef struct {
+  GList *list;
+  gboolean connection_list_changed;
+#ifndef __KORBIT__
+  GPtrArray *fd_to_connection_mapping;
+#else /* __KORBIT__ */
+  GHashTable *fd_to_connection_mapping;
+#endif /* __KORBIT__ */
+#  ifdef USE_POLL
+  GArray *pollset;
+#  else
+  fd_set selectset_rd, selectset_ex;
+#  endif
+  int max_fd;
+} GIOPConnectionList;
+
+extern GIOPConnectionList giop_connection_list;
+
+/* If you get a buffer that you didn't want, add it to the list! */
+void giop_received_list_push(GIOPRecvBuffer *recv_buffer);
+GIOPRecvBuffer *giop_received_list_pop(void);
+
+
+#endif
diff -urN linux-2.4.1/net/korbit/IIOP/IIOP-types.h linux-2.4.1-korbit/net/korbit/IIOP/IIOP-types.h
--- linux-2.4.1/net/korbit/IIOP/IIOP-types.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/IIOP-types.h	Thu Feb  1 11:46:50 2001
@@ -0,0 +1,76 @@
+#ifndef IIOP_TYPES_H
+#define IIOP_TYPES_H 1
+
+/* XXX todo sync this up with basic_types.h if needed */
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+#include <ORBitutil/basic_types.h>
+
+typedef enum {
+  GIOP_CONNECTION_SERVER, /* Not a real connection to any place - just
+			     listening */
+  GIOP_CONNECTION_CLIENT
+} GIOPConnectionClass;
+
+typedef struct _GIOPConnection GIOPConnection;
+struct _GIOPConnection {
+  enum { GIOP_CONNECTION_NONE, GIOP_CONNECTION_IIOP } connection_type;
+  void (*destroy_func)(GIOPConnection *connection);
+
+  gint refcount;
+  GIOPConnectionClass connection_class;
+
+  int fd;
+
+  /* You can access these if you wish. */
+  gpointer orb_data;
+  gpointer user_data;
+  /* end accessable stuff */
+
+  guchar is_valid, was_initiated, is_auth;
+
+  gpointer incoming_msg; /* GIOPRecvBuffer */
+};
+
+#define GIOP_CONNECTION(x) ((GIOPConnection *)(x))
+#define GIOP_CONNECTION_GET_FD(x) (GIOP_CONNECTION((x))->fd)
+
+typedef enum { IIOP_IPV4, IIOP_IPV6, IIOP_USOCK } IIOPConnectionType;
+
+typedef struct {
+  GIOPConnection giop_connection;
+
+  gboolean is_serversock;
+  IIOPConnectionType icnxtype;
+  union {
+    struct {
+      char *hostname;
+      struct sockaddr_in location;
+    } ipv4;
+    struct sockaddr_un usock;
+    /* Yes this is a config.h define, and no it doesn't matter,
+       because this structure should only be used internally anyways */
+#ifdef HAVE_IPV6
+    struct {
+      char *hostname;
+      struct sockaddr_in6 location;
+    } ipv6;
+#endif
+  } u;
+} IIOPConnection;
+
+#define IIOP_CONNECTION(x) ((IIOPConnection *)(x))
+
+#if defined(DEBUG_sopwith_connection_refcounting)
+#define giop_connection_ref(x) G_STMT_START{ (GIOP_CONNECTION(x)->refcount++); g_print("!   reffing fd %d in " __PRETTY_FUNCTION__ ":%d to %d\n", GIOP_CONNECTION_GET_FD(x), __LINE__, GIOP_CONNECTION(x)->refcount); }G_STMT_END
+
+#define giop_connection_unref(x) G_STMT_START{ GIOP_CONNECTION(x)->refcount--; g_print("!   dereffing fd %d in " __PRETTY_FUNCTION__ ":%d to %d\n", GIOP_CONNECTION_GET_FD(x), __LINE__, GIOP_CONNECTION(x)->refcount); if(GIOP_CONNECTION(x)->refcount <= 0) giop_connection_free(x); }G_STMT_END
+#else
+#define giop_connection_ref(x) G_STMT_START{ (GIOP_CONNECTION(x)->refcount++); }G_STMT_END
+
+#define giop_connection_unref(x) G_STMT_START{ GIOP_CONNECTION(x)->refcount--; if(GIOP_CONNECTION(x)->refcount <= 0) giop_connection_free(x); }G_STMT_END
+#endif
+
+#endif /* IIOP_TYPES_H */
diff -urN linux-2.4.1/net/korbit/IIOP/IIOP.h linux-2.4.1-korbit/net/korbit/IIOP/IIOP.h
--- linux-2.4.1/net/korbit/IIOP/IIOP.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/IIOP.h	Thu Feb  1 16:19:47 2001
@@ -0,0 +1,52 @@
+#ifndef IIOP_H
+#define IIOP_H 1
+
+#include <unistd.h>
+#include <ORBitutil/util.h>
+#include "IIOP-config.h"
+#include "IIOP-types.h"
+#include "giop-msg-buffer.h"
+#include "iiop-encoders.h"
+#include "iiop-endian.h"
+
+/* We don't speak GIOP 1.0, sosumi */
+#define GIOP_1_1
+
+
+void giop_init(const char *argv0);
+
+/* You use this to get a pointer to a new (or existing) connection
+   that has the specified host/port characteristics */
+IIOPConnection *iiop_connection_get(const char *host, gushort port,
+				    gboolean existing_only);
+/* Similar, but for UNIX sockets */
+IIOPConnection *iiop_connection_unix_get(const char *sockpath,
+					 gboolean existing_only);
+
+/* gives us a local socket that other people can connect to... */
+IIOPConnection *iiop_connection_server(void);
+IIOPConnection *iiop_connection_server_ipv6(void);
+IIOPConnection *iiop_connection_server_unix(const char *sockpath);
+
+void giop_main_quit(void);
+void giop_main(void); /* main loop for the program if none other is given,
+			 and also used while waiting for a reply */
+void giop_main_iterate(gboolean blocking);
+void giop_main_handle_connection(GIOPConnection *connection);
+void giop_main_handle_connection_exception(GIOPConnection *connection);
+GIOPRecvBuffer *giop_main_next_message(gboolean blocking);
+GIOPRecvBuffer *giop_main_next_message_2(gboolean blocking,
+					 GIOPConnection *monitor);
+GIOPConnection *giop_check_connections(gboolean block_for_reply);
+
+/* This assumes that the appropriate GIOP_CLOSECONNECTION message
+   has been sent to the peer */
+void giop_connection_free(GIOPConnection *connection);
+
+/* Called when a connection is created */
+extern void (*IIOPAddConnectionHandler)(GIOPConnection *newcnx);
+/* Called when a connection is about to be destroyed */
+extern void (*IIOPRemoveConnectionHandler)(GIOPConnection *oldcnx);
+extern void (*IIOPIncomingMessageHandler)(GIOPRecvBuffer *recv_buffer);
+
+#endif /* IIOP_H */
diff -urN linux-2.4.1/net/korbit/IIOP/Makefile linux-2.4.1-korbit/net/korbit/IIOP/Makefile
--- linux-2.4.1/net/korbit/IIOP/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/Makefile	Thu Feb  1 11:46:51 2001
@@ -0,0 +1,18 @@
+#
+# Makefile for KORBit/IIOP
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .o file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := IIOPlib.o
+
+#obj-m := $(O_TARGET)
+obj-y := connection.o encoders.o giop-msg-buffer.o iiop-endian.o
+
+
+EXTRA_CFLAGS = -D__KORBIT__ -DHAVE_CONFIG_H -I. -I.. -I../include -I../kglib -I../ORBitutil -nostdinc
+
+include $(TOPDIR)/Rules.make
diff -urN linux-2.4.1/net/korbit/IIOP/connection.c linux-2.4.1-korbit/net/korbit/IIOP/connection.c
--- linux-2.4.1/net/korbit/IIOP/connection.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/connection.c	Thu Feb  1 19:26:07 2001
@@ -0,0 +1,1565 @@
+#include "config.h"
+
+#if defined(HAVE_POLL) && defined(I_WANT_POLL)
+#define USE_POLL
+#else
+#undef USE_POLL
+#endif
+
+#ifndef _XOPEN_SOURCE_EXTENDED
+#   define _XOPEN_SOURCE_EXTENDED 1
+#   define WE_DEFINED_XOPEN_SOURCE_EXTENDED 1
+#endif
+#include "iiop-endianP.h"
+#ifdef WE_DEFINED_XOPEN_SOURCE_EXTENDED
+#   undef _XOPEN_SOURCE_EXTENDED
+#endif
+#include "IIOP.h"
+#include "IIOP-private.h"
+#include "giop-msg-buffer.h"
+#include <stdlib.h>
+#include <unistd.h>
+#ifdef ORBIT_DEBUG
+#include <errno.h>
+#endif
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#ifndef _XOPEN_SOURCE_EXTENDED
+#   define _XOPEN_SOURCE_EXTENDED 1
+#endif
+#include <arpa/inet.h>
+#include <netdb.h>
+#ifdef WE_DEFINED_XOPEN_SOURCE_EXTENDED
+#   undef _XOPEN_SOURCE_EXTENDED
+#endif
+#include <ctype.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <signal.h>
+#include <syslog.h>
+#include <stdio.h>
+
+/*
+#ifdef O_NONBLOCK
+#undef O_NONBLOCK
+#endif
+#define O_NONBLOCK 0
+*/
+
+#if defined(HAVE_TCPD_H) && defined(HAVE_HOSTS_ACCESS)
+#include <tcpd.h>
+#endif
+
+#if 0
+#include <malloc.h>
+
+static struct mallinfo mi1, mi2;
+
+#define AM() mi1 = mallinfo();
+#define PM(x) mi2 = mallinfo(); printf(x ": used %d, now %d\n", \
+mi2.uordblks - mi1.uordblks, mi2.uordblks);
+#endif
+
+#ifdef HAVE_POLL
+#include <sys/poll.h>
+#endif
+
+#ifndef SUN_LEN
+/* This system is not POSIX.1g.  */
+#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path)  \
+                      + strlen ((ptr)->sun_path))
+#endif
+
+void (*IIOPAddConnectionHandler)(GIOPConnection *newcnx) = NULL;
+void (*IIOPRemoveConnectionHandler)(GIOPConnection *oldcnx) = NULL;
+void (*IIOPIncomingMessageHandler)(GIOPRecvBuffer *recv_buffer) = NULL;
+
+static void giop_connection_add_to_list         (GIOPConnection *cnx);
+static void giop_connection_remove_from_list    (GIOPConnection *cnx);
+
+static void iiop_init                           (void);
+static void iiop_connection_server_accept       (GIOPConnection *connection);
+static void iiop_connection_destroy   		(IIOPConnection *connection);
+static IIOPConnection *iiop_connection_new      (const char *host, gushort port);
+static IIOPConnection *iiop_connection_unix_new (const char *sockpath);
+static void iiop_unlink_unix_sockets            (void);
+
+DEFINE_LOCK(giop_connection_list);
+GIOPConnectionList giop_connection_list;
+static GSList *iiop_unix_socket_list = NULL;
+
+#if defined(HAVE_HOSTS_ACCESS) && defined (HAVE_TCPD_H)
+static const char *argv0_val = NULL;
+#endif
+
+struct fd_hash_elem
+{
+        guint fd;
+        GIOPConnection *cnx;
+};
+
+static guint fd_hash_func(gconstpointer key)
+{
+        const guint *key_ptr = (guint *)key;
+        guint result = *key_ptr >> 2;
+        return result;
+}
+
+static gint fd_compare_func(gconstpointer a, gconstpointer b)
+{
+        const guint *a_ptr = (guint *)a;
+        const guint *b_ptr = (guint *)b;
+        return *a_ptr == *b_ptr;
+}
+
+static gboolean fd_hash_clear(gpointer key, gpointer value, gpointer user_data)
+{
+        struct fd_hash_elem *el = (struct fd_hash_elem *)value;
+        g_free(el);
+        return TRUE;
+}
+
+/*
+ * giop_init
+ *
+ *    Inputs: None
+ *    Outputs: None
+ *
+ *    Side effects: Initializes giop_connection_list
+ *    Global data structures used: giop_connection_list
+ *
+ *    Description: Initializes giop_connection_list. Calls
+ *                 giop_message_buffer_init() to initialize the
+ *                 message_buffer subsystem. Calls iiop_init()
+ *		   to perform IIOP-specific initialization.
+ */
+
+void giop_init(const char *argv0)
+{
+#ifndef __KERNEL__
+  struct sigaction mypipe;
+#endif
+  g_assert(sizeof(GIOPMessageHeader) == 12);
+
+#if defined(HAVE_HOSTS_ACCESS) && defined (HAVE_TCPD_H)
+  argv0_val = g_strdup(g_basename(argv0)); /* For TCP wrappers */
+#endif
+
+#ifndef __KERNEL__
+  memset(&mypipe, '\0', sizeof(mypipe));
+  mypipe.sa_handler = SIG_IGN;
+
+  sigaction(SIGPIPE, &mypipe, NULL);
+#endif
+
+  giop_message_buffer_init();
+
+  INIT_LOCK(giop_connection_list);
+
+  giop_connection_list.list = NULL;
+  giop_connection_list.connection_list_changed = FALSE;
+
+#ifdef USE_POLL
+  giop_connection_list.pollset = g_array_new(FALSE, FALSE,
+					     sizeof(struct pollfd));
+#else
+  FD_ZERO(&giop_connection_list.selectset_rd);
+  FD_ZERO(&giop_connection_list.selectset_ex);
+#endif
+
+#ifndef __KORBIT__
+  giop_connection_list.fd_to_connection_mapping = g_ptr_array_new();
+#else
+  giop_connection_list.fd_to_connection_mapping = 
+          g_hash_table_new(&fd_hash_func,
+                           &fd_compare_func);
+#endif
+
+  /*
+   * This also needs to do any transport-specific initialization
+   * as appropriate
+   */
+  iiop_init();
+}
+
+/*** giop_connection_init
+ *
+ *   Inputs: 'giop_connection' - memory region allocated for use as a
+ *                               GIOPConnection.
+ *           'cnxclass'        - the class of connection that will be stored
+ *                               here (SERVER, CLIENT)
+ *
+ *   Outputs: None
+ *
+ *   Side effects: Initializes 'giop_connection'.
+ *
+ *   Description: Basic setup of a GIOPConnection.
+ *                Sets is_valid to FALSE because it is the responsibility of
+ *	          the transport-specific initialization routine to make
+ *	          a connection valid.
+ */
+
+static void giop_connection_init(GIOPConnection *giop_connection,
+				 GIOPConnectionClass cnxclass)
+{
+  giop_connection->connection_type = GIOP_CONNECTION_NONE;
+  giop_connection->refcount = 0;
+  giop_connection->connection_class = cnxclass;
+  giop_connection->is_valid = FALSE;
+  giop_connection->is_auth = FALSE;
+  giop_connection->was_initiated = FALSE;
+}
+
+/*
+ * giop_connection_free
+ *    Inputs: 'connection'
+ *    Outputs: None
+ *    Side effects: Makes the 'connection' invalid as a GIOPConnection
+ *                  and as a gpointer.
+ *
+ *    Description: Calls giop_connection_remove_from_list() to
+ *                 stop the connection from being used for incoming.
+ *
+ *	           If a transport-specific finalization function has
+ *	           been provided, call it.
+ *	           
+ *	           Free the memory block at '*connection'.
+ *
+ */
+void giop_connection_free(GIOPConnection *connection)
+{
+  g_return_if_fail(connection != NULL);
+  giop_connection_remove_from_list(connection);
+
+  if(connection->is_valid && connection->destroy_func)
+    connection->destroy_func(connection);
+
+  connection->is_valid = FALSE;
+
+  if(connection->incoming_msg) {
+    GIOPRecvBuffer *buf;
+
+    buf = connection->incoming_msg;
+    connection->incoming_msg = NULL;
+    giop_recv_buffer_unuse(buf);
+  }
+
+  g_free(connection);
+}
+
+/*
+ * giop_connection_list_recreate
+ *
+ *    Inputs: None
+ *    Outputs: None
+ *
+ *    Side effects: giop_connection_list changes.
+ *
+ *    Global data structures used: giop_connection_list
+ *
+ *    Description:
+ *         When new connections are added to giop_connection_list.list,
+ *     	   the data structures passed to poll() or select() (OS-dependant)
+ *     	   must be recreated to match this list.
+ *     	   
+ *     	   [We do this at add-connection/remove-connection time
+ *     	    instead of every time a poll/select is done in order to
+ *     	    speed things up a little]
+ *     	   
+ *     	   This function reinitializes the OS-specific file
+ *     	   descriptor data structure and then adds all the file
+ *     	   descriptors in the list to it.
+ *     	  
+ *     	   It also regenerates the array that maps file descriptors
+ *     	   into GIOPConnection*'s
+ *
+ */
+static void
+giop_connection_list_recreate(void)
+{
+  int curfd;
+  GList *item;
+  GIOPConnection *cnx;
+#ifdef USE_POLL
+  struct pollfd new_poll;
+
+  new_poll.revents = 0;
+#endif
+
+  giop_connection_list.max_fd = 0;
+  for(item = giop_connection_list.list; item; item = g_list_next(item))
+    {
+      cnx = item->data;
+      curfd = GIOP_CONNECTION_GET_FD(cnx);
+
+      if(curfd > giop_connection_list.max_fd)
+	giop_connection_list.max_fd = curfd;
+  }
+
+#ifndef __KORBIT__
+  g_ptr_array_set_size(giop_connection_list.fd_to_connection_mapping,
+		       giop_connection_list.max_fd + 1);
+#else
+  g_hash_table_foreach_remove(giop_connection_list.fd_to_connection_mapping,
+                              fd_hash_clear,
+                              NULL);
+#endif
+
+#ifdef USE_POLL
+  g_array_set_size(giop_connection_list.pollset, 0);
+#else
+  FD_ZERO(&giop_connection_list.selectset_rd);
+  FD_ZERO(&giop_connection_list.selectset_ex);
+#endif
+
+  for(item = giop_connection_list.list; item; item = g_list_next(item))
+    {
+            struct fd_hash_elem *el;
+            
+      cnx = item->data;
+      curfd = GIOP_CONNECTION_GET_FD(cnx);
+
+#ifndef __KORBIT__
+      giop_connection_list.fd_to_connection_mapping->pdata[curfd] = cnx;
+#else
+      el = g_new(struct fd_hash_elem, 1);
+      el->fd = curfd;
+      el->cnx = cnx;
+      g_hash_table_insert(giop_connection_list.fd_to_connection_mapping,
+                          &(el->fd),
+                          el);
+#endif
+
+#     ifdef USE_POLL
+      new_poll.fd = curfd;
+      new_poll.events = POLLIN|POLLPRI;
+      g_array_append_val(giop_connection_list.pollset, 
+			 new_poll);
+#     else
+      FD_SET(curfd, &giop_connection_list.selectset_rd);
+      FD_SET(curfd, &giop_connection_list.selectset_ex);
+#     endif
+  }
+}
+
+/*
+ * giop_connection_add_to_list
+ *
+ *    Inputs: 'cnx' - a GIOPConnection that the user wishes added to the list
+ *    Outputs: None
+ *
+ *    Side effects: Modifies giop_connection_list
+ *    Global data structures used: giop_connection_list
+ *    Bugs: Does not check for duplicate additions.
+ *
+ *    Description:
+ *         Adds a connection to the list of active connections.
+ */
+static void
+giop_connection_add_to_list(GIOPConnection *cnx)
+{
+  g_return_if_fail(cnx->is_valid == FALSE);
+
+  cnx->is_valid = TRUE;
+
+  GET_LOCK(giop_connection_list);
+  giop_connection_list.list = g_list_prepend(giop_connection_list.list, cnx);
+
+  giop_connection_list_recreate();
+
+  RELEASE_LOCK(giop_connection_list);
+
+  if(IIOPAddConnectionHandler)
+    IIOPAddConnectionHandler(cnx);
+
+  giop_connection_ref(cnx);
+}
+
+/*
+ * giop_connection_remove_from_list
+ *
+ *    Inputs: 'cnx' - a GIOPConnection that the user wishes
+ *    Outputs: None
+ *
+ *    Side effects: Modifies giop_connection_list
+ *    Global data structures used: giop_connection_list
+ *
+ *    Description:
+ *         Removes a connection from the list of active connections.
+ *         Calls the library user's "I removed connection" handler if it
+ *         exists.
+ *
+ *    Bugs: Does not check for duplicate removals. This may not be "bad" though.
+ */
+void
+giop_connection_remove_from_list(GIOPConnection *cnx)
+{
+  GList *link;
+
+  GET_LOCK(giop_connection_list);
+
+  link = g_list_find(giop_connection_list.list, cnx);
+
+  if(!link)
+    goto out;
+
+  if(IIOPRemoveConnectionHandler && cnx->is_valid)
+    IIOPRemoveConnectionHandler(cnx);
+
+  giop_connection_list.list = g_list_remove_link(giop_connection_list.list,
+						 link);
+  g_list_free_1(link);
+
+  giop_connection_unref(cnx);
+
+  giop_connection_list_recreate();
+ out:
+  RELEASE_LOCK(giop_connection_list);
+}
+
+/************************************************
+ * Routines specific to the IIOP/IPv4 transport *
+ ************************************************/
+
+/*
+ * iiop_init
+ *
+ *    Inputs: None
+ *    Outputs: None
+ *
+ *    Side effects: Initializes iiop_unix_socket_list
+ *    Global data structures used: iiop_unix_socket_list
+ *
+ *    Description: Initializes iiop_unix_socket_list.
+ *                 Registers Unix domain sockets for
+ *                 removal at server termination.
+ */
+static void
+iiop_init(void)
+{
+#ifndef __KERNEL__
+  g_atexit(iiop_unlink_unix_sockets);
+#endif
+}
+
+/*
+ * iiop_connection_init
+ *
+ *    Inputs: 'connection' - a memory region that needs to be initialized as
+ *                           an 'IIOPConnection'.
+ *
+ *    Side effects: initializes 'connection'
+ *
+ *    Description: Performs the IIOP-specific initialization of an
+ *                 IIOPConnection. giop_connection_init is called.
+ *
+ */
+void
+iiop_connection_init(IIOPConnection *connection,
+		     GIOPConnectionClass cnxclass,
+		     IIOPConnectionType iioptype)
+{
+  giop_connection_init(GIOP_CONNECTION(connection), cnxclass);
+
+  GIOP_CONNECTION(connection)->connection_type =
+    GIOP_CONNECTION_IIOP;
+
+  GIOP_CONNECTION(connection)->destroy_func =
+    (void (*)(GIOPConnection *))iiop_connection_destroy;
+
+  connection->icnxtype = iioptype;
+}
+
+/*
+ * iiop_connection_from_fd
+ *
+ *    Inputs: 'fd' - a file descriptor that attention should be paid to
+ *    Outputs: 'fd_cnx' - the created connection 
+ *
+ *    Description: This is intended to be used on a file descriptor
+ *	           that has been accept()'d. It creates the connection
+ *	           and fills in the connection information, then adds
+ *	           it to the active list.
+ */
+IIOPConnection *
+iiop_connection_from_fd(int fd, IIOPConnection *parent)
+{
+  IIOPConnection *fd_cnx;
+  struct hostent *hent;
+  socklen_t n;
+
+  g_assert(fd >= 0);
+
+  fd_cnx = g_new0(IIOPConnection, 1);
+
+  iiop_connection_init(fd_cnx, GIOP_CONNECTION_CLIENT, parent->icnxtype);
+
+  GIOP_CONNECTION(fd_cnx)->fd = fd;
+
+  switch(parent->icnxtype) {
+  case IIOP_IPV4:
+    n = sizeof(struct sockaddr_in);
+    if(getpeername(GIOP_CONNECTION_GET_FD(fd_cnx), (struct sockaddr *)&fd_cnx->u.ipv4.location, &n))
+      {
+	fd_cnx->u.ipv4.hostname = g_strdup("");
+      }
+    else
+      {
+	hent = gethostbyaddr((const char *)&fd_cnx->u.ipv4.location.sin_addr.s_addr, 4, AF_INET);
+	if(hent)
+	  {
+	    fd_cnx->u.ipv4.hostname = g_strdup(hent->h_name);
+	  }
+	else
+	  {
+	    fd_cnx->u.ipv4.hostname = inet_ntoa(*((struct in_addr *)&fd_cnx->u.ipv4.location.sin_addr));
+	  }
+      }
+    break;
+
+  case IIOP_USOCK:
+    n = sizeof(struct sockaddr_un);
+    fd_cnx->u.usock.sun_family = AF_UNIX;
+    getpeername(GIOP_CONNECTION_GET_FD(fd_cnx),
+	(struct sockaddr *)&fd_cnx->u.usock, &n);
+    break;
+
+#ifdef HAVE_IPV6
+  case IIOP_IPV6:
+    n = sizeof(struct sockaddr_in6);
+    getpeername(GIOP_CONNECTION_GET_FD(fd_cnx),
+	(struct sockaddr *)&fd_cnx->u.ipv6.location, &n);
+    hent = gethostbyaddr((const char *)&fd_cnx->u.ipv6.location.sin6_addr, 
+			 sizeof(fd_cnx->u.ipv6.location.sin6_addr), AF_INET6);
+    fd_cnx->u.ipv6.hostname = g_strdup(hent->h_name);
+    break;
+#endif
+
+  default:
+    g_error("Unsupported connection type %d", parent->icnxtype);
+  }
+
+  fcntl(GIOP_CONNECTION_GET_FD(fd_cnx), F_SETFD,
+	fcntl(GIOP_CONNECTION_GET_FD(fd_cnx), F_GETFD, 0)
+	| FD_CLOEXEC);
+  fcntl(GIOP_CONNECTION_GET_FD(fd_cnx), F_SETFL,
+	fcntl(GIOP_CONNECTION_GET_FD(fd_cnx), F_GETFL, 0)
+	| O_NONBLOCK);
+
+  ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug,
+	      "iiop_connection_from_fd connect [%d]\n",
+	      GIOP_CONNECTION_GET_FD(fd_cnx));
+
+  giop_connection_add_to_list(GIOP_CONNECTION(fd_cnx));
+
+  return fd_cnx;
+}
+
+/*
+ * iiop_connection_server
+ *
+ *   Outputs: 'server_cnx'
+ *
+ *    Description: Creates a special IIOPConnection on which incoming
+ *                 connections come.
+ */
+IIOPConnection *
+iiop_connection_server(void)
+{
+  struct hostent *hent;
+  char hn_tmp[65];
+  socklen_t n;
+  IIOPConnection *server_cnx = g_new0(IIOPConnection, 1);
+
+  iiop_connection_init(server_cnx, GIOP_CONNECTION_SERVER, IIOP_IPV4);
+
+  server_cnx->is_serversock = TRUE;
+  GIOP_CONNECTION(server_cnx)->fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+
+  if(GIOP_CONNECTION_GET_FD(server_cnx) < 0) {
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_server: socket_error: %s\n", strerror(errno));
+    goto failed;
+  }
+
+  server_cnx->u.ipv4.location.sin_family = AF_INET;
+  server_cnx->u.ipv4.location.sin_addr.s_addr = INADDR_ANY;
+  bind(GIOP_CONNECTION_GET_FD(server_cnx),
+       (struct sockaddr *)&server_cnx->u.ipv4.location,
+       sizeof(struct sockaddr_in));
+
+  fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_SETFD,
+	fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_GETFD, 0)
+	| FD_CLOEXEC);
+  fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_SETFL,
+	fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_GETFL, 0)
+	| O_NONBLOCK);
+
+  n = sizeof(struct sockaddr_in);
+  getsockname(GIOP_CONNECTION_GET_FD(server_cnx),
+	      (struct sockaddr *)&server_cnx->u.ipv4.location, &n);
+
+  gethostname(hn_tmp, sizeof(hn_tmp) - 1);
+
+  hent = gethostbyname(hn_tmp);
+  if(hent) 
+    {
+      if (strchr (hent->h_name, '.'))
+	server_cnx->u.ipv4.hostname = g_strdup(hent->h_name);
+      else
+	{
+	  struct in_addr * addr = (struct in_addr *) hent->h_addr_list[0];
+	  g_assert (hent->h_length == sizeof (struct in_addr) && addr);
+	  server_cnx->u.ipv4.hostname = g_strdup (inet_ntoa (*addr));
+	}
+    }
+  else
+    server_cnx->u.ipv4.hostname = g_strdup(hn_tmp);
+
+  listen(GIOP_CONNECTION_GET_FD(server_cnx), 5);
+
+  giop_connection_add_to_list(GIOP_CONNECTION(server_cnx));
+
+  return server_cnx;
+
+failed:
+  close(GIOP_CONNECTION_GET_FD(server_cnx));
+  GIOP_CONNECTION(server_cnx)->fd = -1;
+  giop_connection_free(GIOP_CONNECTION(server_cnx));
+  server_cnx = NULL;
+  /*
+   * FIXME: GET_LOCK and DEFINE_LOCK never called for server_cnx
+  RELEASE_LOCK(server_cnx);
+   */
+  return NULL;
+}
+
+/*
+ * iiop_connection_server_ipv6
+ *   Outputs: 'server_cnx'
+ *
+ *    Description: Create a special IIOPConnection on which incoming
+ *                 connections come.
+ */
+IIOPConnection *
+iiop_connection_server_ipv6(void)
+{
+#ifdef HAVE_IPV6
+  struct hostent *hent, *hent2;
+
+  char hn_tmp[65];
+  int n;
+  IIOPConnection *server_cnx;
+
+  g_error("IPv6 support is baroquen! (Actually just never worked)");
+
+  server_cnx = g_new0(IIOPConnection, 1);
+  
+  iiop_connection_init(server_cnx, GIOP_CONNECTION_SERVER, IIOP_IPV6);
+  
+  server_cnx->is_serversock = TRUE;
+  GIOP_CONNECTION(server_cnx)->fd = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
+
+  if(GIOP_CONNECTION_GET_FD(server_cnx) < 0) {
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_server_ipv6: socket_error: %s\n", strerror(errno));
+    goto failed;
+  }
+
+  server_cnx->u.ipv6.location.sin6_family = AF_INET6;
+  bind(GIOP_CONNECTION_GET_FD(server_cnx),
+       (struct sockaddr *)&server_cnx->u.ipv6.location,
+       sizeof(struct sockaddr_in6));
+  
+  fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_SETFD,
+	fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_GETFD, 0)
+	| FD_CLOEXEC);
+  fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_SETFL,
+	fcntl(GIOP_CONNECTION_GET_FD(server_cnx), F_GETFL, 0)
+	| O_NONBLOCK);
+
+  n = sizeof(struct sockaddr_in6);
+  getsockname(GIOP_CONNECTION_GET_FD(server_cnx), &server_cnx->u.ipv6.location, &n);
+
+  gethostname(hn_tmp, sizeof(hn_tmp) - 1);
+
+  hent = gethostbyname(hn_tmp);
+  if(hent) {
+    hent2 = gethostbyaddr(hent->h_addr, sizeof(server_cnx->u.ipv6.location.sin6_addr), AF_INET6);
+    if(hent2)
+      server_cnx->hostname = g_strdup(hent2->h_name);
+    else
+      server_cnx->hostname = g_strdup(hn_tmp);
+  } else
+    server_cnx->hostname = g_strdup(hn_tmp);
+
+  listen(GIOP_CONNECTION_GET_FD(server_cnx), 5);
+
+  giop_connection_add_to_list(GIOP_CONNECTION(server_cnx));
+
+  return server_cnx;
+
+failed:
+  close(GIOP_CONNECTION_GET_FD(server_cnx));
+  GIOP_CONNECTION(server_cnx)->fd = -1;
+  giop_connection_free(GIOP_CONNECTION(server_cnx));
+  server_cnx = NULL;
+  /*
+   * FIXME: GET_LOCK and DEFINE_LOCK never called for server_cnx
+  RELEASE_LOCK(server_cnx);
+   */
+#endif
+  return NULL;
+}
+
+/*
+ * iiop_connection_server_unix
+ *
+ *   Outputs: 'server_cnx_unix'
+ *
+ *    Side effects: Initializes 'server_cnx_unix' if not initialized.
+ *
+ *    Description: Return a special IIOPConnection on which incoming connections
+ *                 come. If not already initialized, it creates the connection,
+ *	           otherwise it returns the existing one.
+ *	           This is
+ */
+IIOPConnection *
+iiop_connection_server_unix(const char *sockpath)
+{
+  IIOPConnection *server_cnx_unix;
+
+  g_assert(sockpath && *sockpath);
+
+  server_cnx_unix = g_new0(IIOPConnection, 1);
+
+  iiop_connection_init(server_cnx_unix, GIOP_CONNECTION_SERVER, IIOP_USOCK);
+
+  server_cnx_unix->is_serversock = TRUE;
+  GIOP_CONNECTION(server_cnx_unix)->fd = socket(AF_UNIX, SOCK_STREAM, 0);
+
+  if(GIOP_CONNECTION_GET_FD(server_cnx_unix) < 0) {
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_server_unix: socket_error: %s\n", strerror(errno));
+    goto failed;
+  }
+
+  strcpy(server_cnx_unix->u.usock.sun_path, sockpath);
+
+  server_cnx_unix->u.usock.sun_family = AF_UNIX;
+  if(bind(GIOP_CONNECTION_GET_FD(server_cnx_unix),
+	  (struct sockaddr *)&server_cnx_unix->u.usock,
+	  SUN_LEN(&server_cnx_unix->u.usock)) != 0) {
+    /* see the comment in iiop_connection_destroy switch as to why we
+       close it here. bad hack */
+    close(GIOP_CONNECTION_GET_FD(server_cnx_unix));
+    GIOP_CONNECTION(server_cnx_unix)->fd = -1;
+    goto failed;
+  }
+
+  fcntl(GIOP_CONNECTION_GET_FD(server_cnx_unix), F_SETFD,
+	fcntl(GIOP_CONNECTION_GET_FD(server_cnx_unix), F_GETFD, 0)
+	| FD_CLOEXEC);
+  fcntl(GIOP_CONNECTION_GET_FD(server_cnx_unix), F_SETFL,
+	fcntl(GIOP_CONNECTION_GET_FD(server_cnx_unix), F_GETFL, 0)
+	| O_NONBLOCK);
+
+  if(listen(GIOP_CONNECTION_GET_FD(server_cnx_unix), 5) != 0)
+    goto failed;
+
+  giop_connection_add_to_list(GIOP_CONNECTION(server_cnx_unix));
+  iiop_unix_socket_list = g_slist_prepend(iiop_unix_socket_list,
+					  server_cnx_unix);
+
+  /*
+   * FIXME: GET_LOCK and DEFINE_LOCK never called for server_cnx_unix
+  RELEASE_LOCK(server_cnx_unix);
+   */
+
+  return server_cnx_unix;
+
+failed:
+  close(GIOP_CONNECTION_GET_FD(server_cnx_unix));
+  GIOP_CONNECTION(server_cnx_unix)->fd = -1;
+  giop_connection_free(GIOP_CONNECTION(server_cnx_unix));
+  server_cnx_unix = NULL;
+  /*
+   * FIXME: GET_LOCK and DEFINE_LOCK never called for server_cnx_unix
+  RELEASE_LOCK(server_cnx_unix);
+   */
+  return NULL;
+}
+
+/*
+ * iiop_unlink_unix_sockets(void)
+ *
+ *    Inputs: None
+ *    Outputs: None
+ *
+ *    Side effects: Modifies iiop_unix_socket_list
+ *    Global data structures used: iiop_unix_socket_list
+ *
+ *    Description:
+ *         Unlinks any Unix server sockets created.
+ *         Called during program termination.
+ */
+static void
+iiop_unlink_unix_sockets(void)
+{
+  GSList *item;
+
+  for (item = iiop_unix_socket_list;
+       item; item = g_slist_next(item)) {
+    GIOPConnection *cnx;
+
+    cnx = GIOP_CONNECTION(item->data);
+    if(cnx->connection_class == GIOP_CONNECTION_SERVER)
+      unlink(IIOP_CONNECTION(cnx)->u.usock.sun_path);
+  }
+
+  if (iiop_unix_socket_list) {
+    g_slist_free(iiop_unix_socket_list);
+    iiop_unix_socket_list = NULL;
+  }
+}
+
+/*
+ * iiop_connection_get
+ *
+ * Inputs: 'host' - the hostname (or dotted quad) of the remote host that
+ *                  will be connected
+ *         'port' - the port number on the above host to connect to.
+ *         'existing_only' - don't create a new connection if
+ *                           an existing one with the specified host:port
+ *                           doesn't exist.
+ *
+ * Outputs: 'cnx' - the connection to the specified host:port, or
+ *                  NULL upon error.
+ *
+ * Description: Returns an IIOPConnection that is connected to the
+ *              specified host:port. If a connection already exists to the
+ *	 	host:port, just returns it. Otherwise, calls
+ *	 	'iiop_connection_new' to create a new connection
+ *	 	to host:port.
+ */
+IIOPConnection *
+iiop_connection_get(const char *host, gushort port, gboolean existing_only)
+{
+  IIOPConnection *cnx = NULL, *tmp;
+  GList *link;
+
+  g_assert(host);
+  g_assert(port);
+
+  GET_LOCK(giop_connection_list);
+  for(link = giop_connection_list.list; link; link = link->next)
+    {
+      tmp = IIOP_CONNECTION(link->data);
+      if(GIOP_CONNECTION(tmp)->connection_type != GIOP_CONNECTION_IIOP)
+	continue;
+
+      if(!GIOP_CONNECTION(tmp)->is_valid)
+	continue;
+
+      if(GIOP_CONNECTION(tmp)->connection_class != GIOP_CONNECTION_CLIENT)
+	continue;
+
+      if(IIOP_CONNECTION(tmp)->icnxtype != IIOP_IPV4)
+	continue;
+
+      if(!strcmp(host, tmp->u.ipv4.hostname)
+	 && htons(port) == tmp->u.ipv4.location.sin_port) {
+	cnx = tmp;
+	break;
+      }
+    }
+  RELEASE_LOCK(giop_connection_list);
+
+  if(!cnx && !existing_only)
+    cnx = iiop_connection_new(host, port);
+
+  return cnx;
+}
+
+
+/*
+ * iiop_connection_new
+ *
+ * Inputs: same meanings as in 'iiop_connection_get'
+ * Outputs: 'retval' - newly created IIOPConnection
+ *
+ * Description: Allocates and initializes a new IIOPConnection,
+ *              turns 'host' into an IP address, and then makes a TCP
+ *              connection to host:port. Adds it to the list of active
+ *              connections.
+ */
+IIOPConnection *
+iiop_connection_new(const char *host, gushort port)
+{
+  IIOPConnection *retval;
+
+  g_return_val_if_fail(host != NULL && port != 0, NULL);
+
+  retval = g_new0(IIOPConnection, 1);
+
+  iiop_connection_init(retval, GIOP_CONNECTION_CLIENT, IIOP_IPV4);
+
+  GIOP_CONNECTION(retval)->fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if(GIOP_CONNECTION_GET_FD(retval) < 0) {
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_new: socket_error: %s\n", strerror(errno));
+    goto failed;
+  }
+
+  retval->u.ipv4.hostname = g_strdup(host);
+
+  retval->u.ipv4.location.sin_port = htons(port);
+  retval->u.ipv4.location.sin_family = AF_INET;
+  if(!inet_aton(host, &retval->u.ipv4.location.sin_addr))
+    {
+      struct hostent *hent;
+      hent = gethostbyname(host);
+      if(!hent) {
+	/* a (char *)h_strerror(int) function would be nice here */
+	ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_new: gethostbyname error: %d\n", h_errno);
+	goto failed;
+      }
+      memcpy(&retval->u.ipv4.location.sin_addr, hent->h_addr, (size_t) sizeof(retval->u.ipv4.location.sin_addr));
+    }
+  if(connect(GIOP_CONNECTION_GET_FD(retval), (struct sockaddr *)&retval->u.ipv4.location, sizeof(retval->u.ipv4.location)) < 0) {
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_new: connect error: %s\n", strerror(errno));
+    goto failed;
+  }
+
+  ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug,
+	      "iiop_connection_new connect [%d] to %s:%d\n",
+	      GIOP_CONNECTION_GET_FD(retval),
+	      host, (guint)port);
+
+
+  fcntl(GIOP_CONNECTION_GET_FD(retval), F_SETFD, FD_CLOEXEC);
+  fcntl(GIOP_CONNECTION_GET_FD(retval), F_SETFL,
+	fcntl(GIOP_CONNECTION_GET_FD(retval), F_GETFL, 0)
+	| O_NONBLOCK);
+
+  GIOP_CONNECTION(retval)->was_initiated = TRUE;
+  GIOP_CONNECTION(retval)->is_auth = TRUE;
+
+  giop_connection_add_to_list(GIOP_CONNECTION(retval));
+
+  return retval;
+
+failed:
+  close(GIOP_CONNECTION_GET_FD(retval));
+  GIOP_CONNECTION(retval)->fd = -1;
+  giop_connection_free(GIOP_CONNECTION(retval));
+  return NULL;
+}
+
+/*
+ * iiop_connection_unix_get
+ *
+ *   Inputs: 'sockpath' - Of the format 'path'
+ *
+ *   Outputs: 'cnx' - the connection to the specified path, or
+ *             NULL upon error.
+ *
+ *    Description: Returns an IIOPConnection that is connected to the
+ *                 specified UNIX socket, if possible. If a connection
+ *                 already exists, just returns it. Otherwise,
+ *                 calls 'iiop_connection_unix_new' to create a new
+ *                 connection to sockpath.
+ */
+IIOPConnection *
+iiop_connection_unix_get(const char *sockpath, gboolean existing_only)
+{
+  IIOPConnection *cnx = NULL, *tmp;
+  GList *link;
+
+  GET_LOCK(giop_connection_list);
+  for(link = giop_connection_list.list; link; link = link->next)
+    {
+      tmp = IIOP_CONNECTION(link->data);
+
+      if(GIOP_CONNECTION(tmp)->connection_type != GIOP_CONNECTION_IIOP)
+	continue;
+
+      if(!GIOP_CONNECTION(tmp)->is_valid)
+	continue;
+
+      if(GIOP_CONNECTION(tmp)->connection_class != GIOP_CONNECTION_CLIENT)
+	continue;
+
+      if(IIOP_CONNECTION(tmp)->icnxtype != IIOP_USOCK)
+	continue;
+
+      if(!strcmp(sockpath, tmp->u.usock.sun_path)) {
+	cnx = tmp;
+	break;
+      }
+    }
+  RELEASE_LOCK(giop_connection_list);
+
+  if(!cnx && !existing_only)
+    cnx = iiop_connection_unix_new(sockpath);
+
+  return cnx;
+}
+
+/*
+ * iiop_connection_unix_new
+ *
+ *   Inputs:
+ *
+ *    Outputs: 'retval' - newly created IIOPConnection, or NULL upon error
+ *
+ *    Description: Creates a connection to a UNIX socket (if possible)
+ *                 Adds it to the list of active connections.
+ */
+static IIOPConnection *
+iiop_connection_unix_new(const char *sockpath)
+{
+  IIOPConnection *retval;
+
+  retval = g_new0(IIOPConnection, 1);
+
+  retval->u.usock.sun_family = AF_UNIX;
+
+  g_snprintf(retval->u.usock.sun_path,
+	     sizeof(retval->u.usock.sun_path), "%s", sockpath);
+
+  iiop_connection_init(retval, GIOP_CONNECTION_CLIENT, IIOP_USOCK);
+
+  GIOP_CONNECTION(retval)->fd = socket(AF_UNIX, SOCK_STREAM, 0);
+  if(GIOP_CONNECTION_GET_FD(retval) < 0) {
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_new: socket_error: %s\n", strerror(errno));
+    goto failed;
+  }
+
+  if(connect(GIOP_CONNECTION_GET_FD(retval), (struct sockaddr *)&retval->u.usock, SUN_LEN(&retval->u.usock)) < 0) {
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug, "iiop_connection_new: connect error: %s\n", strerror(errno));
+    goto failed;
+  }
+
+  GIOP_CONNECTION(retval)->was_initiated = TRUE;
+  GIOP_CONNECTION(retval)->is_auth = TRUE;
+
+  fcntl(GIOP_CONNECTION_GET_FD(retval), F_SETFD, FD_CLOEXEC);
+  fcntl(GIOP_CONNECTION_GET_FD(retval), F_SETFL,
+	fcntl(GIOP_CONNECTION_GET_FD(retval), F_GETFL, 0)
+	| O_NONBLOCK);
+
+  giop_connection_add_to_list(GIOP_CONNECTION(retval));
+
+  ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug,
+	      "iiop_connection_unix_new connect [%d] to %s\n",
+	      GIOP_CONNECTION_GET_FD(retval),
+	      sockpath);
+
+  return retval;
+
+failed:
+  close(GIOP_CONNECTION_GET_FD(retval));
+  GIOP_CONNECTION(retval)->fd = -1;
+  giop_connection_free(GIOP_CONNECTION(retval));
+  return NULL;
+}
+
+/*
+ * iiop_connection_server_accept
+ *    Inputs: 'connection' - a server IIOPConnection.
+ *
+ *    Description: Performs accept(), TCP wrapper, access checking and related
+ *                 duties on a connection
+ */
+int allow_severity = LOG_INFO, deny_severity = LOG_NOTICE;
+
+#if defined(HAVE_HOSTS_ACCESS) && defined(HAVE_TCPD_H)
+DEFINE_LOCK(tcp_wrappers_usage);
+
+#endif
+static void
+iiop_connection_server_accept(GIOPConnection *connection)
+{
+  struct sockaddr sock;
+  socklen_t n;
+  int newfd;
+  GIOPConnection *newcnx;
+
+//  printk("iiop_conncetion_server_accept( %d )\n", 
+//         GIOP_CONNECTION_GET_FD(connection));
+
+  n = sizeof(sock);
+
+  switch(IIOP_CONNECTION(connection)->icnxtype) {
+  case IIOP_IPV4: sock.sa_family = AF_INET; break;
+  case IIOP_USOCK: sock.sa_family = AF_UNIX; break;
+  case IIOP_IPV6:
+#ifdef HAVE_IPV6
+    sock.sa_family = AF_INET6;
+#endif
+    break;
+  }
+
+  newfd = accept(GIOP_CONNECTION_GET_FD(connection), &sock, &n);
+
+#if defined(HAVE_HOSTS_ACCESS) && defined(HAVE_TCPD_H)
+  /* tcp wrappers access checking */
+  switch(IIOP_CONNECTION(connection)->icnxtype) {
+  case IIOP_IPV4:
+    {
+      struct request_info request;
+
+      GET_LOCK(tcp_wrappers_usage);
+
+      request_init(&request, RQ_DAEMON, argv0_val, RQ_FILE, newfd, 0);
+
+      fromhost(&request);
+      if(!hosts_access(&request)) {
+	syslog(deny_severity, "[orbit] refused connect from %s", eval_client(&request));
+	close(newfd); newfd = -1;
+      } else
+	syslog(allow_severity, "[orbit] connect from %s", eval_client(&request));
+
+      RELEASE_LOCK(tcp_wrappers_usage);
+    }
+    break;
+  default:
+    /* No access controls for these transports */
+    break;
+  }
+#endif
+
+  if(newfd >= 0) {
+    newcnx = GIOP_CONNECTION(iiop_connection_from_fd(newfd,
+						     IIOP_CONNECTION(connection)));
+    GIOP_CONNECTION(newcnx)->orb_data = connection->orb_data;
+    switch(IIOP_CONNECTION(connection)->icnxtype) {
+    case IIOP_USOCK: newcnx->is_auth = TRUE; break;
+    default:
+      break;
+    }
+  }
+}
+
+/*
+ * iiop_connection_destroy
+ *
+ *    Inputs: 'iiop_connection' - an IIOPConnection to be finalized
+ *
+ *    Side effects: invalidates 'iiop_connection' for use as an IIOPConnection
+ *
+ *    Description: Performs the IIOP-specific parts of connection shutdown,
+ *    including sending a CLOSECONNECTION message to the remote side.
+ */
+static void
+iiop_connection_destroy(IIOPConnection *iiop_connection)
+{
+  const GIOPMessageHeader mh = {"GIOP", {1,0}, FLAG_ENDIANNESS,
+				GIOP_CLOSECONNECTION, 0};
+
+  switch(iiop_connection->icnxtype) {
+  case IIOP_IPV4:
+    ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug,
+		"iiop_connection_destroy connect [%d] of %s:%d\n",
+		GIOP_CONNECTION_GET_FD(iiop_connection),
+		iiop_connection->u.ipv4.hostname,
+		ntohs(iiop_connection->u.ipv4.location.sin_port));
+    g_free(iiop_connection->u.ipv4.hostname);
+    break;
+  case IIOP_IPV6:
+#ifdef HAVE_IPV6
+    g_free(iiop_connection->u.ipv6.hostname);
+#else
+    g_warning("IPv6 unsupported, can't free it!");
+#endif
+    break;
+  case IIOP_USOCK:
+    /* why do we check if fd is > 0 here?
+       the orb code tries to reuse existing socket connection points.
+       If binding to any of those fails because another process is using it,
+       we don't want to unlink the other server's socket!
+       if the bind fails, iiop_connection_server_unix closes the fd for us */
+    if(GIOP_CONNECTION(iiop_connection)->connection_class == GIOP_CONNECTION_SERVER
+       && GIOP_CONNECTION(iiop_connection)->fd >= 0)
+      unlink(iiop_connection->u.usock.sun_path);
+    break;
+  default:
+    break;
+  }
+
+  if(GIOP_CONNECTION_GET_FD(iiop_connection) >= 0) {
+    if(GIOP_CONNECTION(iiop_connection)->is_valid
+       && !GIOP_CONNECTION(iiop_connection)->was_initiated)
+      {
+	write(GIOP_CONNECTION_GET_FD(iiop_connection), &mh, sizeof(mh));
+      }
+
+    shutdown(GIOP_CONNECTION_GET_FD(iiop_connection), 2);
+    close(GIOP_CONNECTION_GET_FD(iiop_connection));
+    GIOP_CONNECTION(iiop_connection)->fd = -1;
+  }
+}
+
+static int giop_nloops = 0;
+
+void giop_main_quit(void) { giop_nloops--; }
+
+void
+giop_main(void)
+{
+  int looplevel;
+
+  looplevel = ++giop_nloops;
+
+  while(giop_nloops > 0) {
+
+    giop_main_iterate(TRUE);
+
+    if(giop_nloops != looplevel) {
+      giop_nloops = --looplevel;
+      return;
+    }
+  }
+}
+
+GIOPRecvBuffer *
+giop_main_next_message(gboolean blocking)
+{
+  return giop_main_next_message_2(blocking, NULL);
+}
+
+GIOPRecvBuffer *
+giop_main_next_message_2(gboolean blocking,
+			 GIOPConnection *monitor)
+{
+    GIOPConnection *connection;
+    GIOPRecvBuffer *recv_buffer = NULL;
+
+    do {
+      recv_buffer = giop_received_list_pop();
+//      printk("giop_main_next_message_2 : recv_buffer = 0x%08X\n", recv_buffer);
+      if(recv_buffer)
+	break;
+
+      connection = giop_check_connections(blocking);
+//      printk("giop_main_next_message_2 : connection = 0x%08X\n", connection);
+      if(!connection) 
+      {
+              return NULL;
+      }
+      
+      if(GIOP_CONNECTION_GET_FD(connection) < 0) {
+	g_assert(!"connection has -ve fd!");
+      }
+
+//      printk("giop_main_next_message_2 : connection class = %d\n", 
+//             connection->connection_class);
+      if(connection->connection_class == GIOP_CONNECTION_SERVER)
+	iiop_connection_server_accept(connection);
+      else
+	recv_buffer = giop_recv_message_buffer_use(connection);
+
+      if(monitor && !monitor->is_valid) 
+      {
+              return NULL;
+      }
+
+    } while(!recv_buffer);
+
+    return recv_buffer;
+}
+
+void
+giop_main_handle_connection(GIOPConnection *connection)
+{
+  GIOPRecvBuffer *recv_buffer;
+
+  //printk("giop_main_handle_connection\n");
+
+  g_return_if_fail(connection != NULL);
+  g_return_if_fail(connection->is_valid);
+
+  if(connection->connection_class == GIOP_CONNECTION_SERVER) {
+    iiop_connection_server_accept(connection);
+    return;
+  } else
+    recv_buffer = giop_recv_message_buffer_use(connection);
+
+  if(recv_buffer) {
+    if(IIOPIncomingMessageHandler)
+      IIOPIncomingMessageHandler(recv_buffer);
+    else
+      giop_received_list_push(recv_buffer);
+  }
+}
+
+/*
+ * giop_main_handle_connection_exception
+ *
+ * Input: GIOPConnection *connection
+ *
+ * Output:
+ *
+ * Side effects: invalidates connection
+ *
+ * Description:
+ *     When poll() or select() indicates that a file descriptor
+ *     has been closed at the remote end, we must invalidate the associated
+ *     GIOPConnection structure.
+ */
+void
+giop_main_handle_connection_exception(GIOPConnection *connection)
+{
+  g_return_if_fail(connection != NULL);
+  g_return_if_fail(connection->is_valid);
+
+//  printk("giop_main_handle_connection_exception(0x%X)\n", GIOP_CONNECTION_GET_FD(connection));
+
+  giop_connection_ref(connection);
+
+  giop_connection_remove_from_list(connection);
+
+  shutdown(GIOP_CONNECTION_GET_FD(connection), 2);
+  close(GIOP_CONNECTION_GET_FD(connection));
+  GIOP_CONNECTION(connection)->fd = -1;
+  connection->is_valid = FALSE;
+
+  if(connection->incoming_msg) {
+    giop_recv_buffer_unuse(connection->incoming_msg);
+    connection->incoming_msg = NULL;
+  }
+
+  giop_connection_unref(connection);
+}
+
+/*
+ * giop_main_iterate
+ *
+ *    Input: 'blocking' - flag to indicate whether to wait for incoming
+ *           messages (TRUE), or whether to return immediately if no
+ *           incoming messages are available (FALSE).
+ *    Output: None
+ *    Description:
+ *           Gets the next message into recv_buffer (see
+ *           giop_main_next_message) If we have a handler for incoming
+ *           messages, then pass recv_buffer to the handler (handler
+ *           becomes the new owner of recv_buffer's contents). Otherwise,
+ *           tosses it onto the list of received-but-unprocessed buffers.
+ *
+ *    Warnings:
+ *           If you don't have an IIOPIncomingMessageHandler set, you're
+ *           probably really screwed in the long run.
+ */
+void
+giop_main_iterate(gboolean blocking)
+{
+  GIOPRecvBuffer *recv_buffer;
+
+//  printk("giop_main_iterate: blocking: %d\n", blocking);
+schedule();
+
+  recv_buffer = giop_main_next_message(blocking);
+
+//  printk("giop_main_iterate: recv_buffer = 0x%08X\n", recv_buffer);
+
+  if(recv_buffer) {
+    if(IIOPIncomingMessageHandler)
+      IIOPIncomingMessageHandler(recv_buffer);
+    else
+      giop_received_list_push(recv_buffer);
+  }
+}
+
+/*
+ * giop_check_connections
+ *
+ *    Inputs: 'block_for_reply' - If no incoming data is immediately available
+ *            should this routine wait for incoming data (TRUE) or return
+ *            immediately (FALSE).
+ *
+ *    Outputs: 'connection' - the first connection that has incoming
+ *             data available for reading (supposedly a GIOP message, but
+ *             could be anything).
+ *
+ *    Side effects: Removes closed connections from the active list.
+ *
+ *    Global data structures used: giop_connection_list
+ *    
+ *    Description: Does a poll or select (OS-dependant) on the list of file
+ *                 descriptors in giop_connection_list.
+ *
+ * 		   If a file descriptor has been closed, call
+ * 		   giop_connection_handle_exception() on it and (as
+ * 		   appropriated by 'block_for_reply') either return
+ * 		   NULL or do another poll/select.
+ * 	  
+ * 		   If a file descriptor has data available for
+ * 		   reading, find the associated GIOPConnection (using
+ * 		   giop_connection_list.fd_to_connection_mapping) and
+ * 		   return that.
+ * 		  
+ */
+GIOPConnection *
+giop_check_connections(gboolean block_for_reply)
+{
+  GIOPConnection *connection = NULL;
+  int pollret;
+  int numcnx_checks;
+  int i;
+#ifndef USE_POLL
+  fd_set selectset_rd, selectset_ex;
+
+  struct timeval immediate_timeout = {0,0};
+#endif
+
+//  printk("giop_check_connections\n");
+  
+ do_read_msg:
+
+  if(!giop_connection_list.list) 
+  {
+//          printk("giop_check_connections : list = NULL\n");
+	  BUG();
+          return NULL;
+  }
+  
+#if 0
+  giop_connection_list_recreate(); /* easiest way to get valid
+				      select sets... */
+#endif
+
+#ifdef USE_POLL
+  numcnx_checks = giop_connection_list.pollset->len;
+#else
+  memcpy(&selectset_rd, &giop_connection_list.selectset_rd,
+	 sizeof(selectset_rd));
+  memcpy(&selectset_ex, &giop_connection_list.selectset_ex,
+	 sizeof(selectset_ex));
+
+  numcnx_checks = giop_connection_list.max_fd+1;
+#endif
+
+ restart:
+#ifdef USE_POLL
+  pollret = poll((struct pollfd *)giop_connection_list.pollset->data,
+		 giop_connection_list.pollset->len,
+		 block_for_reply?-1:0);
+
+#if KORBIT_DEBUG_WRITING
+{
+  int ix;
+  struct pollfd *fds = (struct pollfd *)giop_connection_list.pollset->data;
+//  printk("back from poll(#fds = %d, block = %d) = %d)\n", giop_connection_list.pollset->len, block_for_reply, pollret);
+//  for (ix = 0; ix < giop_connection_list.pollset->len; ix++)
+ //   printk("  [fd = 0x%X, event = 0x%X, revent = 0x%X]\n", 
+//           fds[ix].fd, fds[ix].events, fds[ix].revents);
+
+}
+#endif /* KORBIT_DEBUG_WRITING */
+
+
+#     else /* !USE_POLL */
+
+  {
+    pollret = select (giop_connection_list.max_fd + 1,
+		      &selectset_rd,
+		      NULL, &selectset_ex,
+		      block_for_reply?NULL:&immediate_timeout);
+  }
+#     endif /* !USE_POLL */
+
+//  printk("giop_check_connections : pollret == %d\n", pollret);
+  if(pollret <= 0) {
+    if(pollret < 0) {
+      if(errno == EINTR)
+	goto restart;
+      else
+	g_warning("Error code from select/poll: %s", g_strerror(errno));
+    } else
+      return NULL;
+  }
+
+  /* Check for data to be read on the fd's.
+     Note we have to do the hangup/exception checking in a separate loop,
+     because there may be data waiting to be read on a connection that the
+     other end has closed. */
+  for(i = 0; i < numcnx_checks; i++) {
+          struct fd_hash_elem *el;
+          
+#ifdef USE_POLL
+    struct pollfd *p = 
+      &g_array_index(giop_connection_list.pollset,
+		     struct pollfd, 
+		     i);
+    g_assert(p->fd <= giop_connection_list.max_fd);
+#ifndef __KORBIT__
+    connection = giop_connection_list.fd_to_connection_mapping->pdata[p->fd];
+#else
+    el = g_hash_table_lookup(giop_connection_list.fd_to_connection_mapping,
+                             &(p->fd));
+    if (el)
+            connection = el->cnx;
+#endif
+    if(p->revents & POLLIN)
+      goto got_connection;
+#else
+#ifndef __KORBIT__
+    connection = giop_connection_list.fd_to_connection_mapping->pdata[i];
+#else
+    el = g_hash_table_lookup(giop_connection_list.fd_to_connection_mapping,
+                             &i);
+    if (el)
+            connection = el->cnx;
+#endif
+    if (FD_ISSET(i, &selectset_rd)) {
+      goto got_connection;
+    }
+#endif    
+  }
+
+  /* Handle fd exceptions */
+  for(i = 0; i < numcnx_checks; i++)
+    {
+              struct fd_hash_elem *el;
+#ifdef USE_POLL
+      struct pollfd *p = 
+      &g_array_index(giop_connection_list.pollset,
+		     struct pollfd, 
+		     i);
+
+      g_assert(p->fd <= giop_connection_list.max_fd);
+      if(p->revents & (POLLHUP|POLLNVAL)) {
+#ifndef __KORBIT__
+	connection = giop_connection_list.fd_to_connection_mapping->pdata[p->fd];
+#else
+        el = g_hash_table_lookup(giop_connection_list.fd_to_connection_mapping,
+                                 &(p->fd));
+        if (el)
+                connection = el->cnx;
+#endif
+	giop_main_handle_connection_exception(connection);
+      }
+#else /* !USE_POLL */
+      if(FD_ISSET(i, &selectset_ex)) {
+#ifndef __KORBIT__
+	connection = giop_connection_list.fd_to_connection_mapping->pdata[i];
+#else
+        el = g_hash_table_lookup(giop_connection_list.fd_to_connection_mapping,
+                                 &i);
+        if (el)
+                connection = el->cnx;
+#endif
+	giop_main_handle_connection_exception(connection);
+      }
+#endif /* !USE_POLL */
+    }
+
+  /* Only reached if we didn't find a connection to read data from */
+  if(block_for_reply)
+    goto do_read_msg;
+
+ got_connection:
+//  printk("giop_check_connections : got connection\n");
+  return connection;
+}
+
diff -urN linux-2.4.1/net/korbit/IIOP/encoders.c linux-2.4.1-korbit/net/korbit/IIOP/encoders.c
--- linux-2.4.1/net/korbit/IIOP/encoders.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/encoders.c	Thu Feb  1 11:46:51 2001
@@ -0,0 +1,46 @@
+#include "config.h"
+#include <string.h>
+#include "IIOP.h"
+
+ENCODER_DEC(IOP_ServiceContext)
+{
+  APA(&mem->context_id, sizeof(mem->context_id));
+  ENCODER_CALL(CORBA_sequence_octet, &mem->context_data);
+}
+
+ENCODER_DEC(IOP_ServiceContextList)
+{
+  int i;
+
+  if(!mem)
+    {
+      APA((gpointer)giop_scratch_space, sizeof(mem->_length));
+      return;
+    }
+
+  APA(&mem->_length, sizeof(mem->_length));
+
+  for(i = 0; i < mem->_length; i++)
+    ENCODER_CALL(IOP_ServiceContext, &mem->_buffer[i]);
+}
+
+ENCODER_DEC(CORBA_sequence_octet)
+{
+  if(!mem)
+    {
+      APA((gpointer)giop_scratch_space, sizeof(mem->_length));
+      return;
+    }
+
+  APIA(&mem->_length, sizeof(mem->_length));
+  if(mem->_length > 0)
+    AP(mem->_buffer, mem->_length);
+}
+
+ENCODER_DEC(CORBA_char)
+{
+  GIOP_unsigned_long len = strlen(mem) + 1;
+
+  APIA(&len, sizeof(len));
+  AP(mem, len);
+}
diff -urN linux-2.4.1/net/korbit/IIOP/giop-msg-buffer.c linux-2.4.1-korbit/net/korbit/IIOP/giop-msg-buffer.c
--- linux-2.4.1/net/korbit/IIOP/giop-msg-buffer.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/giop-msg-buffer.c	Fri Feb  2 01:23:46 2001
@@ -0,0 +1,1443 @@
+/* The big picture:
+ * For every outgoing request, we have to have the network-ready data
+ * somewhere in memory.
+ *
+ * Using writev, any pieces that do not need endian conversion can
+ * be written in-place.
+ *
+ * The pieces that do need endian conversion can be put into one or more
+ * buffers.
+ *
+ * WHOA WHOA newsflash
+ * Because IIOP lets the message sender specify the endianness,
+ * we do not need to do endian conversion _ever_! The receiver can do all
+ * conversions if need be, or if they are the same endianness as sender they
+ * can just pull it in right off the wire :)
+ * 
+ */
+
+#include "config.h"
+#include "iiop-endianP.h"
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <string.h>
+
+#ifdef HAVE_POLL
+#  include <sys/poll.h>
+#else
+#  include <sys/types.h>
+#  include <sys/time.h>
+#endif
+#include "IIOP.h"
+#include "IIOP-private.h"
+
+#ifdef HAVE_LIMITED_WRITEV
+#define writev g_writev
+#endif
+
+/*
+#ifdef O_NONBLOCK
+#undef O_NONBLOCK
+#endif
+#define O_NONBLOCK 0
+*/
+
+
+/* type defs */
+
+#ifdef        __GNUC__
+#define       PACKED __attribute__((packed))
+#else
+#define       PACKED
+#endif
+
+/*
+ * Overlaps with struct _GIOPMessageHeader on purpose
+ *  - we save time because this stuff never changes
+ */
+struct _GIOPMessageHeaderConstants {
+  GIOP_char magic[4];
+  GIOP_char GIOP_version[2];
+  GIOP_octet flags;
+} PACKED;
+
+/* functions */
+static gint giop_recv_decode_message(GIOPRecvBuffer *buf);
+static gboolean num_on_list(GIOP_unsigned_long num,
+			    const GIOP_unsigned_long *request_ids,
+			    GIOP_unsigned_long req_count);
+static gint giop_recv_reply_decode_message(GIOPRecvBuffer *buf);
+static gint giop_recv_request_decode_message(GIOPRecvBuffer *buf);
+static gint giop_recv_locate_reply_decode_message(GIOPRecvBuffer *buf);
+static gint giop_recv_locate_request_decode_message(GIOPRecvBuffer *buf);
+static GIOPRecvBuffer *giop_received_list_check_reply(GIOP_unsigned_long request_id);
+
+#ifdef NOT_REENTRANT
+extern DEFINE_LOCK(iiop_connection_list);
+#endif
+GList *iiop_connection_list = NULL;
+
+/* global variables */
+char giop_scratch_space[2048];
+
+static const struct _GIOPMessageHeaderConstants
+giop_message_header_constants = {
+  "GIOP",
+  {1,0},
+  FLAG_ENDIANNESS,
+};
+
+struct iovec
+giop_first_message_vec = {NULL,
+			  sizeof(struct _GIOPMessageHeaderConstants)};
+
+DEFINE_LOCK(sendbufferlist);
+GSList *sendbufferlist = NULL;
+
+DEFINE_LOCK(recvbufferlist);
+GSList *recvbufferlist = NULL;
+
+DEFINE_LOCK(incoming_bufs);
+GList *incoming_bufs = NULL; /* List of incoming messages that had to be
+				shunted aside */
+
+DEFINE_LOCK(sendbuffers);
+DEFINE_LOCK(recvbuffers);
+GMemChunk *sendbuffers = NULL, *recvbuffers = NULL;
+
+DEFINE_LOCK(request_id_counter);
+GIOP_unsigned_long request_id_counter;
+
+#if 0
+inline
+void giop_message_buffer_append_iovec(GIOPMessageBuffer *msgbuf,
+				      const struct iovec *iovec)
+{
+  /* g_print("Appending iovec %d bytes @ %p\n", iovec->iov_len, iovec->iov_base); */
+  g_array_append_val(msgbuf->iovecs, *iovec);
+}
+#else
+#define giop_message_buffer_append_iovec(msgbuf, iovec) g_array_append_val((msgbuf)->iovecs, *(iovec))
+#endif
+
+void
+giop_message_buffer_init(void)
+{
+  giop_first_message_vec.iov_base = (gpointer)&giop_message_header_constants;
+  INIT_LOCK(sendbufferlist);
+  INIT_LOCK(recvbufferlist);
+  request_id_counter = 1;
+  INIT_LOCK(request_id_counter);
+
+  INIT_LOCK(sendbuffers);
+  sendbuffers = g_mem_chunk_create(GIOPSendBuffer, 2, G_ALLOC_ONLY);
+  INIT_LOCK(recvbuffers);
+  recvbuffers = g_mem_chunk_create(GIOPRecvBuffer, 2, G_ALLOC_ONLY);
+}
+
+static void
+giop_message_buffer_new(GIOPMessageBuffer *buf)
+{
+  buf->iovecs = g_array_new(FALSE, FALSE, sizeof(struct iovec));
+}
+
+#define STRUCT_OFFSET(t, f) ((int) ((char*) &((t*) 0)->f))
+
+/* Send buffers only */
+static GIOPSendBuffer *
+giop_send_buffer_new(void)
+{
+  GIOPSendBuffer *msgbuf;
+  struct iovec firstvec;
+
+  GET_LOCK(sendbuffers);
+  msgbuf = g_chunk_new(GIOPSendBuffer, sendbuffers);
+  RELEASE_LOCK(sendbuffers);
+
+  giop_message_buffer_new(GIOP_MESSAGE_BUFFER(msgbuf));
+
+  giop_message_buffer_append_iovec(GIOP_MESSAGE_BUFFER(msgbuf),
+				   &giop_first_message_vec);
+
+  firstvec.iov_base = &(GIOP_MESSAGE_BUFFER(msgbuf)->message_header.message_type);
+  firstvec.iov_len = sizeof(GIOPMessageHeader)
+    - STRUCT_OFFSET(GIOPMessageHeader, message_type);
+  GIOP_MESSAGE_BUFFER(msgbuf)->message_header.message_size = 0;
+
+  msgbuf->indirects = g_mem_chunk_create(char[GIOP_INDIRECT_CHUNK_SIZE],
+					 2, G_ALLOC_ONLY);
+
+  giop_message_buffer_append_iovec(GIOP_MESSAGE_BUFFER(msgbuf), &firstvec);
+
+  return msgbuf;
+}
+
+gint
+giop_send_buffer_write(GIOPSendBuffer *send_buffer)
+{
+  gulong nvecs;
+  glong res, sum, t;
+  struct iovec *curvec;
+  int fd;
+  GIOPConnection *cnx;
+  gint retval = -1;
+
+//  printf("giop_send_buffer_write\n");
+
+  cnx = GIOP_MESSAGE_BUFFER(send_buffer)->connection;
+  if(!cnx->is_valid)
+    return -1;
+
+  fd = GIOP_CONNECTION_GET_FD(cnx);
+  nvecs = GIOP_MESSAGE_BUFFER(send_buffer)->iovecs->len;
+  curvec = (struct iovec *)GIOP_MESSAGE_BUFFER(send_buffer)->iovecs->data;
+
+#if defined(ORBIT_DEBUG) && 0
+  g_print("Message of length %d looks like:\n",
+	  GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_size);
+{ int i = 0;
+  for(sum = 0; i < nvecs; i++) {
+    sum += curvec[i].iov_len;
+    g_print("    [%p, %d]: %d\n", curvec[i].iov_base, curvec[i].iov_len,
+	    sum);
+  }
+}
+#endif
+
+  fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK);
+  res = writev(fd, curvec, nvecs);
+//  printk("writev wrote %d byte\n", res);
+
+  sum = (GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_size + sizeof(GIOPMessageHeader));
+  if(res < sum) {
+    if(res < 0) {
+//printf("writev returned %d\n", res);
+      if(errno != EAGAIN) {
+	giop_main_handle_connection_exception(cnx);
+	goto out;
+      }
+
+      res = 0;
+    }
+
+    /* wrote 7, iovecs 3, 2, 2, 4:
+       0 + 3 !> 7
+       3 + 2 !> 7
+       5 + 2 !> 7
+     */
+
+    for(t = 0; ; t += curvec->iov_len, curvec++, nvecs--) {
+      if((t + curvec->iov_len) > res)
+	break;
+    }
+    if((res - t) > 0) {
+      curvec->iov_len -= (res - t);
+      curvec->iov_base = (gpointer)((char *)curvec->iov_base + (res - t));
+    }
+
+
+    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK);
+    t = writev(fd, curvec, nvecs);
+
+    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK);
+
+    if((t < 0) || ((res + t) < sum)) {
+//printf("crap, t = %d   res = %d   sum = %d\n", t, res, sum);
+	giop_main_handle_connection_exception(cnx);
+	goto out;
+    }
+  }
+
+  retval = 0;
+
+ out:
+
+  return retval;
+}
+
+static GIOPSendBuffer *
+giop_send_buffer_use(GIOPConnection *connection)
+{
+  GIOPSendBuffer *retval;
+
+  if(!connection->is_valid)
+    return NULL;
+
+  GET_LOCK(sendbufferlist);
+
+  if(sendbufferlist)
+    {
+      GSList *head;
+
+      retval = sendbufferlist->data;
+
+      head = sendbufferlist;
+      sendbufferlist = g_slist_remove_link(sendbufferlist, sendbufferlist);
+      g_slist_free_1 (head);
+
+      g_array_set_size(GIOP_MESSAGE_BUFFER(retval)->iovecs, 2);
+      GIOP_MESSAGE_BUFFER(retval)->message_header.message_size = 0;
+    }
+  else
+    retval = giop_send_buffer_new();
+
+  RELEASE_LOCK(sendbufferlist);
+  
+  giop_connection_ref(connection);
+  GIOP_MESSAGE_BUFFER(retval)->connection = connection;
+
+  g_mem_chunk_reset(retval->indirects);
+  retval->indirect = g_chunk_new(gpointer, retval->indirects);
+#ifdef ORBIT_DEBUG
+  memset(retval->indirect, '\xFE', GIOP_INDIRECT_CHUNK_SIZE);
+#endif
+  retval->indirect_used = 0;
+
+  return retval;
+}
+
+GIOPSendBuffer *
+giop_send_reply_buffer_use(GIOPConnection *connection,
+			   const IOP_ServiceContextList *service_context,
+			   GIOP_unsigned_long request_id,
+			   GIOPReplyStatusType reply_status)
+{
+  GIOPSendBuffer *send_buffer;
+
+  send_buffer = giop_send_buffer_use(connection);
+
+  if(!send_buffer)
+    return NULL;
+
+  GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_type = GIOP_REPLY;
+
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   sizeof(GIOP_unsigned_long));
+  if(!service_context) {
+    static const GIOP_unsigned_long sc_zero_int = 0;
+    AP(&sc_zero_int, sizeof(service_context->_length));
+  } else {
+    int i, n;
+    n = service_context->_length;
+    AP(&service_context->_length, sizeof(service_context->_length));
+    for(i = 0; i < n; i++) {
+      int j, o;
+      CORBA_sequence_octet *seqo;
+
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				       sizeof(GIOP_unsigned_long));
+      AP(&service_context->_buffer[i].context_id,
+	 sizeof(service_context->_buffer[i].context_id));
+      seqo = &service_context->_buffer[i].context_data;
+      o = seqo->_length;
+      AP(&seqo->_length, sizeof(GIOP_unsigned_long));
+      for(j = 0; j < o; j++)
+	AP(seqo->_buffer, seqo->_length);
+    }
+  }
+  send_buffer->message.u.reply.request_id = request_id;
+  send_buffer->message.u.reply.reply_status = reply_status;
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   sizeof(GIOP_unsigned_long));
+  AP(&send_buffer->message.u.reply.request_id,
+     sizeof(GIOP_unsigned_long));
+  AP(&send_buffer->message.u.reply.reply_status,
+     sizeof(GIOP_unsigned_long));
+
+  return send_buffer;
+}
+
+GIOPSendBuffer *
+giop_send_locate_reply_buffer_use(GIOPConnection *connection,
+			   GIOP_unsigned_long request_id,
+			   GIOPLocateStatusType locate_reply_status)
+{
+  GIOPSendBuffer *send_buffer;
+
+  send_buffer = giop_send_buffer_use(connection);
+
+  if(!send_buffer)
+    return NULL;
+
+  GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_type = GIOP_LOCATEREPLY;
+
+  APIA(&request_id, sizeof(request_id));
+  APIA(&locate_reply_status, sizeof(locate_reply_status));
+
+  return send_buffer;
+}
+
+GIOPSendBuffer *
+giop_send_request_buffer_use(GIOPConnection *connection,
+			     const IOP_ServiceContextList *service_context,
+			     GIOP_unsigned_long request_id,
+			     GIOP_boolean response_expected,
+			     const struct iovec *object_key_vec,
+			     const struct iovec *operation_vec,
+			     const struct iovec *principal_vec)
+{
+  GIOPSendBuffer *send_buffer;
+#if 0
+  static const struct {
+    CORBA_unsigned_long _length;
+    char _buffer[7];
+  } default_principal = { sizeof("nobody"), "nobody" };
+  static const struct iovec default_principal_vec =
+  {(void *)&default_principal,
+   sizeof(CORBA_unsigned_long) + sizeof("nobody")};
+#endif
+
+  if (!connection)
+    return NULL;
+  if(!object_key_vec)
+    return NULL;
+  if(!operation_vec)
+    return NULL;
+
+  ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug,
+	      "Sending request %s id %d to %s\n",
+	      ((guchar *)operation_vec->iov_base) + 4,
+	      request_id, ((guchar *)object_key_vec->iov_base) + 4);
+
+  send_buffer = giop_send_buffer_use(connection);
+
+  if (!send_buffer)
+    return NULL;
+
+  GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_type = GIOP_REQUEST;
+
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   sizeof(GIOP_unsigned_long));
+  if(!service_context) {
+    static const GIOP_unsigned_long sc_zero_int = 0;
+    AP(&sc_zero_int, sizeof(GIOP_unsigned_long));
+  } else {
+    int i, n;
+    n = service_context->_length;
+    AP(&service_context->_length, sizeof(service_context->_length));
+    for(i = 0; i < n; i++) {
+      int j, o;
+      CORBA_sequence_octet *seqo;
+
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				       sizeof(GIOP_unsigned_long));
+      AP(&service_context->_buffer[i].context_id,
+	 sizeof(service_context->_buffer[i].context_id));
+      seqo = &service_context->_buffer[i].context_data;
+      o = seqo->_length;
+      AP(&seqo->_length, sizeof(GIOP_unsigned_long));
+      for(j = 0; j < o; j++)
+	AP(seqo->_buffer, seqo->_length);
+    }
+  }
+  send_buffer->message.u.request.request_id = request_id;
+  send_buffer->message.u.request.response_expected = response_expected;
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   sizeof(GIOP_unsigned_long));
+  AP(&send_buffer->message.u.request.request_id,
+     sizeof(GIOP_unsigned_long));
+  AP(&send_buffer->message.u.request.response_expected,
+     sizeof(GIOP_boolean));
+#if 0
+  API(&response_expected, 1);
+  AP((gpointer)giop_scratch_space, 3);
+#endif
+
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   sizeof(CORBA_unsigned_long));
+  giop_message_buffer_append_iovec(GIOP_MESSAGE_BUFFER(send_buffer),
+				   object_key_vec);
+  GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_size +=
+    object_key_vec->iov_len;
+
+  /*
+   * We can know the length at compile time - don't calculate it at runtime
+   * if we can help it :)
+   */
+  /* ENCODER_CALL(CORBA_string, (CORBA_string *)operation); */
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   sizeof(CORBA_unsigned_long));
+  giop_message_buffer_append_iovec(GIOP_MESSAGE_BUFFER(send_buffer),
+				   operation_vec);
+  GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_size +=
+    operation_vec->iov_len;
+
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   sizeof(CORBA_unsigned_long));
+  giop_message_buffer_append_iovec(GIOP_MESSAGE_BUFFER(send_buffer),
+				   principal_vec);
+  GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_size +=
+    principal_vec->iov_len;
+
+  return send_buffer;
+}
+
+GIOPSendBuffer *
+giop_send_locate_request_buffer_use(GIOPConnection *connection,
+			     GIOP_unsigned_long request_id,
+			     const struct iovec *object_key_vec)
+{
+	GIOPSendBuffer *send_buffer;
+
+	if (!connection)
+		return NULL;
+	if (!object_key_vec)
+		return NULL;
+
+	ORBit_Trace(TraceMod_IIOP, TraceLevel_Debug,
+		"Sending locate request id %d to %s\n",
+		request_id, ((guchar *)object_key_vec->iov_base) + 4);
+
+	send_buffer = giop_send_buffer_use(connection);
+
+	if (!send_buffer)
+		return NULL;
+
+	GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_type = GIOP_LOCATEREQUEST;
+
+	APIA(&request_id, sizeof(request_id));
+
+	giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+		sizeof(CORBA_unsigned_long));
+	giop_message_buffer_append_iovec(GIOP_MESSAGE_BUFFER(send_buffer),
+		object_key_vec);
+	GIOP_MESSAGE_BUFFER(send_buffer)->message_header.message_size +=
+		object_key_vec->iov_len;
+
+	return send_buffer;
+}
+
+void
+giop_send_buffer_unuse(GIOPSendBuffer *send_buffer)
+{
+  if (send_buffer == NULL)
+    return;
+
+  giop_connection_unref(GIOP_MESSAGE_BUFFER(send_buffer)->connection);
+
+  GET_LOCK(sendbufferlist);
+  sendbufferlist = g_slist_prepend(sendbufferlist, send_buffer);
+  RELEASE_LOCK(sendbufferlist);
+}
+
+gulong
+giop_message_buffer_do_alignment(GIOPMessageBuffer *buffer,
+				 gulong align_for)
+{
+  struct iovec newvec;
+  struct iovec *lastvec;
+  guint alignme;
+  gulong real_msgsize;
+  gulong align_diff;
+
+  if(align_for < 2) return 0;
+  if(align_for >
+     MAX(sizeof(GIOP_long_long),sizeof(GIOP_long_double)))
+    align_for = MAX(sizeof(GIOP_long_long), sizeof(GIOP_long_double));
+
+  real_msgsize = buffer->message_header.message_size+sizeof(GIOPMessageHeader);
+
+  alignme = (gulong)ALIGN_ADDRESS(real_msgsize, align_for);
+
+  align_diff = alignme - real_msgsize;
+  if(align_diff > 0)
+    {
+      lastvec = (struct iovec *)(buffer->iovecs->data) 
+				 + buffer->iovecs->len - 1;
+
+      if(lastvec->iov_base == giop_scratch_space)
+	{
+	  newvec.iov_len = align_diff;
+	  lastvec->iov_len += align_diff;
+	  buffer->message_header.message_size += align_diff;
+	}
+      else
+	{
+	  newvec.iov_base = (gpointer)giop_scratch_space;
+	  newvec.iov_len = align_diff;
+	  buffer->message_header.message_size += align_diff;
+	  giop_message_buffer_append_iovec(buffer, &newvec);
+	}
+      return newvec.iov_len;
+    }
+  else
+    return 0;
+}
+
+void 
+giop_message_buffer_append_mem_a(GIOPMessageBuffer *buffer,
+				 gconstpointer mem_region,
+				 gulong mem_region_length)
+{
+  struct iovec newvec;
+  struct iovec *lastvec;
+  gint alignfor;
+
+  alignfor = giop_message_buffer_do_alignment(buffer, mem_region_length);
+
+  lastvec = (struct iovec *)(buffer->iovecs->data) + 
+			     + buffer->iovecs->len - 1;
+
+  if((mem_region == giop_scratch_space && lastvec->iov_base == giop_scratch_space)
+     || (alignfor == 0 && (((guchar *)lastvec->iov_base) + lastvec->iov_len) == mem_region))
+    {
+      lastvec->iov_len += mem_region_length;
+    }
+  else
+    {
+      newvec.iov_base = (gpointer)mem_region;
+      newvec.iov_len = mem_region_length;
+      giop_message_buffer_append_iovec(buffer, &newvec);
+    }
+
+  buffer->message_header.message_size += mem_region_length;
+}
+
+void 
+giop_message_buffer_append_mem(GIOPMessageBuffer *buffer,
+			       gconstpointer mem_region,
+			       gulong mem_region_length)
+{
+  struct iovec newvec;
+  struct iovec *lastvec;
+
+  lastvec = (struct iovec *)(buffer->iovecs->data)
+			     + buffer->iovecs->len - 1;
+
+  if((mem_region == giop_scratch_space
+      && lastvec->iov_base == giop_scratch_space)
+     || ((((guchar *)lastvec->iov_base) + lastvec->iov_len) == mem_region))
+    {
+      lastvec->iov_len += mem_region_length;
+    }
+  else
+    {
+      newvec.iov_base = (gpointer)mem_region;
+      newvec.iov_len = mem_region_length;
+      giop_message_buffer_append_iovec(buffer, &newvec);
+    }
+
+  buffer->message_header.message_size += mem_region_length;
+}
+
+/* I think we need a WE_WANT_NEW_CRAPPY_BUGGY_CODE ifdef here - this
+   tiny routine seems to be horribly hard to get right.
+
+   Basically we have to paste the whole of 'mem_region' into our
+   memory chunks, possibly subdividing it up to fit it into multiple
+   1K chunks. Because we have to return the first paste point in case
+   the client wants to manipulate it afterwards, if mem_region_length
+   >= sizeof(CORBA_unsigned_long), we also have to guarantee that the
+   pasted stuff doesn't get divided on a finer boundary than
+   sizeof(CORBA_unsigned_long).
+*/
+gpointer
+giop_send_buffer_append_mem_indirect(GIOPSendBuffer *send_buffer,
+				     gconstpointer mem_region,
+				     gulong mem_region_length)
+{
+  gulong offset = 0, thisblock_size;
+  gpointer blockstart = NULL;
+
+  while(offset < mem_region_length) {
+    thisblock_size = MIN(mem_region_length - offset,
+			 GIOP_INDIRECT_CHUNK_SIZE - send_buffer->indirect_used);
+
+    if((thisblock_size >= sizeof(CORBA_unsigned_long))
+       || (mem_region_length - offset) < sizeof(CORBA_unsigned_long)) {
+      if (!blockstart)
+	blockstart =
+	  ((guchar*) send_buffer->indirect) + send_buffer->indirect_used;
+
+      memcpy((guchar*)send_buffer->indirect + send_buffer->indirect_used,
+	     (guchar*)mem_region + offset, thisblock_size);
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(send_buffer),
+				     (guchar*)send_buffer->indirect +
+				     send_buffer->indirect_used,
+				     thisblock_size);
+      offset += thisblock_size;
+      send_buffer->indirect_used += thisblock_size;
+    }
+
+    if(send_buffer->indirect_used >= (GIOP_INDIRECT_CHUNK_SIZE - sizeof(CORBA_unsigned_long))) {
+#ifdef I_CANT_FIGURE_OUT_WHAT_THIS_LOGIC_WAS_MEANT_TO_DO
+       || (thisblock_size >= sizeof(CORBA_unsigned_long)
+	   && (mem_region_length - offset) > 0)) {
+#endif
+	  send_buffer->indirect_used = 0;
+	  send_buffer->indirect = g_chunk_new(gpointer,
+					      send_buffer->indirects);
+    }
+  }
+
+  return blockstart;
+}
+
+#ifdef WE_WANT_OLD_DEAD_CRAPPY_BUGGY_CODE
+gpointer
+_giop_send_buffer_append_mem_indirect(GIOPSendBuffer *send_buffer,
+				     gconstpointer mem_region,
+				     gulong mem_region_length)
+{
+  gpointer blockstart = NULL;
+  gulong offset, new_offset;
+
+  for(offset = new_offset = 0; new_offset < mem_region_length;)
+    {
+      new_offset =
+	MIN(mem_region_length - offset,
+	    GIOP_INDIRECT_CHUNK_SIZE - send_buffer->indirect_used);
+
+      if((new_offset - offset) > sizeof(CORBA_unsigned_long)
+	 || mem_region_length >= sizeof(CORBA_unsigned_long)) {
+
+	if(!blockstart)
+	  blockstart = send_buffer->indirect + send_buffer->indirect_used;
+      }
+	
+      memcpy(send_buffer->indirect + send_buffer->indirect_used,
+	     mem_region + offset, new_offset - offset);
+	
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(send_buffer),
+				     send_buffer->indirect + send_buffer->indirect_used,
+				     new_offset - offset);
+
+      send_buffer->indirect_used += new_offset - offset;
+
+      offset = new_offset;
+
+      if(new_offset >= GIOP_INDIRECT_CHUNK_SIZE)
+	{
+	  send_buffer->indirect_used = 0;
+	  send_buffer->indirect = g_chunk_new(gpointer,
+					      send_buffer->indirects);
+#ifdef ORBIT_DEBUG
+	  memset(send_buffer->indirect, '\xFE', GIOP_INDIRECT_CHUNK_SIZE);
+#endif
+	}
+    }
+
+  return blockstart;
+}
+#endif
+
+gpointer
+giop_send_buffer_append_mem_indirect_a(GIOPSendBuffer *send_buffer,
+				       gconstpointer mem_region,
+				       gulong mem_region_length)
+{
+  giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(send_buffer),
+				   mem_region_length);
+  return giop_send_buffer_append_mem_indirect(send_buffer,
+					      mem_region, mem_region_length);
+}
+
+GIOP_unsigned_long
+giop_get_request_id(void)
+{
+  GIOP_unsigned_long retval;
+  GET_LOCK(request_id_counter);
+  retval = request_id_counter++;
+  RELEASE_LOCK(request_id_counter);
+  return retval;
+}
+
+/****************************************************
+ * GIOPRecvBuffer routines
+ ****************************************************/
+
+static GIOPRecvBuffer *
+giop_recv_buffer_new(void)
+{
+  GIOPRecvBuffer *msgbuf;
+
+  GET_LOCK(recvbuffers);
+  msgbuf = g_chunk_new(GIOPRecvBuffer, recvbuffers);
+  RELEASE_LOCK(recvbuffers);
+
+  giop_message_buffer_new(GIOP_MESSAGE_BUFFER(msgbuf));
+  msgbuf->message_body = NULL;
+
+  return msgbuf;
+}
+
+void
+giop_recv_buffer_unuse(GIOPRecvBuffer *buffer)
+{
+  if (buffer == NULL)
+    return;
+
+  if(buffer->message_body) {
+    buffer->message_body = ((guchar *)buffer->message_body)
+      - sizeof(GIOPMessageHeader);
+    
+    g_free(buffer->message_body);
+    buffer->message_body = NULL;
+  }
+
+  if(GIOP_MESSAGE_BUFFER(buffer)->connection->incoming_msg == buffer)
+    GIOP_MESSAGE_BUFFER(buffer)->connection->incoming_msg = NULL;
+
+  giop_connection_unref(GIOP_MESSAGE_BUFFER(buffer)->connection);
+
+  GET_LOCK(recvbufferlist);
+  recvbufferlist = g_slist_prepend(recvbufferlist, buffer);
+  RELEASE_LOCK(recvbufferlist);
+}
+
+static GIOPRecvBuffer *
+giop_recv_buffer_use(GIOPConnection *connection)
+{
+  GIOPRecvBuffer *retval;
+
+  if(!connection || !connection->is_valid)
+    return NULL;
+
+  GET_LOCK(recvbufferlist);
+
+  if(recvbufferlist)
+    {
+      GSList *head;
+
+      retval = recvbufferlist->data;
+
+      head = recvbufferlist;
+      recvbufferlist = g_slist_remove_link(recvbufferlist, recvbufferlist);
+      g_slist_free_1 (head);
+
+      GIOP_MESSAGE_BUFFER(retval)->message_header.message_size = 0;
+      retval->message_body = NULL;
+    }
+  else
+    retval = giop_recv_buffer_new();
+
+  retval->state = GIOP_MSG_READING_HEADER;
+  retval->left_to_read = sizeof(GIOPMessageHeader);
+
+  RELEASE_LOCK(recvbufferlist);
+  
+  giop_connection_ref(connection);
+  GIOP_MESSAGE_BUFFER(retval)->connection = connection;
+
+  return retval;
+}
+
+GIOPRecvBuffer *
+giop_recv_message_buffer_use(GIOPConnection *connection)
+{
+  GIOPRecvBuffer *retval;
+  char *bptr;
+  int sysret;
+  guint message_size;
+  
+//  printf("giop_recv_message_buffer_use: connection = 0x%X\n", connection);
+
+  if(!connection || !connection->is_valid)
+    return NULL;
+
+  if(connection->incoming_msg)
+    retval = connection->incoming_msg;
+  else {
+    retval = giop_recv_buffer_use(connection);
+    connection->incoming_msg = retval;
+  }
+
+  if(!retval) return NULL;
+
+  do {
+    switch(retval->state) {
+    case GIOP_MSG_READING_HEADER:
+      bptr = ((char *)&(GIOP_MESSAGE_BUFFER(retval)->message_header));
+      bptr += sizeof(GIOP_MESSAGE_BUFFER(retval)->message_header)
+	- retval->left_to_read;
+      break;
+    case GIOP_MSG_READING_BODY:
+      bptr = retval->cur; /* Reason for not using retval->message_body:
+			     See note XXX1 below */
+      bptr += GIOP_MESSAGE_BUFFER(retval)->message_header.message_size;
+      bptr -= retval->left_to_read;
+      break;
+    default:
+      bptr = NULL;
+    }
+
+//printf("#1p1: READ %d bytes: errno %d state = %d\n", retval->left_to_read, errno, retval->state);
+    sysret = read(GIOP_CONNECTION_GET_FD(connection), bptr,
+		  retval->left_to_read);
+
+    if((sysret == 0)
+       || ((sysret < 0) && (errno != EAGAIN))) {
+//printf("#1: sysret = %d bptr = 0x%X errno = %d\n", sysret, bptr, errno);
+      goto errout;
+    }
+
+    if(sysret > 0)
+      retval->left_to_read -= sysret;
+
+    if(retval->left_to_read == 0) {
+      /* we change states here */
+
+      switch(retval->state) {
+      case GIOP_MSG_READING_HEADER:
+	/* Check the magic stuff */
+	if(strncmp(GIOP_MESSAGE_BUFFER(retval)->message_header.magic, "GIOP", 4)
+	   || GIOP_MESSAGE_BUFFER(retval)->message_header.GIOP_version[0] != 1) {
+//printf("#2: Not a GIOP thinger? '%s'\n", GIOP_MESSAGE_BUFFER(retval)->message_header.magic);
+	  goto errout;
+        }
+	if(GIOP_MESSAGE_BUFFER(retval)->message_header.message_size == 0
+	   && GIOP_MESSAGE_BUFFER(retval)->message_header.message_type != GIOP_CLOSECONNECTION) {
+//	  printf("Unexpected 0-length IIOP message\n");
+	  goto errout;
+	}
+
+	if(giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(retval))) {
+	  CORBA_unsigned_long t = GIOP_MESSAGE_BUFFER(retval)->message_header.message_size;
+	  retval->decoder = (void (*)(gpointer, gpointer, gulong))iiop_byteswap;
+
+	  iiop_byteswap((gpointer)&GIOP_MESSAGE_BUFFER(retval)->message_header.message_size,
+			(gpointer)&t, sizeof(t));
+	} else {
+#ifdef __KERNEL__
+	  retval->decoder = (void (*)(gpointer,gpointer,gulong))__memcpy;
+#else
+	  retval->decoder = (void (*)(gpointer,gpointer,gulong))memcpy;
+#endif
+	}
+
+	message_size = GIOP_MESSAGE_BUFFER(retval)->message_header.message_size;
+	if(!connection->is_auth
+	   && message_size > 131072) {
+//	  printf("message size is bigger than 128k (%d)\n", message_size);
+	  goto errout;
+	}
+
+	retval->message_body = g_malloc(message_size+sizeof(GIOPMessageHeader));
+	/* XXX1 This is a lame hack to work with the fact that
+	   alignment is relative to the MessageHeader, not the RequestHeader */
+	retval->message_body = ((guchar *)retval->message_body) + sizeof(GIOPMessageHeader);
+	retval->cur = retval->message_body;
+	retval->state = GIOP_MSG_READING_BODY;
+	retval->left_to_read = message_size;
+	break;
+      case GIOP_MSG_READING_BODY:
+	if(giop_recv_decode_message(retval)) {
+//printf("giop_recv_decode_message FAILURE!\n");
+	  goto errout;
+	}
+	connection->incoming_msg = NULL;
+	retval->state = GIOP_MSG_READY;
+	break;
+      default:
+        break;
+      }
+    } else if(retval->left_to_read < 0) {
+//      printf("Whoa, we overstepped the number of bytes we were supposed to read by %d\n", -retval->left_to_read);
+      goto errout;
+    } else /* retval->left_to_read > 0 */ {
+      /* couldn't read the whole piece, save it */
+      retval = NULL;
+    }
+  } while(retval && retval->state != GIOP_MSG_READY);
+  
+  return retval;
+
+ errout:
+  giop_recv_buffer_unuse(retval);
+  giop_main_handle_connection_exception(connection);
+  return NULL;
+}
+
+void
+giop_received_list_push(GIOPRecvBuffer *recv_buffer)
+{
+  GET_LOCK(incoming_bufs);
+  incoming_bufs = g_list_prepend(incoming_bufs, recv_buffer);
+  RELEASE_LOCK(incoming_bufs);
+}
+
+GIOPRecvBuffer *giop_received_list_pop(void)
+{
+  GList *head;
+  GIOPRecvBuffer *retval;
+
+  GET_LOCK(incoming_bufs);
+
+  head = incoming_bufs;
+
+  if(!head)
+    return NULL;
+
+  retval = head->data;
+  incoming_bufs = g_list_remove_link(incoming_bufs, head);
+  g_list_free_1 (head);
+
+  RELEASE_LOCK(incoming_bufs);
+
+  return retval;
+}
+
+static GIOPRecvBuffer *
+giop_received_list_check_reply(GIOP_unsigned_long request_id)
+{
+  GIOPRecvBuffer *retval = NULL;
+  GList *item = NULL;
+
+  GET_LOCK(incoming_bufs);
+
+  for(item = incoming_bufs; item; item = g_list_next(item))
+    {
+      if(GIOP_MESSAGE_BUFFER(item->data)->message_header.message_type == GIOP_REPLY
+	 && GIOP_RECV_BUFFER(item->data)->message.u.reply.request_id == request_id) {
+	retval = item->data;
+	break;
+      }
+    }
+
+  if(retval)
+    incoming_bufs = g_list_remove(incoming_bufs, retval);
+
+  RELEASE_LOCK(incoming_bufs);
+
+  return retval;
+}
+
+/** giop_recv_reply_buffer_use_multiple
+ */
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use_multiple(GArray *request_ids,
+				    gboolean block_for_reply)
+{
+  return giop_recv_reply_buffer_use_multiple_2(NULL, request_ids, block_for_reply);
+}
+
+/* here is how it will be:
+   one routine for getting next message with a specified reply ID.
+ */
+
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use_multiple_2(GIOPConnection *request_cnx,
+				      GArray *request_ids,
+				      gboolean block_for_reply)
+{
+  int i;
+  GIOPRecvBuffer *retval = NULL;
+  GSList *pushme = NULL;
+
+  do {
+    /*
+     * We _do_ want to put this inside the loop,
+     * because we may call ourselves recursively for different request_id's
+     */
+    for(i = 0; i < request_ids->len && !retval; i++)
+      retval = giop_received_list_check_reply(g_array_index(request_ids, GIOP_unsigned_long, i));
+
+    if(retval)
+      break;
+
+    retval = giop_main_next_message_2(block_for_reply, request_cnx);
+
+    if(retval) {
+      if(GIOP_MESSAGE_BUFFER(retval)->message_header.message_type == GIOP_REPLY) {
+	 if(num_on_list(retval->message.u.reply.request_id,
+			(GIOP_unsigned_long *)request_ids->data,
+			request_ids->len))
+	   break;
+	 else {
+	   pushme = g_slist_prepend(pushme, retval); retval = NULL;
+	 }
+      } else {
+	if(IIOPIncomingMessageHandler)
+	  IIOPIncomingMessageHandler(retval);
+	else {
+	  pushme = g_slist_prepend(pushme, retval); retval = NULL;
+	}
+	retval = NULL;
+      }
+    } else
+      return NULL;
+
+  } while(!retval && block_for_reply);
+
+  g_slist_foreach(pushme, (GFunc)giop_received_list_push, NULL);
+  g_slist_free(pushme);
+
+  return retval;
+}
+
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use(GIOP_unsigned_long request_id,
+			   gboolean block_for_reply)
+{
+  return giop_recv_reply_buffer_use_2(NULL, request_id, block_for_reply);
+}
+
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use_2(GIOPConnection *request_cnx,
+			     GIOP_unsigned_long request_id,
+			     gboolean block_for_reply)
+{
+  GArray fakeme;
+
+  fakeme.len = 1;
+  fakeme.data = (gpointer)&request_id;
+
+  return giop_recv_reply_buffer_use_multiple_2(request_cnx,
+					       &fakeme,
+					       block_for_reply);
+}
+
+GIOPRecvBuffer *
+giop_recv_locate_reply_buffer_use(GIOP_unsigned_long request_id,
+				  gboolean block_for_reply)
+{
+  GIOPRecvBuffer *retval = NULL;
+
+  do {
+    /*
+     * We _do_ want to put this inside the loop,
+     * because we may call ourselves recursively for different request_id's
+     */
+    retval = giop_received_list_check_reply(request_id);
+
+    if(retval)
+      break;
+
+    retval = giop_main_next_message_2(TRUE, NULL);
+
+    if(retval) {
+      if(GIOP_MESSAGE_BUFFER(retval)->message_header.message_type == GIOP_LOCATEREPLY
+	 && retval->message.u.locate_reply.request_id == request_id)
+	break;
+      else {
+	if(IIOPIncomingMessageHandler)
+	  IIOPIncomingMessageHandler(retval);
+	else
+	  giop_received_list_push(retval);
+	retval = NULL;
+      }
+    } else
+      return NULL;
+  } while(!retval && block_for_reply);
+
+  return retval;
+}
+
+static gint
+giop_recv_decode_message(GIOPRecvBuffer *buf)
+{
+  switch(GIOP_MESSAGE_BUFFER(buf)->message_header.message_type)
+    {
+    case GIOP_REPLY:
+      return giop_recv_reply_decode_message(buf);
+      break;
+    case GIOP_REQUEST:
+      return giop_recv_request_decode_message(buf);
+      break;
+    case GIOP_LOCATEREQUEST:
+      return(giop_recv_locate_request_decode_message(buf));
+      break;
+    case GIOP_LOCATEREPLY:
+      return(giop_recv_locate_reply_decode_message(buf));
+      break;
+    case GIOP_CLOSECONNECTION:
+      return 0;
+      break;
+    default:
+//      printf("Don't know how to decode message type %d\n",
+//		GIOP_MESSAGE_BUFFER(buf)->message_header.message_type);
+      return -1;
+    }
+}
+
+/* if(currptr+len > end || currptr + len < currptr) */
+
+/* This whole mess needs redoing. */
+#define CHECK_NEW_POS(buf, requested_increment) \
+if(!( (( ((guchar*)GIOP_RECV_BUFFER(buf)->cur) \
+		        + (requested_increment) ) \
+		       <= ( ((guchar *)GIOP_RECV_BUFFER(buf)->message_body) \
+			   + GIOP_MESSAGE_BUFFER(buf)->message_header.message_size)) \
+		      && ( ( ((guchar*)GIOP_RECV_BUFFER(buf)->cur) \
+			    + (requested_increment) ) \
+			  >= ((guchar*)GIOP_RECV_BUFFER(buf)->cur) ))) goto out;
+
+#define NEW_POS_OUT out: return -1
+
+#define SAFE_ALIGN_ADDRESS(buf, amt) G_STMT_START { \
+guchar *newval; \
+newval = ALIGN_ADDRESS(GIOP_RECV_BUFFER(buf)->cur, amt); \
+CHECK_NEW_POS(buf, newval-((guchar *)GIOP_RECV_BUFFER(buf)->cur)); \
+GIOP_RECV_BUFFER(buf)->cur = newval; \
+} G_STMT_END
+
+#define GET_ULONG(x) G_STMT_START{					\
+                (x) = GUINT32_SWAP_LE_BE((*(CORBA_unsigned_long *)buf->cur)); \
+                CHECK_NEW_POS(buf, sizeof(CORBA_unsigned_long));        \
+		buf->cur = ((guchar *)buf->cur) + sizeof(CORBA_unsigned_long);	\
+	}G_STMT_END
+
+#define GET_ULONG_NC(x) G_STMT_START{ \
+			*(x) = (*((CORBA_unsigned_long *)(buf->cur))); \
+                        CHECK_NEW_POS(buf, sizeof(CORBA_unsigned_long)); \
+			buf->cur = ((guchar *)buf->cur) + sizeof(CORBA_unsigned_long); \
+		}G_STMT_END
+
+/* There be dragons in here. */
+static gint
+giop_recv_reply_decode_message(GIOPRecvBuffer *buf)
+{
+  /*
+	  enum ReplyStatusType {
+		NO_EXCEPTION,
+		USER_EXCEPTION,
+		SYSTEM_EXCEPTION,
+		LOCATION_FORWARD
+	};
+
+	struct ReplyHeader {
+		IOP::ServiceContextList service_context;
+		unsigned long request_id;
+		ReplyStatusType reply_status;
+	};
+  */
+  int i;
+
+  buf->message.u.reply.service_context._maximum = 0;
+  if(giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(buf))) 
+    {
+      GET_ULONG(buf->message.u.reply.service_context._length);
+/* XXX bad hardcoded hack until someone gives a "right answer" to how to
+solve this problem */
+      if(buf->message.u.reply.service_context._length > 128) return -1;
+      buf->message.u.reply.service_context._buffer =
+	g_new(IOP_ServiceContext, buf->message.u.reply.service_context._length);
+
+      for(i = 0; i < buf->message.u.reply.service_context._length; i++)
+	{
+	  SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+	  GET_ULONG(buf->message.u.reply.service_context._buffer[i].context_id);
+	  GET_ULONG(buf->message.u.reply.service_context._buffer[i].context_data._length);
+	  buf->message.u.reply.service_context._buffer[i].context_data._buffer =
+	    buf->cur;
+	  CHECK_NEW_POS(buf, buf->message.u.reply.service_context._buffer[i].context_data._length);
+	  buf->cur = ((guchar *)buf->cur) + buf->message.u.reply.service_context._buffer[i].context_data._length;
+	}
+      GET_ULONG(buf->message.u.reply.request_id);
+      GET_ULONG(buf->message.u.reply.reply_status);
+    }
+  else
+    {
+
+      GET_ULONG_NC(&buf->message.u.reply.service_context._length);
+/* XXX bad hardcoded hack until someone gives a "right answer" to how to
+solve this problem */
+      if(buf->message.u.reply.service_context._length > 128) return -1;
+      buf->message.u.reply.service_context._buffer =
+	g_new(IOP_ServiceContext, buf->message.u.reply.service_context._length);
+
+      for(i = 0; i < buf->message.u.reply.service_context._length; i++)
+	{
+	  SAFE_ALIGN_ADDRESS(buf, sizeof(CORBA_unsigned_long));
+	  GET_ULONG_NC(&buf->message.u.reply.service_context._buffer[i].context_id);
+	  GET_ULONG_NC(&buf->message.u.reply.service_context._buffer[i].context_data._length);
+	  buf->message.u.reply.service_context._buffer[i].context_data._buffer =
+	    buf->cur;
+	  CHECK_NEW_POS(buf, buf->message.u.reply.service_context._buffer[i].context_data._length);
+	  buf->cur = ((guchar *)buf->cur) + buf->message.u.reply.service_context._buffer[i].context_data._length;
+	}
+      GET_ULONG_NC(&buf->message.u.reply.request_id);
+      GET_ULONG_NC(&buf->message.u.reply.reply_status);
+    }
+
+#if 0
+  g_message("[%d] Received reply %d size %d to request %d",
+	    getpid(),
+	    buf->message.u.reply.reply_status,
+	    GIOP_MESSAGE_BUFFER(buf)->message_header.message_size,
+	    buf->message.u.reply.request_id);
+#endif
+
+  return 0;
+
+  NEW_POS_OUT;
+}
+
+static gint
+giop_recv_locate_reply_decode_message(GIOPRecvBuffer *buf)
+{
+  if(giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(buf))) 
+    {
+      GET_ULONG(buf->message.u.locate_reply.request_id);
+      GET_ULONG(buf->message.u.locate_reply.locate_status);
+    }
+  else
+    {
+      GET_ULONG_NC(&buf->message.u.locate_reply.request_id);
+      GET_ULONG_NC(&buf->message.u.locate_reply.locate_status);
+    }
+
+  return 0;
+  NEW_POS_OUT;
+}
+
+static gint
+giop_recv_request_decode_message(GIOPRecvBuffer *buf)
+{
+  GIOP_unsigned_long len;
+  int i;
+
+  buf->message.u.request.service_context._maximum = 0;
+  if(giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(buf))) 
+    {
+      GET_ULONG(buf->message.u.request.service_context._length);
+
+      /* XXX bad hardcoded hack until someone gives a "right answer"
+	 to how to solve this problem */
+
+      if(buf->message.u.request.service_context._length > 128) return -1;
+      buf->message.u.request.service_context._buffer =
+	g_new(IOP_ServiceContext, buf->message.u.request.service_context._length);
+
+      for(i = 0; i < buf->message.u.request.service_context._length; i++)
+	{
+	  SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+	  GET_ULONG(buf->message.u.request.service_context._buffer[i].context_id);
+	  GET_ULONG(buf->message.u.request.service_context._buffer[i].context_data._length);
+	  buf->message.u.request.service_context._buffer[i].context_data._buffer =
+	    buf->cur;
+	  CHECK_NEW_POS(buf, buf->message.u.request.service_context._buffer[i].context_data._length);
+	  buf->cur = ((guchar *)buf->cur) + buf->message.u.request.service_context._buffer[i].context_data._length;
+	}
+
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG(buf->message.u.request.request_id);
+      buf->message.u.request.response_expected = *((GIOP_boolean *)buf->cur);
+      CHECK_NEW_POS(buf, sizeof(GIOP_boolean));
+      buf->cur = ((guchar *)buf->cur) + sizeof(GIOP_boolean);
+
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG(buf->message.u.request.object_key._length);
+      buf->message.u.request.object_key._buffer = buf->cur;
+
+      CHECK_NEW_POS(buf, buf->message.u.request.object_key._length);
+      buf->cur = ((guchar *)buf->cur) + buf->message.u.request.object_key._length;
+
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG(len);
+      buf->message.u.request.operation = buf->cur;
+
+      CHECK_NEW_POS(buf, len);
+      buf->cur = ((guchar *)buf->cur) + len;
+
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG(buf->message.u.request.requesting_principal._length);
+      buf->message.u.request.requesting_principal._buffer = buf->cur;
+
+      CHECK_NEW_POS(buf, buf->message.u.request.requesting_principal._length);
+      buf->cur = ((guchar *)buf->cur) + buf->message.u.request.requesting_principal._length;
+    }
+  else
+    {
+      GET_ULONG_NC(&buf->message.u.request.service_context._length);
+
+      /* XXX bad hardcoded hack until someone gives a "right answer"
+	 to how to solve this problem */
+      if(buf->message.u.request.service_context._length > 128) return -1;
+      buf->message.u.request.service_context._buffer =
+	g_new(IOP_ServiceContext, buf->message.u.request.service_context._length);
+
+      for(i = 0; i < buf->message.u.request.service_context._length; i++)
+	{
+	  SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+	  GET_ULONG_NC(&buf->message.u.request.service_context._buffer[i].context_id);
+	  GET_ULONG_NC(&buf->message.u.request.service_context._buffer[i].context_data._length);
+	  buf->message.u.request.service_context._buffer[i].context_data._buffer =
+	    buf->cur;
+	  CHECK_NEW_POS(buf, buf->message.u.request.service_context._buffer[i].context_data._length);
+	  buf->cur = ((guchar *)buf->cur) + buf->message.u.request.service_context._buffer[i].context_data._length;
+	}
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG_NC(&buf->message.u.request.request_id);
+      buf->message.u.request.response_expected = *((GIOP_boolean *)buf->cur);
+      CHECK_NEW_POS(buf, sizeof(GIOP_boolean));
+      buf->cur = ((guchar *)buf->cur) + sizeof(GIOP_boolean);
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG_NC(&buf->message.u.request.object_key._length);
+      buf->message.u.request.object_key._buffer = buf->cur;
+      CHECK_NEW_POS(buf, buf->message.u.request.object_key._length);
+      buf->cur = ((guchar *)buf->cur) + buf->message.u.request.object_key._length;
+
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG_NC(&len);
+      buf->message.u.request.operation = buf->cur;
+      CHECK_NEW_POS(buf, len);
+      buf->cur = ((guchar *)buf->cur) + len;
+
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG_NC(&buf->message.u.request.requesting_principal._length);
+      buf->message.u.request.requesting_principal._buffer = buf->cur;
+      CHECK_NEW_POS(buf, buf->message.u.request.requesting_principal._length);
+      buf->cur = ((guchar *)buf->cur) + buf->message.u.request.requesting_principal._length;
+    }
+
+#if 0
+  g_message("[%d] Received request %s size %d ID %d",
+	    getpid(),
+	    buf->message.u.request.operation,
+	    GIOP_MESSAGE_BUFFER(buf)->message_header.message_size,
+	    buf->message.u.request.request_id);
+#endif
+
+  return 0;
+
+  NEW_POS_OUT;
+}
+
+static gint
+giop_recv_locate_request_decode_message(GIOPRecvBuffer *buf)
+{
+  if(giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(buf))) 
+    {
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG(buf->message.u.locate_request.request_id);
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG(buf->message.u.locate_request.object_key._length);
+      buf->message.u.locate_request.object_key._buffer = buf->cur;
+      CHECK_NEW_POS(buf, buf->message.u.locate_request.object_key._length);
+      buf->cur = ((guchar *)buf->cur) + buf->message.u.locate_request.object_key._length;
+    }
+  else
+    {
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG_NC(&buf->message.u.locate_request.request_id);
+      SAFE_ALIGN_ADDRESS(buf, sizeof(GIOP_unsigned_long));
+      GET_ULONG_NC(&buf->message.u.locate_request.object_key._length);
+      buf->message.u.locate_request.object_key._buffer = buf->cur;
+      CHECK_NEW_POS(buf, buf->message.u.locate_request.object_key._length);
+      buf->cur = ((guchar *)buf->cur) + buf->message.u.locate_request.object_key._length;
+    }
+
+  return 0;
+
+  NEW_POS_OUT;
+}
+
+gboolean
+num_on_list(GIOP_unsigned_long num,
+	    const GIOP_unsigned_long *request_ids,
+	    GIOP_unsigned_long req_count)
+{
+  int i;
+  for(i = 0; i < req_count; i++)
+    {
+      if(num == request_ids[i])
+	return TRUE;
+    }
+
+  return FALSE;
+}
diff -urN linux-2.4.1/net/korbit/IIOP/giop-msg-buffer.h linux-2.4.1-korbit/net/korbit/IIOP/giop-msg-buffer.h
--- linux-2.4.1/net/korbit/IIOP/giop-msg-buffer.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/giop-msg-buffer.h	Thu Feb  1 16:19:47 2001
@@ -0,0 +1,228 @@
+#ifndef GIOP_MSG_BUFFER_H
+#define GIOP_MSG_BUFFER_H 1
+
+#include "IIOP.h"
+/* For struct iovec */
+#include <sys/uio.h>
+
+typedef enum {
+  GIOP_REQUEST,
+  GIOP_REPLY,
+  GIOP_CANCELREQUEST,
+  GIOP_LOCATEREQUEST,
+  GIOP_LOCATEREPLY,
+  GIOP_CLOSECONNECTION,
+  GIOP_MESSAGEERROR,
+  GIOP_FRAGMENT
+} GIOPMsgType;
+
+/* GIOP message header */
+typedef struct _GIOPMessageHeader {
+  GIOP_char magic[4];
+  GIOP_char GIOP_version[2];
+  GIOP_octet flags;
+
+  /*
+   * We should really use GIOPMsgType
+   * but that enum winds up being an int...
+   */
+  GIOP_octet message_type;
+
+  GIOP_unsigned_long message_size;
+} GIOPMessageHeader;
+
+#define GIOP_MESSAGE_BUFFER(x) ((GIOPMessageBuffer *)x)
+typedef struct _GIOPMessageBuffer
+{
+  /* The connection that this message will go out over... */
+  GIOPConnection *connection; 
+				 
+  GArray *iovecs;
+  GIOPMessageHeader message_header;
+} GIOPMessageBuffer;
+
+#include "../orb/iop.h"
+
+/* GIOP_REQUEST header */
+typedef enum {
+  GIOP_NO_EXCEPTION,
+  GIOP_USER_EXCEPTION,
+  GIOP_SYSTEM_EXCEPTION,
+  GIOP_LOCATION_FORWARD
+} GIOPReplyStatusType;
+
+typedef struct _GIOPMessageRequest {
+  IOP_ServiceContextList service_context;
+  GIOP_unsigned_long request_id;
+  GIOP_boolean response_expected;
+  CORBA_sequence_octet object_key;
+  CORBA_char *operation;
+  CORBA_Principal requesting_principal;
+} GIOPMessageRequest;
+
+typedef struct _GIOPMessageReply {
+  IOP_ServiceContextList service_context;
+  GIOP_unsigned_long request_id;
+  GIOPReplyStatusType reply_status;
+} GIOPMessageReply;
+
+typedef struct _GIOPMessageCancelRequest {
+  GIOP_unsigned_long request_id;
+} GIOPMessageCancelRequest;
+
+typedef struct _GIOPMessageLocateRequest {
+  GIOP_unsigned_long request_id;
+  CORBA_sequence_octet object_key;
+} GIOPMessageLocateRequest;
+
+typedef enum {
+  GIOP_UNKNOWN_OBJECT,
+  GIOP_OBJECT_HERE,
+  GIOP_OBJECT_FORWARD
+} GIOPLocateStatusType;
+
+typedef struct _GIOPMessageLocateReply {
+  GIOP_unsigned_long request_id;
+  GIOPLocateStatusType locate_status;
+} GIOPMessageLocateReply;
+
+typedef struct _GIOPMessage
+{
+  union {
+    GIOPMessageRequest request;
+    GIOPMessageReply reply;
+    GIOPMessageCancelRequest cancel_request;
+    GIOPMessageLocateRequest locate_request;
+    GIOPMessageLocateReply locate_reply;
+  } u;
+} GIOPMessage;
+
+typedef enum {
+  GIOP_MSG_READING_HEADER,
+  GIOP_MSG_READING_BODY,
+  GIOP_MSG_READY
+} GIOPMessageBufferState;
+
+#define GIOP_SEND_BUFFER(x) ((GIOPSendBuffer *)x)
+typedef struct _GIOPSendBuffer
+{
+  GIOPMessageBuffer message_buffer;
+
+  gpointer indirect;
+
+  GMemChunk *indirects; /* Request buffers only (at present) */
+  gulong indirect_used;
+
+  GIOPMessage message;
+  CORBA_unsigned_long scontext_tmp;
+} GIOPSendBuffer;
+
+#define GIOP_RECV_BUFFER(x) ((GIOPRecvBuffer *)x)
+typedef struct _GIOPRecvBuffer
+{
+  GIOPMessageBuffer message_buffer;
+  GIOPMessage message;
+
+  gpointer message_body;
+  gpointer cur;
+
+  void (*decoder)(gpointer dest, gpointer src, gulong len);
+
+  GIOPMessageBufferState state;
+  gint left_to_read;
+} GIOPRecvBuffer;
+
+/* This function needs to be called before useful things happen */
+void giop_message_buffer_init(void);
+
+gint giop_send_buffer_write(GIOPSendBuffer *request_buffer);
+
+void 
+giop_message_buffer_append_mem_a(GIOPMessageBuffer *request_buffer,
+				 gconstpointer mem_region,
+				 gulong mem_region_length);
+void 
+giop_message_buffer_append_mem(GIOPMessageBuffer *request_buffer,
+			       gconstpointer mem_region,
+			       gulong mem_region_length);
+
+/*
+ * This copies the value into a request-specific buffer before
+ * adding it to the list
+ */
+gpointer
+giop_send_buffer_append_mem_indirect_a(GIOPSendBuffer *request_buffer,
+				       gconstpointer mem_region,
+				       gulong mem_region_length);
+gpointer
+giop_send_buffer_append_mem_indirect(GIOPSendBuffer *request_buffer,
+				     gconstpointer mem_region,
+				     gulong mem_region_length);
+
+GIOPSendBuffer *
+giop_send_request_buffer_use(GIOPConnection *connection,
+			     const IOP_ServiceContextList *service_context,
+			     GIOP_unsigned_long request_id,
+			     GIOP_boolean response_expected,
+			     const struct iovec *object_key_vec,
+			     const struct iovec *operation_vec,
+			     const struct iovec *principal_vec);
+GIOPSendBuffer *
+giop_send_reply_buffer_use(GIOPConnection *connection,
+			   const IOP_ServiceContextList *service_context,
+			   GIOP_unsigned_long request_id,
+			   GIOPReplyStatusType reply_status);
+GIOPSendBuffer *
+giop_send_locate_request_buffer_use(GIOPConnection *connection,
+			     GIOP_unsigned_long request_id,
+			     const struct iovec *object_key_vec);
+GIOPSendBuffer *
+giop_send_locate_reply_buffer_use(GIOPConnection *connection,
+			   GIOP_unsigned_long request_id,
+			   GIOPLocateStatusType reply_status);
+
+void giop_send_buffer_unuse(GIOPSendBuffer *send_buffer);
+
+GIOP_unsigned_long giop_get_request_id(void);
+
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use(GIOP_unsigned_long request_id,
+			   gboolean block_for_reply);
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use_2(GIOPConnection *request_cnx,
+			     GIOP_unsigned_long request_id,
+			     gboolean block_for_reply);
+
+/* For DII - hands back the first received request matching an id on the list */
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use_multiple(GArray *request_ids,
+				    gboolean block_for_reply);
+GIOPRecvBuffer *
+giop_recv_reply_buffer_use_multiple_2(GIOPConnection *request_cnx,
+				      GArray *request_ids,
+				      gboolean block_for_reply);
+
+GIOPRecvBuffer *
+giop_recv_locate_reply_buffer_use(GIOP_unsigned_long request_id,
+				  gboolean block_for_reply);
+
+/*
+ * For server-side use. It's the responsibility of the caller to do
+ * any select()ion desired
+ */
+GIOPRecvBuffer *
+giop_recv_message_buffer_use(GIOPConnection *connection);
+
+void giop_recv_buffer_unuse(GIOPRecvBuffer *buffer);
+
+/*
+ * This is used for sending (and recving, if we ever
+ *  get zero-copy receives implemented) alignment bytes
+ */ 
+extern char giop_scratch_space[2048];
+gulong giop_message_buffer_do_alignment(GIOPMessageBuffer *buffer,
+					gulong align_for);
+
+#define giop_msg_conversion_needed(msgbuf) (conversion_needed(GIOP_MESSAGE_BUFFER(msgbuf)->message_header.flags & 1))
+
+#endif /* GIOP_MSG_BUFFER_H */
diff -urN linux-2.4.1/net/korbit/IIOP/iiop-encoders.h linux-2.4.1-korbit/net/korbit/IIOP/iiop-encoders.h
--- linux-2.4.1/net/korbit/IIOP/iiop-encoders.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/iiop-encoders.h	Thu Feb  1 11:46:51 2001
@@ -0,0 +1,25 @@
+#ifndef ENCODERS_H
+#define ENCODERS_H 1
+
+#define ENCODER_DEC(typename) \
+void giop_encoder_##typename##(GIOPSendBuffer *send_buffer, \
+			       const typename *mem)
+
+#define ENCODER_CALL(typename, mem) \
+giop_encoder_##typename##(send_buffer, mem)
+
+#define AP(m, l) giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(send_buffer), m, l)
+#define APA(m, l) giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(send_buffer), m, l)
+
+#define API(m, l) giop_send_buffer_append_mem_indirect(send_buffer, m, l)
+#define APIA(m, l) giop_send_buffer_append_mem_indirect_a(send_buffer, m, l)
+
+ENCODER_DEC(IOP_ServiceContext);
+ENCODER_DEC(IOP_ServiceContextList);
+ENCODER_DEC(CORBA_sequence_octet);
+ENCODER_DEC(CORBA_Principal);
+#define giop_encoder_CORBA_Principal(rb, mem) \
+	giop_encoder_CORBA_sequence_octet(rb, mem)
+ENCODER_DEC(CORBA_char);
+
+#endif /* ENCODERS_H */
diff -urN linux-2.4.1/net/korbit/IIOP/iiop-endian.c linux-2.4.1-korbit/net/korbit/IIOP/iiop-endian.c
--- linux-2.4.1/net/korbit/IIOP/iiop-endian.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/iiop-endian.c	Thu Feb  1 11:46:51 2001
@@ -0,0 +1,12 @@
+#define IIOP_DO_NOT_INLINE_IIOP_BYTESWAP
+#include "iiop-endian.h"
+
+void iiop_byteswap(guchar *outdata,
+		   const guchar *data,
+		   gulong datalen)
+{
+  const guchar *source_ptr = data;
+  guchar *dest_ptr = (guchar *)outdata + datalen - 1;
+  while(dest_ptr >= outdata)
+    *dest_ptr-- = *source_ptr++;
+}
diff -urN linux-2.4.1/net/korbit/IIOP/iiop-endian.h linux-2.4.1-korbit/net/korbit/IIOP/iiop-endian.h
--- linux-2.4.1/net/korbit/IIOP/iiop-endian.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/iiop-endian.h	Thu Feb  1 11:46:51 2001
@@ -0,0 +1,42 @@
+#ifndef IIOP_ENDIAN_H
+#define IIOP_ENDIAN_H 1
+
+#include <glib.h>
+
+#if G_BYTE_ORDER == G_BIG_ENDIAN
+
+# define FLAG_ENDIANNESS FLAG_BIG_ENDIAN
+# define conversion_needed(to_endianness) ((to_endianness)!=FLAG_BIG_ENDIAN)
+
+#elif G_BYTE_ORDER == G_LITTLE_ENDIAN
+
+# define FLAG_ENDIANNESS FLAG_LITTLE_ENDIAN
+# define conversion_needed(to_endianness) ((to_endianness)!=FLAG_LITTLE_ENDIAN)
+
+#else
+
+#error "Unsupported endianness on this system."
+
+#endif
+
+#define FLAG_BIG_ENDIAN 0
+#define FLAG_LITTLE_ENDIAN 1
+
+/* This is also defined in IIOP-types.c */
+void iiop_byteswap(guchar *outdata,
+		   const guchar *data,
+		   gulong datalen);
+
+#if defined(G_CAN_INLINE) && !defined(IIOP_DO_NOT_INLINE_IIOP_BYTESWAP)
+G_INLINE_FUNC void iiop_byteswap(guchar *outdata,
+				 const guchar *data,
+				 gulong datalen)
+{
+  const guchar *source_ptr = data;
+  guchar *dest_ptr = outdata + datalen - 1;
+  while(dest_ptr >= outdata)
+    *dest_ptr-- = *source_ptr++;
+}
+#endif
+
+#endif
diff -urN linux-2.4.1/net/korbit/IIOP/iiop-endianP.h linux-2.4.1-korbit/net/korbit/IIOP/iiop-endianP.h
--- linux-2.4.1/net/korbit/IIOP/iiop-endianP.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/IIOP/iiop-endianP.h	Thu Feb  1 16:19:47 2001
@@ -0,0 +1,11 @@
+#ifndef IIOP_ENDIANP_H
+#define IIOP_ENDIANP_H 1
+
+/* This is pretty much "here" */
+
+#include "config.h"
+#include "IIOP.h"
+
+#include "iiop-endian.h"
+
+#endif /* !IIOP_ENDIANP_H */
diff -urN linux-2.4.1/net/korbit/Makefile linux-2.4.1-korbit/net/korbit/Makefile
--- linux-2.4.1/net/korbit/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/Makefile	Thu Feb  1 15:57:33 2001
@@ -0,0 +1,22 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := korbit.o
+
+subdir-y := kglib orb IIOP ORBitutil modules
+subdir-m := modules
+
+obj-y := kglib/kglib.o orb/orblib.o IIOP/IIOPlib.o ORBitutil/ORBitutillib.o exported_symbols.o
+
+export-objs := exported_symbols.o
+
+EXTRA_CFLAGS = -D__KORBIT__ -DHAVE_CONFIG_H -I. -I./include -I./kglib -I./ORBitutil -nostdinc
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/ORBitutil/CVS/Entries linux-2.4.1-korbit/net/korbit/ORBitutil/CVS/Entries
--- linux-2.4.1/net/korbit/ORBitutil/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/CVS/Entries	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,13 @@
+/Makefile/1.4/Thu Feb  1 09:46:52 2001//
+/basic_types.h/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/compat.c/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/compat.h/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/orbit-os-config.h/1.2/Thu Feb  1 09:46:52 2001//
+/os-feature-alloca.h/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/os-specifics.h/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/thread-safety.c/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/thread-safety.h/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/trace.c/1.2/Thu Feb  1 09:46:52 2001//
+/trace.h/1.1.1.1/Thu Feb  1 09:46:52 2001//
+/util.h/1.1.1.1/Thu Feb  1 09:46:52 2001//
+D
diff -urN linux-2.4.1/net/korbit/ORBitutil/CVS/Repository linux-2.4.1-korbit/net/korbit/ORBitutil/CVS/Repository
--- linux-2.4.1/net/korbit/ORBitutil/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/CVS/Repository	Thu Feb  1 11:46:51 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/ORBitutil
diff -urN linux-2.4.1/net/korbit/ORBitutil/CVS/Root linux-2.4.1-korbit/net/korbit/ORBitutil/CVS/Root
--- linux-2.4.1/net/korbit/ORBitutil/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/CVS/Root	Thu Feb  1 11:46:51 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/ORBitutil/Makefile linux-2.4.1-korbit/net/korbit/ORBitutil/Makefile
--- linux-2.4.1/net/korbit/ORBitutil/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/Makefile	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,17 @@
+#
+# Makefile for KORBit/ORBitutil
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .o file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := ORBitutillib.o
+
+#obj-m := $(O_TARGET)
+obj-y := compat.o thread-safety.o trace.o
+
+EXTRA_CFLAGS = -D__KORBIT__ -DHAVE_CONFIG_H -I. -I.. -I../include -I../kglib -I../ORBitutil -nostdinc
+
+include $(TOPDIR)/Rules.make
diff -urN linux-2.4.1/net/korbit/ORBitutil/basic_types.h linux-2.4.1-korbit/net/korbit/ORBitutil/basic_types.h
--- linux-2.4.1/net/korbit/ORBitutil/basic_types.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/basic_types.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,46 @@
+#ifndef BASIC_TYPES_H
+#define BASIC_TYPES_H 1
+
+#include <glib.h>
+
+typedef gint16 CORBA_short;
+typedef gint32 CORBA_long;
+typedef guint16 CORBA_unsigned_short;
+typedef guint32 CORBA_unsigned_long;
+typedef gfloat CORBA_float;
+typedef gdouble CORBA_double;
+typedef char CORBA_char;
+typedef guchar CORBA_boolean;
+typedef guchar CORBA_octet;
+typedef gdouble CORBA_long_double;
+typedef guint16 CORBA_wchar; /* I'm not sure what size a wchar is supposed to be */
+
+/* Just a peeve */
+typedef CORBA_char GIOP_char;
+typedef CORBA_wchar GIOP_wchar;
+typedef CORBA_short GIOP_short;
+typedef CORBA_long GIOP_long;
+typedef CORBA_unsigned_short GIOP_unsigned_short;
+typedef CORBA_unsigned_long GIOP_unsigned_long;
+typedef CORBA_octet GIOP_octet;
+typedef CORBA_long GIOP_enum;
+typedef CORBA_boolean GIOP_boolean;
+typedef CORBA_float GIOP_float;
+typedef CORBA_double GIOP_double;
+typedef CORBA_long_double GIOP_long_double;
+
+#ifdef G_HAVE_GINT64
+#define HAVE_CORBA_LONG_LONG
+/* According to the spec, these two are optional. We support them if we can. */
+typedef gint64 CORBA_long_long;
+typedef guint64 CORBA_unsigned_long_long;
+typedef CORBA_long_long GIOP_long_long;
+typedef CORBA_unsigned_long_long GIOP_unsigned_long_long;
+#else
+#warning ""
+#warning "You don't G_HAVE_GINT64 defined in glib."
+#warning "Please make sure you don't have an old glibconfig.h lying around."
+#warning ""
+#endif
+
+#endif
diff -urN linux-2.4.1/net/korbit/ORBitutil/compat.c linux-2.4.1-korbit/net/korbit/ORBitutil/compat.c
--- linux-2.4.1/net/korbit/ORBitutil/compat.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/compat.c	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,43 @@
+#include "config.h"
+#include "util.h"
+
+#define MAX_IOVS 16
+
+int g_writev(int fd, const struct  iovec *  vector,  size_t count)
+{
+  int retval = 0;
+
+  while(count > MAX_IOVS) {
+    retval += writev(fd, vector, MAX_IOVS);
+    vector += MAX_IOVS; count -= MAX_IOVS;
+  }
+
+  return writev(fd, vector, count) + retval;
+}
+
+#ifndef HAVE_INET_ATON
+#include <netinet/in.h>
+#include <string.h>
+int inet_aton(const char *cp, struct in_addr *inp)
+{
+	union {
+		unsigned int n;
+		char parts[4];
+	} u;
+	int a=0,b=0,c=0,d=0, i;
+
+	i = sscanf(cp, "%d.%d.%d.%d%*s", &a, &b, &c, &d);
+
+	if(i != 4)
+		return 0;
+
+	u.parts[0] = a;
+	u.parts[1] = b;
+	u.parts[2] = c;
+	u.parts[3] = d;
+
+	inp->s_addr = u.n;
+
+	return 1;
+}
+#endif
diff -urN linux-2.4.1/net/korbit/ORBitutil/compat.h linux-2.4.1-korbit/net/korbit/ORBitutil/compat.h
--- linux-2.4.1/net/korbit/ORBitutil/compat.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/compat.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,8 @@
+#ifndef ORBITUTIL_COMPAT_H
+#define ORBITUTIL_COMPAT_H 1
+#include <sys/types.h>
+#include <sys/uio.h>
+
+int g_writev(int fd, const struct  iovec *  vector,  size_t count);
+
+#endif /*#define ORBITUTIL_COMPAT_H 1 */
diff -urN linux-2.4.1/net/korbit/ORBitutil/orbit-os-config.h linux-2.4.1-korbit/net/korbit/ORBitutil/orbit-os-config.h
--- linux-2.4.1/net/korbit/ORBitutil/orbit-os-config.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/orbit-os-config.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,8 @@
+#ifndef OS_CONFIG_H
+#define OS_CONFIG_H 1
+
+#ifndef __KORBIT__
+#define ORBIT_HAVE_ALLOCA_H 1
+#endif
+
+#endif
diff -urN linux-2.4.1/net/korbit/ORBitutil/os-feature-alloca.h linux-2.4.1-korbit/net/korbit/ORBitutil/os-feature-alloca.h
--- linux-2.4.1/net/korbit/ORBitutil/os-feature-alloca.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/os-feature-alloca.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,26 @@
+#ifndef OS_FEATURE_ALLOCA_H
+#define OS_FEATURE_ALLOCA_H 1
+
+#  if ORBIT_HAVE_ALLOCA_H
+#  include <alloca.h>
+#  endif
+
+#  include <string.h>
+
+#  if defined(__GNUC__)
+
+#    if defined(__STRICT_ANSI__)
+#      define alloca __builtin_alloca
+#    endif
+
+#  elif !(ORBIT_HAVE_ALLOCA_H)
+
+#    if defined(_AIX)
+ #pragma alloca
+#    elif !defined(alloca) /* predefined by HP cc +Olibcalls */
+char *alloca ();
+#    endif
+
+#  endif /* __GNUC__ etc. */
+
+#endif /* OS_FEATURE_ALLOCA_H */
diff -urN linux-2.4.1/net/korbit/ORBitutil/os-specifics.h linux-2.4.1-korbit/net/korbit/ORBitutil/os-specifics.h
--- linux-2.4.1/net/korbit/ORBitutil/os-specifics.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/os-specifics.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,12 @@
+#ifndef ORBITUTIL_OS_SPECIFICS_H
+#define ORBITUTIL_OS_SPECIFICS_H 1
+
+#include <ORBitutil/orbit-os-config.h>
+
+#include <ORBitutil/os-feature-alloca.h>
+
+/* This file should be a bunch of #ifdef's to #include the
+   os-<osname>.h for the current OS.  It is intended to abstract the
+   gunkiness necessary to get some OS's to build ORBit properly. */
+
+#endif
diff -urN linux-2.4.1/net/korbit/ORBitutil/thread-safety.c linux-2.4.1-korbit/net/korbit/ORBitutil/thread-safety.c
--- linux-2.4.1/net/korbit/ORBitutil/thread-safety.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/thread-safety.c	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,19 @@
+#include "util.h"
+
+#ifdef NOT_REENTRANT
+#include <pthread.h>
+
+pthread_key_t thread_data;
+
+void init_thread_data(void) __attribute__ ((constructor));
+
+void init_thread_data(void)
+{
+  pthread_key_create(&thread_data, NULL);
+}
+
+#else
+
+gpointer prog_data = NULL;
+
+#endif
diff -urN linux-2.4.1/net/korbit/ORBitutil/thread-safety.h linux-2.4.1-korbit/net/korbit/ORBitutil/thread-safety.h
--- linux-2.4.1/net/korbit/ORBitutil/thread-safety.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/thread-safety.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,36 @@
+#ifndef THREAD_SAFETY_H
+#define THREAD_SAFETY_H 1
+
+#ifdef NOT_REENTRANT
+
+#include <pthread.h>
+
+#define DEFINE_LOCK(x) pthread_mutex_t x##_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+#define INIT_LOCK(x) /* We use static initialization, see above */
+#define GET_LOCK(x) pthread_mutex_lock(&x##_lock)
+#define RELEASE_LOCK(x) pthread_mutex_unlock(&x##_lock)
+#define PARAM_LOCK(x) pthread_mutex_t x##_lock
+#define LOCK_NAME(x) x##_lock
+#define EXTERN_LOCK(x) extern pthread_mutex_t x##_lock
+extern pthread_key_t thread_data;
+#define GET_THREAD_DATA() pthread_getspecific(thread_data)
+#define SET_THREAD_DATA(x) pthread_setspecific(thread_data, (x))
+
+#else
+
+/* stupid work around ANSI & empty semicolons. */
+#define DEFINE_LOCK(x)
+#define INIT_LOCK(x)
+#define GET_LOCK(x)
+#define RELEASE_LOCK(x)
+#define PARAM_LOCK(x) gpointer x##_lock
+#define LOCK_NAME(x) NULL
+#define EXTERN_LOCK(x)
+
+extern gpointer prog_data;
+#define GET_THREAD_DATA() prog_data
+#define SET_THREAD_DATA(x) (prog_data = (x))
+
+#endif
+
+#endif /* THREAD_SAFETY_H */
diff -urN linux-2.4.1/net/korbit/ORBitutil/trace.c linux-2.4.1-korbit/net/korbit/ORBitutil/trace.c
--- linux-2.4.1/net/korbit/ORBitutil/trace.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/trace.c	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,94 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@acm.org>
+ *
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "trace.h"
+
+/*
+ * The function to call to handle trace messages, or NULL to use the default
+ * of printing to stderr.
+ */
+#ifdef ORBIT_DEBUG
+static int (* TraceCallback)(char *, va_list)=NULL;
+static int TraceModules=0;
+static ORBit_TraceLevel TraceMaxLevel=0;
+
+const char *ORBit_Trace_levellist[] = {
+	"ALERT   ",
+	"CRITICAL",
+	"ERROR   ",
+	"WARNING ",
+	"NOTICE  ",
+	"INFO    ",
+	"DEBUG   "
+};
+
+void ORBit_Trace_setCallback(int (*cbf)(char *, va_list))
+{
+	TraceCallback=cbf;
+}
+
+int (*ORBit_Trace_getCallback(void))(char *, va_list)
+{
+	return(TraceCallback);
+}
+
+void ORBit_Trace_setModules(int modules)
+{
+	TraceModules=modules;
+}
+
+void ORBit_Trace_setLevel(ORBit_TraceLevel level)
+{
+	TraceMaxLevel=level;
+}
+
+int ORBit_Trace(ORBit_TraceModule module, ORBit_TraceLevel level, char *fmt, ...)
+{
+	va_list args;
+
+	if(!BitTest(TraceModules, module))
+		return 0;
+	if(TraceMaxLevel < level)
+		return 0;
+
+	va_start(args, fmt);
+	if(TraceCallback!=NULL)
+		return((*TraceCallback)(fmt, args));
+
+#ifdef __KORBIT__
+	printf("[%s]: ", ORBit_Trace_levellist[level]);
+
+	printf("%s", g_strdup_vprintf(fmt, args));
+	return 0; // breaks semantics, but return value is never used
+#else /* !__KORBIT__ */
+	fprintf(stderr, "[%s]: ", ORBit_Trace_levellist[level]);
+
+	return vfprintf(stderr, fmt, args);
+#endif /* !__KORBIT__ */
+}
+#endif
diff -urN linux-2.4.1/net/korbit/ORBitutil/trace.h linux-2.4.1-korbit/net/korbit/ORBitutil/trace.h
--- linux-2.4.1/net/korbit/ORBitutil/trace.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/trace.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,68 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@acm.org>
+ *
+ */
+
+#ifndef _ORBIT_TRACE_H_
+#define _ORBIT_TRACE_H_
+
+#include <stdarg.h>
+#include "util.h"
+
+typedef enum {
+	TraceMod_ORB,
+	TraceMod_CDR,
+	TraceMod_IIOP,
+	TraceMod_TC,
+	TraceMod_IR,
+	TraceMod_User=32
+} ORBit_TraceModule;
+
+typedef enum {
+	TraceLevel_Alert=0,
+	TraceLevel_Critical,
+	TraceLevel_Error,
+	TraceLevel_Warning,
+	TraceLevel_Notice,
+	TraceLevel_Info,
+	TraceLevel_Debug
+} ORBit_TraceLevel;
+
+extern const char *ORBit_Trace_levellist[];
+
+#ifdef ORBIT_DEBUG
+extern void ORBit_Trace_setCallback(int (*)(char *, va_list));
+extern int (*ORBit_Trace_getCallback(void))(char *, va_list);
+extern void ORBit_Trace_setModules(int);
+extern void ORBit_Trace_setLevel(ORBit_TraceLevel);
+extern int ORBit_Trace(ORBit_TraceModule, ORBit_TraceLevel, char *, ...);
+#else
+#define ORBit_Trace_setCallback(x)
+#define ORBit_Trace_getCallback() NULL
+#define ORBit_Trace_setModules(x)
+#define ORBit_Trace_setLevel(x)
+#define ORBit_Trace(module,level,fmt,args...)
+#endif
+
+
+#endif /* !_ORBIT_TRACE_H_ */
diff -urN linux-2.4.1/net/korbit/ORBitutil/util.h linux-2.4.1-korbit/net/korbit/ORBitutil/util.h
--- linux-2.4.1/net/korbit/ORBitutil/util.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/ORBitutil/util.h	Thu Feb  1 11:46:52 2001
@@ -0,0 +1,35 @@
+#ifndef UTIL_H
+#define UTIL_H 1
+
+#include <glib.h>
+
+#define ORBIT_DEBUG 1
+
+#ifdef ORBIT_DEBUG
+#define ORBIT_DEBUG_NOTE(x) (x)
+#else
+#define ORBIT_DEBUG_NOTE(x)
+#endif
+
+
+#define BitTest(f, bit)  ((f) & (1<<(bit)))
+#define BitSet(f, bit) ((f) |= (1<<(bit)))
+#define BitClr(f, bit) ((f) &= ~(1<<(bit)))
+/* Align an address upward to a boundary, expressed as a number of bytes.
+   E.g. align to an 8-byte boundary with argument of 8.  */
+
+/*
+ *   (this + boundary - 1)
+ *          &
+ *    ~(boundary - 1)
+ */
+
+#define ALIGN_ADDRESS(this, boundary) \
+  ((gpointer)((( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))))
+
+#include <ORBitutil/thread-safety.h>
+#include <ORBitutil/trace.h>
+#include <ORBitutil/compat.h>
+#include <ORBitutil/os-specifics.h>
+
+#endif
diff -urN linux-2.4.1/net/korbit/config.h linux-2.4.1-korbit/net/korbit/config.h
--- linux-2.4.1/net/korbit/config.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/config.h	Thu Feb  1 11:46:49 2001
@@ -0,0 +1,73 @@
+
+/* Define if you have alloca, as a function or macro.  */
+#define HAVE_ALLOCA 1
+
+#define HAVE_ATEXIT 1
+#define NO_SYS_SIGLIST 1  /* reduce dependencies */
+#define NO_SYS_ERRLIST 1  /* reduce dependencies */
+
+/* Define if you have <alloca.h> and it should be used (not on Ultrix).  */
+/* #define HAVE_ALLOCA_H 1 */
+
+/* Define if you have the vprintf function.  */
+#define HAVE_VPRINTF 1
+
+/* Define if you have the ANSI C header files.  */
+#define STDC_HEADERS 1
+
+#define HAVE_INET_ATON 1
+/* #undef ORBIT_SERIAL */
+
+/* Define to 'int' if it isn't defined in the header files. */
+/* #undef socklen_t */
+
+#define  ALIGNOF_CORBA_BOOLEAN 1
+#define  ALIGNOF_CORBA_CHAR 1
+#define  ALIGNOF_CORBA_DOUBLE 4
+#define  ALIGNOF_CORBA_FLOAT 4
+#define  ALIGNOF_CORBA_LONG 4
+#define  ALIGNOF_CORBA_LONG_DOUBLE 4
+#define  ALIGNOF_CORBA_LONG_LONG 4
+#define  ALIGNOF_CORBA_OCTET 1
+#define  ALIGNOF_CORBA_SHORT 2
+#define  ALIGNOF_CORBA_STRUCT 1
+#define  ALIGNOF_CORBA_UNSIGNED_LONG 4
+#define  ALIGNOF_CORBA_UNSIGNED_LONG_LONG 4
+#define  ALIGNOF_CORBA_UNSIGNED_SHORT 2
+#define  ALIGNOF_CORBA_WCHAR 2
+#define  ALIGNOF_CORBA_POINTER 4
+
+/* TCP wrappers */
+#define HAVE_TCPD_H 1
+
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
+
+/* Define if you have the basename function.  */
+#define HAVE_BASENAME 1
+
+/* Define if you have the poll function.  */
+#define HAVE_POLL 1
+#define I_WANT_POLL 1
+
+/* Define if you have the <endian.h> header file.  */
+#define HAVE_ENDIAN_H 1
+
+/* Define if you have the <fcntl.h> header file.  */
+#define HAVE_FCNTL_H 1
+
+/* Define if you have the <stddef.h> header file.  */
+#define HAVE_STDDEF_H 1
+
+/* Define if you have the <sys/poll.h> header file.  */
+#define HAVE_SYS_POLL_H 1
+
+/* Define if you have the <tcpd.h> header file.  */
+#define HAVE_TCPD_H 1
+
+/* Define if you have the <unistd.h> header file.  */
+#define HAVE_UNISTD_H 1
+
+/* Define if you have the <wchar.h> header file.  */
+#define HAVE_WCHAR_H 1
diff -urN linux-2.4.1/net/korbit/exported_symbols.c linux-2.4.1-korbit/net/korbit/exported_symbols.c
--- linux-2.4.1/net/korbit/exported_symbols.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/exported_symbols.c	Thu Feb  1 11:46:49 2001
@@ -0,0 +1,93 @@
+/*
+ * #include whatever it takes to get the EXPORT_SYMBOL macro, and
+ * whatever header files from korbit (for things that are being
+ * exported.
+ */
+#include <linux/config.h>
+#include <linux/module.h>
+#include "errno.h"
+#include "orb/orbit.h"
+
+/* 
+ * Stuff that's good to export
+ */
+EXPORT_SYMBOL(errno);
+
+/* 
+ * kglib exports...
+ */
+EXPORT_SYMBOL(g_malloc0);
+EXPORT_SYMBOL(g_free);
+EXPORT_SYMBOL(g_snprintf);
+
+/*
+ * Mainline CORBA symbols.
+ */
+EXPORT_SYMBOL(CORBA_exception_init);
+EXPORT_SYMBOL(CORBA_ORB_init);
+EXPORT_SYMBOL(CORBA_ORB_resolve_initial_references);
+EXPORT_SYMBOL(CORBA_ORB_object_to_string);
+EXPORT_SYMBOL(CORBA_free);
+EXPORT_SYMBOL(CORBA_ORB_run);
+EXPORT_SYMBOL(CORBA_Object_release);
+EXPORT_SYMBOL(CORBA_Object_duplicate);
+EXPORT_SYMBOL(CORBA_octet_allocbuf);
+EXPORT_SYMBOL(CORBA_exception_set);
+EXPORT_SYMBOL(CORBA_string__free);
+EXPORT_SYMBOL(CORBA_ORB_string_to_object);
+EXPORT_SYMBOL(CORBA_string_alloc);
+EXPORT_SYMBOL(CORBA_exception_set_system);
+
+/* 
+ * ORBIT Specific symbols to export
+ */
+EXPORT_SYMBOL(ORBit_TypeCode_epv);
+EXPORT_SYMBOL(ORBit_send_system_exception);
+EXPORT_SYMBOL(ORBit_register_class);
+EXPORT_SYMBOL(ORBit_marshal_object);
+EXPORT_SYMBOL(ORBit_alloc);
+EXPORT_SYMBOL(ORBit_free);
+EXPORT_SYMBOL(ORBit_send_user_exception);
+EXPORT_SYMBOL(ORBit_delete_profiles);
+EXPORT_SYMBOL(ORBit_demarshal_object);
+EXPORT_SYMBOL(_ORBit_object_get_connection);
+EXPORT_SYMBOL(ORBit_handle_exception);
+EXPORT_SYMBOL(ORBit_object_get_forwarded_connection);
+EXPORT_SYMBOL(ORBit_default_principal_iovec);
+EXPORT_SYMBOL(ORBit_demarshal_IOR);
+
+/*
+ * CORBA giop functions
+ */
+EXPORT_SYMBOL(giop_send_buffer_write);
+EXPORT_SYMBOL(giop_send_buffer_unuse);
+EXPORT_SYMBOL(giop_message_buffer_do_alignment);
+EXPORT_SYMBOL(giop_message_buffer_append_mem);
+EXPORT_SYMBOL(giop_send_reply_buffer_use);
+EXPORT_SYMBOL(giop_send_request_buffer_use);
+EXPORT_SYMBOL(giop_recv_buffer_unuse);
+EXPORT_SYMBOL(giop_recv_reply_buffer_use_2);
+
+/*
+ * POA Symbols.
+ */
+EXPORT_SYMBOL(PortableServer_POAManager_activate);
+EXPORT_SYMBOL(PortableServer_POA_activate_object_with_id);
+EXPORT_SYMBOL(PortableServer_POA_servant_to_reference);
+EXPORT_SYMBOL(PortableServer_POA_deactivate_object);
+EXPORT_SYMBOL(PortableServer_POA__get_the_POAManager);
+EXPORT_SYMBOL(PortableServer_ServantBase__init);
+EXPORT_SYMBOL(PortableServer_ServantBase__fini);
+EXPORT_SYMBOL(PortableServer_POA_reference_to_servant);
+EXPORT_SYMBOL(PortableServer_POA_servant_to_id);
+EXPORT_SYMBOL(PortableServer_POA_activate_object);
+EXPORT_SYMBOL(PortableServer_POA_reference_to_id);
+
+/*
+ * TC Stuff (whatever that is)
+ */
+EXPORT_SYMBOL(TC_octet_struct);
+EXPORT_SYMBOL(TC_long_struct);
+EXPORT_SYMBOL(TC_ulong_struct);
+EXPORT_SYMBOL(TC_short_struct);
+EXPORT_SYMBOL(TC_string_struct);
diff -urN linux-2.4.1/net/korbit/include/.cvsignore linux-2.4.1-korbit/net/korbit/include/.cvsignore
--- linux-2.4.1/net/korbit/include/.cvsignore	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/.cvsignore	Thu Feb  1 11:46:53 2001
@@ -0,0 +1 @@
+stdarg.h
diff -urN linux-2.4.1/net/korbit/include/CVS/Entries linux-2.4.1-korbit/net/korbit/include/CVS/Entries
--- linux-2.4.1/net/korbit/include/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/CVS/Entries	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,24 @@
+/.cvsignore/1.1/Thu Feb  1 09:46:53 2001//
+/alloca.h/1.3/Thu Feb  1 09:46:53 2001//
+/assert.h/1.1.1.1/Thu Feb  1 09:46:53 2001//
+/ctype.h/1.1.1.1/Thu Feb  1 09:46:53 2001//
+/dirent.h/1.1.1.1/Thu Feb  1 09:46:53 2001//
+/errno.h/1.2/Thu Feb  1 09:46:53 2001//
+/fcntl.h/1.3/Thu Feb  1 09:46:53 2001//
+/host_list.h/1.7/Thu Feb  1 09:46:53 2001//
+/limits.h/1.1.1.1/Thu Feb  1 09:46:53 2001//
+/locale.h/1.1.1.1/Thu Feb  1 09:46:53 2001//
+/math.h/1.2/Thu Feb  1 09:46:53 2001//
+/netdb.h/1.17/Thu Feb  1 09:46:53 2001//
+/pwd.h/1.1.1.1/Thu Feb  1 09:46:53 2001//
+/signal.h/1.1.1.1/Thu Feb  1 09:46:53 2001//
+/stdarg.h/1.3/Thu Feb  1 09:46:54 2001//
+/stddef.h/1.1.1.1/Thu Feb  1 09:46:54 2001//
+/stdio.h/1.19/Thu Feb  1 09:46:54 2001//
+/stdlib.h/1.4/Thu Feb  1 09:46:54 2001//
+/string.h/1.3/Thu Feb  1 09:46:54 2001//
+/syslog.h/1.1.1.1/Thu Feb  1 09:46:54 2001//
+/time.h/1.1.1.1/Thu Feb  1 09:46:54 2001//
+/unistd.h/1.3/Thu Feb  1 09:46:54 2001//
+/utime.h/1.1.1.1/Thu Feb  1 09:46:54 2001//
+D
diff -urN linux-2.4.1/net/korbit/include/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/include/CVS/Entries.Log
--- linux-2.4.1/net/korbit/include/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/CVS/Entries.Log	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,3 @@
+A D/arpa////
+A D/netinet////
+A D/sys////
diff -urN linux-2.4.1/net/korbit/include/CVS/Repository linux-2.4.1-korbit/net/korbit/include/CVS/Repository
--- linux-2.4.1/net/korbit/include/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/CVS/Repository	Thu Feb  1 11:46:53 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/include
diff -urN linux-2.4.1/net/korbit/include/CVS/Root linux-2.4.1-korbit/net/korbit/include/CVS/Root
--- linux-2.4.1/net/korbit/include/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/CVS/Root	Thu Feb  1 11:46:53 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/include/alloca.h linux-2.4.1-korbit/net/korbit/include/alloca.h
--- linux-2.4.1/net/korbit/include/alloca.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/alloca.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,6 @@
+#ifndef __KORBIT_ALLOCA_H__
+#define __KORBIT_ALLOCA_H__
+
+#include <stdlib.h>
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/arpa/CVS/Entries linux-2.4.1-korbit/net/korbit/include/arpa/CVS/Entries
--- linux-2.4.1/net/korbit/include/arpa/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/arpa/CVS/Entries	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,2 @@
+/inet.h/1.4/Thu Feb  1 09:46:54 2001//
+D
diff -urN linux-2.4.1/net/korbit/include/arpa/CVS/Repository linux-2.4.1-korbit/net/korbit/include/arpa/CVS/Repository
--- linux-2.4.1/net/korbit/include/arpa/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/arpa/CVS/Repository	Thu Feb  1 11:46:54 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/include/arpa
diff -urN linux-2.4.1/net/korbit/include/arpa/CVS/Root linux-2.4.1-korbit/net/korbit/include/arpa/CVS/Root
--- linux-2.4.1/net/korbit/include/arpa/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/arpa/CVS/Root	Thu Feb  1 11:46:54 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/include/arpa/inet.h linux-2.4.1-korbit/net/korbit/include/arpa/inet.h
--- linux-2.4.1/net/korbit/include/arpa/inet.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/arpa/inet.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,50 @@
+#ifndef __KORBIT_ARPA_INET_H__
+#define __KORBIT_ARPA_INET_H__
+
+#include <linux/inet.h>
+#include <linux/in.h>
+
+static inline char* inet_ntoa(struct in_addr in)
+{
+   return in_ntoa(in.s_addr);
+}
+
+static inline int inet_aton(const char *cp, struct in_addr *inp)
+{
+	unsigned long l;
+	unsigned int val;
+	int i;
+
+        if (!cp || !inp)
+                return 0;
+
+	l = 0;
+	for (i = 0; i < 4; i++) 
+	{
+		l <<= 8;
+		if (*cp != '\0') 
+		{
+			val = 0;
+			while (*cp != '\0' && *cp != '.') 
+			{
+                                if (*cp < '0' || '9' < *cp)
+                                        return 0;
+                                
+				val *= 10;
+				val += *cp - '0';
+				cp++;
+			}
+                        if (val > 255)
+                                return 0;
+                        
+			l |= val;
+			if (*cp != '\0') 
+				cp++;
+		}
+	}
+	inp->s_addr = htonl(l);
+
+        return 1;
+}
+
+#endif /* __KORBIT_ARPA_INET_H__ */
diff -urN linux-2.4.1/net/korbit/include/assert.h linux-2.4.1-korbit/net/korbit/include/assert.h
--- linux-2.4.1/net/korbit/include/assert.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/assert.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_ASSERT_H__
+#define __KORBIT_ASSERT_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/ctype.h linux-2.4.1-korbit/net/korbit/include/ctype.h
--- linux-2.4.1/net/korbit/include/ctype.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/ctype.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,4 @@
+#ifndef __KORBIT_CTYPE_H__
+#define __KORBIT_CTYPE_H__
+#include <linux/ctype.h>
+#endif
diff -urN linux-2.4.1/net/korbit/include/dirent.h linux-2.4.1-korbit/net/korbit/include/dirent.h
--- linux-2.4.1/net/korbit/include/dirent.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/dirent.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_DIRENT_H__
+#define __KORBIT_DIRENT_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/errno.h linux-2.4.1-korbit/net/korbit/include/errno.h
--- linux-2.4.1/net/korbit/include/errno.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/errno.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,9 @@
+#ifndef __KORBIT_ERRNO_H__
+#define __KORBIT_ERRNO_H__
+
+#include <asm/errno.h>
+
+#define errno korbit_errno
+extern int korbit_errno;
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/fcntl.h linux-2.4.1-korbit/net/korbit/include/fcntl.h
--- linux-2.4.1/net/korbit/include/fcntl.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/fcntl.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,49 @@
+#ifndef __KORBIT_FCNTL_H__
+#define __KORBIT_FCNTL_H__
+
+#include <linux/mm.h>
+#include <linux/file.h>
+#include <linux/smp_lock.h>
+
+#include <asm/fcntl.h>
+
+#include <stdio.h>
+
+#define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | FASYNC)
+
+static inline int fcntl(int fd, int cmd, long arg)
+{
+        struct file *filp = fd2file(fd);
+        long err = -EINVAL;
+        
+        switch (cmd)
+        {
+        case F_SETFD:
+        case F_GETFD:
+                err = 0;
+                break;
+        case F_GETFL:
+                if (filp)
+                        err = filp->f_flags;
+                break;
+        case F_SETFL:
+                if (filp)
+                {
+                        lock_kernel();
+
+                        /* required for strict SunOS emulation */
+                        if (O_NONBLOCK != O_NDELAY)
+                          if (arg & O_NDELAY)
+                            arg |= O_NONBLOCK;
+
+                        filp->f_flags = (arg & SETFL_MASK) | 
+                                        (filp->f_flags & ~SETFL_MASK);
+                        err = 0;
+                        unlock_kernel();
+                }
+                break;
+        }
+        return err;
+}
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/host_list.h linux-2.4.1-korbit/net/korbit/include/host_list.h
--- linux-2.4.1/net/korbit/include/host_list.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/host_list.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,24 @@
+/*
+ * A statically-allocated list of Hostnames<->IPv4 addresses.
+ */
+#ifndef __KORBIT_HOST_LIST_H
+#define __KORBIT_HOST_LIST_H
+
+static struct {
+        char *name;
+        char *IP;
+} host_table[] = {
+        {"redefine.dyndns.org", "206.221.225.140"},
+        {"csil-sunb4.cs.uiuc.edu", "128.174.243.204"},
+        {"kazoo.cs.uiuc.edu", "128.174.237.133"},
+        {"opus0.cs.uiuc.edu", "128.174.236.20"},
+        {"wakeland-56.flexabit.net", "64.198.239.56"},
+	{"es-dcl-border1.cso.uiuc.edu", "127.0.0.1"},
+	{"es-dcl-border1", "127.0.0.1"}
+//	{"es-dcl-border1.cso.uiuc.edu", "130.126.112.222"},
+//	{"es-dcl-border1", "130.126.112.222"}
+};
+
+#define __MAX_STATIC_NAMES (sizeof(host_table) / sizeof(host_table[0]))
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/limits.h linux-2.4.1-korbit/net/korbit/include/limits.h
--- linux-2.4.1/net/korbit/include/limits.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/limits.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,7 @@
+#ifndef __KORBIT_LIMITS_H__
+#define __KORBIT_LIMITS_H__
+
+#include <linux/limits.h>
+#include <linux/kernel.h>
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/locale.h linux-2.4.1-korbit/net/korbit/include/locale.h
--- linux-2.4.1/net/korbit/include/locale.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/locale.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_LOCALE_H__
+#define __KORBIT_LOCALE_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/math.h linux-2.4.1-korbit/net/korbit/include/math.h
--- linux-2.4.1/net/korbit/include/math.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/math.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,16 @@
+#ifndef __KORBIT_MATH_H__
+#define __KORBIT_MATH_H__
+
+#include <asm/page.h>
+
+static inline double pow(double x, double y) {
+	double Q = 1.0; 
+	if (y < 0) 
+		BUG();
+/*		return 1.0/pow(x,-y);*/
+	while (y-- > 0)
+		Q *= x;
+	return Q;
+}
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/netdb.h linux-2.4.1-korbit/net/korbit/include/netdb.h
--- linux-2.4.1/net/korbit/include/netdb.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/netdb.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,197 @@
+#ifndef __KORBIT_NETDB_H__
+#define __KORBIT_NETDB_H__
+
+#include <sys/socket.h>
+#include <linux/in.h>
+#include <arpa/inet.h>
+#include "host_list.h"
+
+#define h_errno 0
+/* static int h_errno; */
+
+/* Description of data base entry for a single host.  */
+struct hostent
+{
+  char *h_name;			/* Official name of host.  */
+  char **h_aliases;		/* Alias list.  */
+  int h_addrtype;		/* Host address type.  */
+  socklen_t h_length;		/* Length of address.  */
+  char **h_addr_list;		/* List of addresses from name server.  */
+#define	h_addr	h_addr_list[0]	/* Address, for backward compatibility.  */
+};
+
+/* Is this defined somewhere else? */
+/*struct in_addr {
+	__uint32_t s_addr;
+};*/
+
+/*
+ * Set h_errno?
+ * #define HOST_NOT_FOUND 1
+ * #define TRY_AGAIN 2
+ * #define NO_RECOVERY 3
+ * #define NO_DATA 4
+ */
+static inline struct hostent *gethostbyname (char *host)
+{
+	int c;
+	static struct in_addr tmp_in;
+	static struct hostent ret_host;
+	static char *aliases[2];
+	static char *addrs[2];
+
+	if (host == NULL)
+		{
+		printf ("** gethostbyname() Error: Got NULL parameter! **\n");
+		return (NULL);
+		}
+
+	/*
+	 * The actual lookup.
+	 */
+	for (c = 0; c < __MAX_STATIC_NAMES; c++)
+		{
+			if (host_table[c].name && strncmp (host, host_table[c].name, strlen(host_table[c].name)) == 0)
+				{
+/*				printf ("Name '%s' found at position %d!\n", argv[1], c);*/
+/*				printf ("IP address is: '%s'.\n", IPs[c]);*/
+				break;
+				}
+		}
+
+	if (c == __MAX_STATIC_NAMES)
+		{
+		/* Host not found, return NULL. */
+		return (NULL);
+		}
+	/* else, names[c] is gold! */
+
+	/* make a new hostent, ret_host */
+
+	ret_host.h_addrtype = AF_INET;
+	ret_host.h_aliases = aliases;
+	aliases[0] = host_table[c].name;
+	aliases[1] = NULL;
+	ret_host.h_name = host_table[c].name;
+	if (!inet_aton (host_table[c].IP, &tmp_in))
+		{
+		printf ("** gethostbyname() Error: Invalid IP address in table! **\n");
+		return (NULL);
+		}
+	ret_host.h_addr_list = addrs;
+	addrs[0] = (char *)&tmp_in.s_addr;
+	addrs[1] = NULL;
+	ret_host.h_length = sizeof (tmp_in.s_addr);
+	return (&ret_host);
+} /* End gethostbyname(). */
+
+/*
+ * TODO: getpeername(), gethostbyaddr(), getsockname(), gethostname()
+ * Everything from here-on has been untested (in userland). Buyer beware.
+ */
+static inline struct hostent *gethostbyaddr (const char *addr, int len, int type)
+{
+	struct in_addr tin;
+	char *inp_addr;
+	int c;
+	static struct hostent ret_host;
+	static char *aliases[1];
+	static char *addrs[2];
+	static struct in_addr tmp_in;
+
+
+	if ((type != AF_INET) || (len != 4))
+		{
+		printf ("** gethostbyaddr Error: Don't know how to deal with non-AF_INET addresses! **\n");
+		return (NULL);
+		}
+
+	tin.s_addr = *((__u32 *)addr);
+	inp_addr = inet_ntoa (tin);
+	if (inp_addr == NULL)
+		{
+		/* We got some invalid input, baby. */
+		return (NULL);
+
+		}
+
+	/*
+	 * The actual lookup.
+	 */
+	for (c = 0; c < __MAX_STATIC_NAMES; c++)
+		{
+			if (host_table[c].IP && strncmp (inp_addr, host_table[c].IP, strlen(host_table[c].IP)) == 0)
+				{
+				break;
+				}
+		}
+
+	if (c == __MAX_STATIC_NAMES)
+		{
+		/* Host not found, return NULL. */
+		return (NULL);
+		}
+	/* else, host_table[c].IP is gold! */
+
+	ret_host.h_addrtype = AF_INET;
+	ret_host.h_aliases = aliases;
+	aliases[0] = NULL;
+	ret_host.h_name = host_table[c].name;
+	if (!inet_aton (host_table[c].IP, &tmp_in))
+		{
+		printf ("** gethostbyname() Error: Invalid IP address in table! **\n");
+		return (NULL);
+		}
+	ret_host.h_addr_list = addrs;
+	addrs[0] = (char *)&tmp_in.s_addr;
+	addrs[1] = NULL;
+	ret_host.h_length = sizeof (tmp_in.s_addr);
+	return (&ret_host);	
+} /* End gethostbyaddr(). */
+
+/*
+ * If successful, return 0. Else, return -1 and set errno.
+ * Errors:
+ *    EBADF The argument s is not a valid file descriptor.
+ *
+ *    ENOMEM
+ *          There was insufficient memory available for the opera-
+ *          tion to complete.
+ *
+ *    ENOSR There were insufficient  STREAMS  resources  available
+ *          for the operation to complete.
+ *
+ *    ENOTSOCK
+ *          The argument s is not a socket.
+ */
+static inline int getsockname (int s, struct sockaddr *name, socklen_t *namelen)
+{
+ 	struct socket *sock = fd2sock(s);
+
+	if (sock == NULL)
+	        return -1;
+
+	/*
+	 * getname() wants an 'int *' for the length, will it by this
+	 * 'socklen_t *' business? (even though it is just an 'int *'?).
+	 */
+	if (sock->ops->getname(sock, name, namelen, 0) == 0)
+	        return 0;
+	else
+	    	return -1; /* should normally also set errno */
+} /* End getsockname(). */
+
+static inline int getpeername (int s, struct sockaddr *name, socklen_t *namelen)
+{
+ 	struct socket *sock = fd2sock(s);
+
+	if (sock == NULL)
+	        return -1;
+
+	if (sock->ops->getname(sock, name, namelen, 1) == 0)
+	        return 0;
+	else
+	    	return -1; /* should normally also set errno */
+} /* End getpeername(). */
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/netinet/CVS/Entries linux-2.4.1-korbit/net/korbit/include/netinet/CVS/Entries
--- linux-2.4.1/net/korbit/include/netinet/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/netinet/CVS/Entries	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,2 @@
+/in.h/1.1.1.1/Thu Feb  1 09:46:55 2001//
+D
diff -urN linux-2.4.1/net/korbit/include/netinet/CVS/Repository linux-2.4.1-korbit/net/korbit/include/netinet/CVS/Repository
--- linux-2.4.1/net/korbit/include/netinet/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/netinet/CVS/Repository	Thu Feb  1 11:46:55 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/include/netinet
diff -urN linux-2.4.1/net/korbit/include/netinet/CVS/Root linux-2.4.1-korbit/net/korbit/include/netinet/CVS/Root
--- linux-2.4.1/net/korbit/include/netinet/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/netinet/CVS/Root	Thu Feb  1 11:46:55 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/include/netinet/in.h linux-2.4.1-korbit/net/korbit/include/netinet/in.h
--- linux-2.4.1/net/korbit/include/netinet/in.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/netinet/in.h	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,5 @@
+#ifndef __KORBIT_NETINET_IN_H__
+#define __KORBIT_NETINET_IN_H__
+#include <linux/socket.h>
+#include <linux/in.h>
+#endif
diff -urN linux-2.4.1/net/korbit/include/pwd.h linux-2.4.1-korbit/net/korbit/include/pwd.h
--- linux-2.4.1/net/korbit/include/pwd.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/pwd.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_PWD_H__
+#define __KORBIT_PWD_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/signal.h linux-2.4.1-korbit/net/korbit/include/signal.h
--- linux-2.4.1/net/korbit/include/signal.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/signal.h	Thu Feb  1 11:46:53 2001
@@ -0,0 +1,6 @@
+#ifndef __KORBIT_SIGNAL_H__
+#define __KORBIT_SIGNAL_H__
+
+#include <asm/signal.h>
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/stdarg.h linux-2.4.1-korbit/net/korbit/include/stdarg.h
--- linux-2.4.1/net/korbit/include/stdarg.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/stdarg.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,13 @@
+#ifndef __KORBIT_STDARG_H__
+#define __KORBIT_STDARG_H__
+
+#define ANDY 1
+
+#if FREDRIK
+#include "/usr/lib/gcc-lib/i386-glibc21-linux/egcs-2.91.66/include/stdarg.h"
+#elif CHRIS
+#include "/usr/lib/gcc-lib/i586-mandrake-linux/egcs-2.91.66/include/stdarg.h"
+#elif ANDY
+#include "/usr/lib/gcc-lib/i386-redhat-linux/egcs-2.91.66/include/stdarg.h"
+#endif
+#endif
diff -urN linux-2.4.1/net/korbit/include/stddef.h linux-2.4.1-korbit/net/korbit/include/stddef.h
--- linux-2.4.1/net/korbit/include/stddef.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/stddef.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_STDDEF_H__
+#define __KORBIT_STDDEF_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/stdio.h linux-2.4.1-korbit/net/korbit/include/stdio.h
--- linux-2.4.1/net/korbit/include/stdio.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/stdio.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,402 @@
+#ifndef __KORBIT_STDIO_H__
+#define __KORBIT_STDIO_H__
+
+#include <asm/segment.h>
+#include <asm/uaccess.h>
+#include <linux/smp_lock.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/uio.h>
+#include <linux/dcache.h>
+#include <linux/file.h>
+#include <linux/highuid.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+
+#define KORBIT_DEBUG_WRITING 0
+
+
+#define printf(format,args...) printk(format,##args)
+#define fflush(x)
+
+#define SEEK_SET       0       /* Seek from beginning of file.  */
+#define SEEK_CUR       1       /* Seek from current position.  */
+#define SEEK_END       2       /* Seek from end of file.  */
+
+static inline int unlink(const char *pathname) {
+  printf("KERNEL UNLINK('%s') CALLED!\n", pathname);
+  return -1;
+}
+
+static inline struct file *fd2file(int fd) {
+        if (fd & 1) /* can't convert a socket! */
+                return NULL;
+
+        return (struct file *)(-(fd & ~1));
+}
+
+static inline int open(const char *filename, int flags, int mode) {
+        struct file *RetVal = filp_open(filename, flags, mode);
+        if (IS_ERR(RetVal))
+        {
+                errno = PTR_ERR(RetVal);
+                return -1;
+        }
+        return -(int)RetVal;
+}
+
+static inline int creat(const char *filename, mode_t mode)
+{
+        return open(filename, O_CREAT | O_WRONLY | O_TRUNC, mode);
+}
+
+static inline int lseek(int fd, long offset, int whence)
+{
+        if ((fd & 1) == 1)
+        {
+                printk("KERNEL FSEEK() CALLED ON SOCKET!\n");
+                return -1;
+        }
+        else 
+        {
+                struct file *F = fd2file(fd);
+                loff_t (*fn)(struct file *, loff_t, int);
+                int retval = -1;
+
+                if (whence <= 2) 
+                {
+                        fn = default_llseek;
+                        if (F->f_op && F->f_op->llseek)
+                                fn = F->f_op->llseek;
+                        
+                        lock_kernel();
+                        retval = fn(F, offset, whence);
+                        unlock_kernel();
+                }
+                if (retval < 0)
+                {
+                        errno = -retval;
+                        retval = -1;
+                }
+                return retval;
+        }
+}
+
+
+asmlinkage long sys_newstat(char * filename, struct stat * statbuf);
+static inline int stat(char *filename, struct stat *buf)
+{
+        mm_segment_t oldfs;
+        int retval;
+        
+        oldfs = get_fs(); set_fs(KERNEL_DS); 
+        retval = sys_newstat(filename, buf);
+        set_fs(oldfs);
+        if (retval < 0)
+        {
+                errno = -retval;
+                retval = -1;
+        }
+        return retval;
+}
+
+asmlinkage long sys_newlstat(char * filename, struct stat * statbuf);
+static inline int lstat(char *filename, struct stat *buf)
+{
+        mm_segment_t oldfs;
+        int retval;
+        
+        oldfs = get_fs(); set_fs(KERNEL_DS); 
+        retval = sys_newlstat(filename, buf);
+        set_fs(oldfs);
+        if (retval < 0)
+        {
+                errno = -retval;
+                retval = -1;
+        }
+        return retval;
+}
+
+
+static inline int do_revalidate(struct dentry *dentry)
+{
+        struct inode * inode = dentry->d_inode;
+        if (inode->i_op && inode->i_op->revalidate)
+                return inode->i_op->revalidate(dentry);
+        return 0;
+}
+
+
+static inline int cp_new_stat(struct inode * inode, struct stat * statbuf)
+{
+        struct stat tmp;
+        
+        memset(&tmp, 0, sizeof(tmp));
+        tmp.st_dev = kdev_t_to_nr(inode->i_dev);
+        tmp.st_ino = inode->i_ino;
+        tmp.st_mode = inode->i_mode;
+        tmp.st_nlink = inode->i_nlink;
+        SET_STAT_UID(tmp, inode->i_uid);
+        SET_STAT_GID(tmp, inode->i_gid);
+        tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
+#if BITS_PER_LONG == 32
+        if (inode->i_size > 0x7fffffff)
+                return -EOVERFLOW;
+        else
+#endif  
+        {
+                tmp.st_size = inode->i_size;
+                tmp.st_atime = inode->i_atime;
+                tmp.st_mtime = inode->i_mtime;
+                tmp.st_ctime = inode->i_ctime;
+                
+                tmp.st_blocks = inode->i_blocks;
+                tmp.st_blksize = inode->i_blksize;
+                
+                memcpy(statbuf, &tmp, sizeof(tmp));
+                return 0;
+        }
+}
+
+
+static inline int fstat(int fd, struct stat *buf)
+{
+        if ((fd & 1) == 1)
+        {
+                printk("TODO : FSTAT FOR SOCKETS, DO WE WANT THIS?\n");
+                errno = EBADF;
+                return -1;
+        }
+        else
+        {
+                struct file *file = fd2file(fd);
+                struct dentry *dentry;
+                int retval = -EBADF;
+                
+                if (file) 
+                {
+                        dentry = file->f_dentry;
+                        retval = do_revalidate(dentry);
+                        
+                        if (!retval)
+                                retval =  cp_new_stat(dentry->d_inode, buf);
+                }
+                if (retval < 0)
+                {
+                        errno = -retval;
+                        retval = -1;
+                }
+                return retval;
+        }
+}
+
+
+asmlinkage long sys_readlink(const char * path, char * buf, int bufsiz);
+static inline int readlink(const char *path, char *buf, size_t bufsiz)
+{
+        int retval;
+        mm_segment_t oldfs;
+        
+        oldfs = get_fs(); set_fs(KERNEL_DS); 
+        retval = sys_readlink(path, buf, bufsiz);
+        set_fs(oldfs);
+        if (retval < 0)
+        {
+                errno = -retval;
+                retval = -1;
+        }
+        return retval;
+}
+
+
+static inline int read(int fd, void *buffer, size_t count) {
+        if ((fd & 1) == 1)
+        {
+                struct socket *sock = fd2sock(fd);
+                struct iovec iov;
+                struct msghdr msg;
+		mm_segment_t oldfs;
+                int flags = 0;
+                int RetVal;
+                
+                msg.msg_name = NULL;
+                msg.msg_namelen = 0;
+                msg.msg_iov = &iov;
+                msg.msg_iovlen = 1;
+                msg.msg_control = NULL;
+                msg.msg_controllen = 0;
+		msg.msg_flags = 0;
+                iov.iov_base = buffer;
+                iov.iov_len = count;
+		oldfs = get_fs(); set_fs(KERNEL_DS); 
+                RetVal = sock_recvmsg(sock, &msg, count, flags);
+		set_fs(oldfs);
+                if (RetVal < 0)
+                {
+                        errno = -RetVal;
+                        RetVal = -1;
+                }
+                return RetVal;
+        }
+        else
+        {
+                struct file *F = fd2file(fd);
+                mm_segment_t oldfs;
+                int RetVal;
+                
+                oldfs = get_fs(); 
+                set_fs(KERNEL_DS);
+                RetVal = F->f_op->read(F, buffer, count, &F->f_pos);
+                set_fs(oldfs);
+                if (RetVal < 0)
+                {
+                        errno = -RetVal;
+                        RetVal = -1;
+                }
+                return RetVal;
+        }
+}
+
+static inline int write(int fd, const void *buffer, size_t count) {
+        if ((fd & 1) == 1)
+        {
+                struct socket *sock = fd2sock(fd);
+                struct iovec iov;
+                struct msghdr msg;
+		mm_segment_t oldfs;
+                int RetVal;
+                msg.msg_name = NULL;
+                msg.msg_namelen = 0;
+                msg.msg_iov = &iov;
+                msg.msg_iovlen = 1;
+                msg.msg_control = NULL;
+                msg.msg_controllen = 0;
+		msg.msg_flags = MSG_NOSIGNAL;
+                if (sock->type == SOCK_SEQPACKET)
+                        msg.msg_flags |= MSG_EOR;
+                iov.iov_base = (void *)buffer;
+                iov.iov_len = count;
+
+		oldfs = get_fs(); set_fs(KERNEL_DS); 
+                RetVal = sock_sendmsg(sock, &msg, count);
+		set_fs(oldfs);
+                if (RetVal < 0)
+                {
+                        errno = -RetVal;
+                        RetVal = -1;
+                }
+                return RetVal;
+        }
+        else
+        {
+                struct file *F = fd2file(fd);
+                mm_segment_t oldfs;
+                int RetVal;
+                
+                oldfs = get_fs(); 
+                set_fs(KERNEL_DS);
+                RetVal = F->f_op->write(F, buffer, count, &F->f_pos);
+                set_fs(oldfs);
+                if (RetVal < 0)
+                {
+                        errno = -RetVal;
+                        RetVal = -1;
+                }
+                return RetVal;
+        }
+}
+
+static inline int writev(int fd, const struct iovec  *vector, int count) {
+#ifndef DONT_USE_SIMPLE_WRITEV
+  int i, amount = 0;
+#if KORBIT_DEBUG_WRITING
+  printk("writev (fd = 0x%X, vec=0x%p, count = %d)\n", fd, vector, count);
+#endif
+  for (i = 0; i < count; i++) {
+    char *Buf = vector[i].iov_base;
+    int Amount = vector[i].iov_len;
+    while (Amount > 0) {
+      int A = write(fd, Buf, Amount);
+//#if KORBIT_DEBUG_WRITING
+if (A < Amount)
+      printk("  write(fd = 0x%X, buf = 0x%p, size = 0x%X) "
+             "= 0x%X errno = 0x%X\n", fd, Buf, Amount, A, errno);
+//#endif
+      Amount -= A;
+      amount += A;
+      Buf += A;
+      if (Amount > 0) schedule();     // Behave somewhat nicely...
+    }
+  }
+
+#if KORBIT_DEBUG_WRITING
+  printk("writev returning 0x%X[%d]\n", amount, amount);
+#endif
+  return amount;
+
+#else
+        if ((fd & 1) == 1)
+        {
+                struct socket *sock =  fd2sock(fd);
+                struct msghdr msg;
+		mm_segment_t oldfs;
+                int i, RetVal;
+                size_t tot_len = 0;
+                
+                for (i = 0; i < count; i++)
+                        tot_len += vector[i].iov_len;
+                
+                msg.msg_name = NULL;
+                msg.msg_namelen = 0;
+                msg.msg_iov = (struct iovec *)vector;
+                msg.msg_iovlen = count;
+                msg.msg_control = NULL;
+                msg.msg_controllen = 0;
+                if (sock->type == SOCK_SEQPACKET)
+                        msg.msg_flags |= MSG_EOR;
+
+		oldfs = get_fs(); set_fs(KERNEL_DS); 
+                RetVal = sock_sendmsg(sock, &msg, tot_len);
+		set_fs(oldfs);
+                if (RetVal < 0)
+                {
+                        errno = -RetVal;
+                        RetVal = -1;
+                }
+                return RetVal;
+        }
+        else
+        {
+                struct file *F = fd2file(fd);
+                mm_segment_t oldfs;
+                int RetVal;
+                
+                oldfs = get_fs(); 
+                set_fs(KERNEL_DS);
+                RetVal = F->f_op->writev(F, vector, (unsigned)count, &F->f_pos);
+                set_fs(oldfs);
+                if (RetVal < 0)
+                {
+                        errno = -RetVal;
+                        RetVal = -1;
+                }
+                return RetVal;
+        }
+#endif
+}
+
+static inline int close(int fd) {
+        int err = 0;
+        if ((fd & 1) == 1) {
+                struct socket *sock = fd2sock(fd);
+                sock_release(sock);
+        } else {
+                struct file *file = fd2file(fd);
+                fput(file);
+        }
+        return err;
+}
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/stdlib.h linux-2.4.1-korbit/net/korbit/include/stdlib.h
--- linux-2.4.1/net/korbit/include/stdlib.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/stdlib.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,99 @@
+#ifndef __KORBIT_STDLIB_H__
+#define __KORBIT_STDLIB_H__
+
+#include <linux/kernel.h>
+#include <linux/malloc.h>
+#include <linux/types.h>
+#include <asm/string.h>
+
+#define strtol(nptr,endptr,base) simple_strtol(nptr,endptr,base)
+
+#if 0
+#define malloc(size) kmalloc(size, GFP_KERNEL)
+#define free(ptr) kfree(ptr)
+#endif
+
+static inline void *malloc(size_t size)
+{
+        void *ptr = NULL;
+
+        if (size == 0) 
+                size = 4;
+
+        ptr = kmalloc(size + sizeof(size), GFP_KERNEL);
+
+        if (ptr)
+        {
+                *((size_t *)ptr) = size;
+                ptr = (size_t *)ptr + 1;
+        }
+        
+        return ptr;
+}
+
+static inline void free(void *ptr)
+{
+        if (ptr)
+                kfree((size_t *)ptr - 1);
+}
+
+#define alloca(size) malloc(size)
+
+/* freeca(ptr) - free a mem allocation if ptr points to one, otherwise do 
+ * nothing.
+ */
+static inline void freeca(void *ptr)
+{
+    if (ptr != NULL) { /* Don't free it if it's already free */
+	free(ptr);
+    }
+}
+
+static inline void *calloc(size_t nmemb, size_t size)
+{
+        void *ptr = malloc(nmemb*size);
+        if (ptr)
+                memset(ptr,0,nmemb*size);
+        return ptr;
+}
+
+static inline void *realloc(void *ptr, size_t size)
+{
+        void *newptr = NULL;
+
+        if (size != 0)
+                newptr = malloc(size);
+        
+        if (ptr && newptr) /* Copy old contents */
+        {
+                size_t *p1 = (size_t *)ptr - 1;
+                size_t *p2 = (size_t *)newptr - 1;
+                size_t n = *p1 < *p2 ? *p1 : *p2;
+                memcpy(newptr, ptr, n);
+        }
+
+        if (ptr)
+                free(ptr);
+        
+        return newptr;
+}
+
+/* Returned by `div'.  */
+typedef struct
+{
+        int quot;			/* Quotient.  */
+        int rem;			/* Remainder.  */
+} div_t;
+
+static inline div_t div(int number, int denom)
+{
+        div_t result;
+        result.quot = number/denom;
+        result.rem = number-(number*result.quot);
+        return result;
+}
+
+#define atexit(fn) -1
+#define getenv(name) 0
+
+#endif /* __KORBIT_STDLIB_H__ */
diff -urN linux-2.4.1/net/korbit/include/string.h linux-2.4.1-korbit/net/korbit/include/string.h
--- linux-2.4.1/net/korbit/include/string.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/string.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,11 @@
+#ifndef __KORBIT_STRING_H__
+#define __KORBIT_STRING_H__
+
+#include <linux/types.h>
+#include <asm/string.h>
+
+#include <glib.h>
+
+#define strerror(errno) g_strerror(errno)
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/CVS/Entries linux-2.4.1-korbit/net/korbit/include/sys/CVS/Entries
--- linux-2.4.1/net/korbit/include/sys/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/CVS/Entries	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,10 @@
+/ioctl.h/1.1.1.1/Thu Feb  1 09:46:55 2001//
+/poll.h/1.25/Thu Feb  1 09:46:55 2001//
+/socket.h/1.20/Thu Feb  1 09:46:55 2001//
+/stat.h/1.1.1.1/Thu Feb  1 09:46:55 2001//
+/time.h/1.1.1.1/Thu Feb  1 09:46:55 2001//
+/types.h/1.1.1.1/Thu Feb  1 09:46:56 2001//
+/uio.h/1.1.1.1/Thu Feb  1 09:46:56 2001//
+/un.h/1.1.1.1/Thu Feb  1 09:46:56 2001//
+/wait.h/1.1.1.1/Thu Feb  1 09:46:56 2001//
+D
diff -urN linux-2.4.1/net/korbit/include/sys/CVS/Repository linux-2.4.1-korbit/net/korbit/include/sys/CVS/Repository
--- linux-2.4.1/net/korbit/include/sys/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/CVS/Repository	Thu Feb  1 11:46:55 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/include/sys
diff -urN linux-2.4.1/net/korbit/include/sys/CVS/Root linux-2.4.1-korbit/net/korbit/include/sys/CVS/Root
--- linux-2.4.1/net/korbit/include/sys/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/CVS/Root	Thu Feb  1 11:46:55 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/include/sys/ioctl.h linux-2.4.1-korbit/net/korbit/include/sys/ioctl.h
--- linux-2.4.1/net/korbit/include/sys/ioctl.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/ioctl.h	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_SYS_IOCTL_H__
+#define __KORBIT_SYS_IOCTL_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/poll.h linux-2.4.1-korbit/net/korbit/include/sys/poll.h
--- linux-2.4.1/net/korbit/include/sys/poll.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/poll.h	Fri Feb  2 01:22:10 2001
@@ -0,0 +1,112 @@
+#ifndef __KORBIT_SYS_POLL_H__
+#define __KORBIT_SYS_POLL_H__
+
+#include <asm/poll.h>
+#include <asm/param.h>
+#include <linux/net.h>
+#include <linux/tcp.h>
+#include <linux/socket.h>
+#include <net/tcp.h>
+#include <net/sock.h>
+#include <linux/skbuff.h>
+#include <linux/sched.h>
+#include "stdlib.h"
+#include "sys/socket.h"
+
+/* Poll the file descriptors described by the NFDS structures starting at
+ * FDS.  If TIMEOUT is nonzero and not -1, allow TIMEOUT milliseconds for
+ * an event to occur; if TIMEOUT is -1, block until an event occurs.
+ * Returns the number of file descriptors with events, zero if timed
+ * out, or -1 for errors.
+ */
+
+/* This implementation of poll assumes that we are sitting on the wait
+ * queues for all of the file descriptors already.  Therefore if we are about
+ * to block, all we have to do is perform the schedule call which will
+ * automatically cause us to "block".
+ */
+static int poll_CheckFDs(struct pollfd *fds, unsigned long int nfds)
+{
+  int NumReady = 0, i;
+
+  // Loop over the file descriptors seeing if there is already work to be
+  // done...
+  for (i = 0; i < nfds; i++) {
+        struct socket *sock = fd2sock(fds[i].fd);
+	fds[i].revents = 0;
+
+        // Check to see if stuff is available to read
+        if (sock) {
+                // It's a socket baby
+                fds[i].revents = tcp_poll(0, sock, 0);
+
+                // Apparently tcp_poll doesn't look at the CLOSE_WAIT value,
+                // and we have a lot of sockets that end up in this state.
+                // This is a hack to shortcircuit some read failures from
+                // later.  This breaks "poll semantics" strictly speaking, but
+                // it's basically the "right thing to do" (tm).
+		if (sock->sk->state == TCP_CLOSE_WAIT) 
+                        fds[i].revents = POLLHUP;
+               	fds[i].revents &= fds[i].events | POLLERR | POLLHUP;
+        } else {
+                // It's a file
+                //struct file *f = fd2file(fd);
+//                printk("POLL NOT IMPLEMENTED FOR FILES YET\n");
+                BUG();
+	}
+
+        if (fds[i].revents) {
+                NumReady++;
+//                printk("FD #%d: Event = 0x%X\n", i, fds[i].revents);
+	}
+
+  } /* for */
+
+  return NumReady;
+} /* End poll_CheckFDs(). */
+
+
+static int poll(struct pollfd *fds, unsigned long int nfds, int timeout) {
+  wait_queue_t *WaitQueues = 0;
+  int NumReady = poll_CheckFDs(fds, nfds);
+  int i; 
+
+  if (NumReady || timeout == 0)
+    return NumReady;
+
+//  printk("Starting to Poll... %d fds...\n", nfds);
+  WaitQueues = (wait_queue_t*)malloc(nfds*sizeof(wait_queue_t));
+  if (WaitQueues == 0) return 0; // Crap, nomem...
+
+  for (i = 0; i < nfds; i++) { 
+    struct socket *sock = fd2sock(fds[i].fd);
+    init_waitqueue_entry(WaitQueues+i, current);
+
+    if (sock)
+      add_wait_queue_exclusive(sock->sk->sleep, WaitQueues+i);
+//    else 
+//      printk("I don't know how to wait on fd #%d = 0x%X\n", i, fds[i].fd);
+  }
+
+  // Wait for us to get notified by one of the socket wait queue notifiers!
+  do {
+    // Change our task state so that we are not immediately rescheduled.  
+    // This lets the scheduler know that we are waiting for something to happen
+    set_current_state(TASK_INTERRUPTIBLE);
+    schedule();
+  } while (!(NumReady = poll_CheckFDs(fds, nfds)));
+
+  set_current_state(TASK_RUNNING);
+
+  for (i = 0; i < nfds; i++) { 
+    struct socket *sock = fd2sock(fds[i].fd);
+    if (sock)
+      remove_wait_queue(sock->sk->sleep, WaitQueues+i);
+  }
+
+  free(WaitQueues);
+//  printk("Returning %d\n", NumReady);
+  return NumReady;
+}
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/socket.h linux-2.4.1-korbit/net/korbit/include/sys/socket.h
--- linux-2.4.1/net/korbit/include/sys/socket.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/socket.h	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,126 @@
+#ifndef __KORBIT_SYS_SOCKET_H__
+#define __KORBIT_SYS_SOCKET_H__
+typedef unsigned int socklen_t;
+
+#include <linux/socket.h>
+#include <linux/wait.h>
+#include <asm/semaphore.h>
+#include <net/sock.h>
+
+/* These functions are declared in net/socket.c */
+asmlinkage long sys_socket(int family, int type, int protocol);
+struct socket *sockfd_lookup(int fd, int *err);
+
+
+static inline int sock2fd(struct socket *s)
+{
+        return (-(int)s) | 1;
+}
+
+static inline struct socket *fd2sock(int sockfd)
+{
+        if ((sockfd & 1) == 0) /* can't convert a file! */
+                return NULL;
+
+        return (struct socket *)(-(sockfd & ~1));
+}
+
+
+static inline int socket(int domain, int type, int protocol) {
+        struct socket *sock;
+        int retval = sock_create(domain, type, protocol, &sock);
+
+        if (retval < 0) return (int)NULL;
+        return sock2fd(sock);
+}
+
+
+static inline int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen)
+{
+        struct socket *sock = fd2sock(sockfd);
+
+        if (sock == NULL)
+                return -1;
+        if (!sock->ops->bind(sock, my_addr, addrlen))
+                return 0;
+        else
+                return -1; /* should normally also set errno */
+}
+
+
+static inline int connect(int sockfd, const struct sockaddr *serv_addr, 
+                          socklen_t addrlen)
+{
+        struct socket *sock = fd2sock(sockfd);
+        int flags = 0; /* TODO : what is flags supposed to be? */
+        
+        if (sock == NULL)
+                return -1;
+
+        if (sock->ops->connect(sock, (struct sockaddr *)serv_addr, addrlen, flags) == 0)
+                return 0;
+        else
+                return -1; /* should normally also set errno */
+}
+
+
+static inline int listen(int sockfd, int backlog)
+{
+        struct socket *sock = fd2sock(sockfd);
+        
+        if (sock == NULL)
+                return -1;
+        
+        if (sock->ops->listen(sock, backlog) == 0)
+                return 0;
+        else
+                return -1; /* should normally also set errno */
+}
+
+
+static inline int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
+{
+        struct socket *sock = fd2sock(sockfd);
+        struct socket *newsock;
+        struct sockaddr_in *newaddr = (struct sockaddr_in *)addr; /* check? */
+        int flags = 0; /* Should be ok */
+
+	if (sock == 0) 
+                return -1;
+        
+        newsock = sock_alloc();
+        if (newsock == 0)
+                return -1;
+
+        newsock->type = sock->type;
+        newsock->ops = sock->ops;
+        if (sock->ops->accept(sock, newsock, flags) < 0) 
+        {
+                sock_release(newsock);
+                return -1; /* should normally also set errno */
+        }
+
+        newaddr->sin_family = AF_INET;
+        newaddr->sin_port = newsock->sk->dport;
+        newaddr->sin_addr.s_addr = newsock->sk->daddr;
+
+        *addrlen = sizeof(newaddr);
+
+        return sock2fd(newsock);
+}
+
+
+static inline int shutdown(int sockfd, int how)
+{
+        struct socket *sock = fd2sock(sockfd);
+        
+        if (sock == NULL)
+                return -1;
+
+        if (sock->ops->shutdown(sock, how) == 0)
+                return 0;
+        else
+                return -1; /* should normally also set errno */
+}
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/stat.h linux-2.4.1-korbit/net/korbit/include/sys/stat.h
--- linux-2.4.1/net/korbit/include/sys/stat.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/stat.h	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_SYS_STAT_H__
+#define __KORBIT_SYS_STAT_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/time.h linux-2.4.1-korbit/net/korbit/include/sys/time.h
--- linux-2.4.1/net/korbit/include/sys/time.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/time.h	Thu Feb  1 11:46:55 2001
@@ -0,0 +1,6 @@
+#ifndef __KORBIT_TIME_H__
+#define __KORBIT_TIME_H__
+
+#include <linux/time.h>
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/types.h linux-2.4.1-korbit/net/korbit/include/sys/types.h
--- linux-2.4.1/net/korbit/include/sys/types.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/types.h	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,4 @@
+#ifndef __KORBIT_SYS_TYPES_H__
+#define __KORBIT_SYS_TYPES_H__
+#include <linux/types.h>
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/uio.h linux-2.4.1-korbit/net/korbit/include/sys/uio.h
--- linux-2.4.1/net/korbit/include/sys/uio.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/uio.h	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,4 @@
+#ifndef __KORBIT_SYS_UIO_H__
+#define __KORBIT_SYS_UIO_H__
+#include <linux/uio.h>
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/un.h linux-2.4.1-korbit/net/korbit/include/sys/un.h
--- linux-2.4.1/net/korbit/include/sys/un.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/un.h	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,5 @@
+#ifndef __KORBIT_SYS_UN_H__
+#define __KORBIT_SYS_UN_H__
+#include <linux/socket.h>
+#include <linux/un.h>
+#endif
diff -urN linux-2.4.1/net/korbit/include/sys/wait.h linux-2.4.1-korbit/net/korbit/include/sys/wait.h
--- linux-2.4.1/net/korbit/include/sys/wait.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/sys/wait.h	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,3 @@
+#ifndef __KORBIT_SYS_WAIT_H__
+#define __KORBIT_SYS_WAIT_H__
+#endif
diff -urN linux-2.4.1/net/korbit/include/syslog.h linux-2.4.1-korbit/net/korbit/include/syslog.h
--- linux-2.4.1/net/korbit/include/syslog.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/syslog.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,7 @@
+#ifndef __KORBIT_SYSLOG_H__
+#define __KORBIT_SYSLOG_H__
+
+#define	LOG_NOTICE	5	/* normal but significant condition */
+#define	LOG_INFO	6	/* informational */
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/time.h linux-2.4.1-korbit/net/korbit/include/time.h
--- linux-2.4.1/net/korbit/include/time.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/time.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,4 @@
+#ifndef __KORBIT_TIME_H__
+#define __KORBIT_TIME_H__
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/unistd.h linux-2.4.1-korbit/net/korbit/include/unistd.h
--- linux-2.4.1/net/korbit/include/unistd.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/unistd.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,19 @@
+#ifndef __KORBIT_UNISTD_H__
+#define __KORBIT_UNISTD_H__
+
+#include <linux/types.h>
+#include <linux/utsname.h>
+#include <asm/string.h>
+#include <asm/semaphore.h>
+/* extern char *getcwd(char * buf, size_t size); */
+
+static inline int gethostname(char *name, size_t len) {
+  down_read(&uts_sem);
+  strncpy(name, system_utsname.nodename, len);
+  up_read(&uts_sem);
+printk("gethostname() = %s\n", name);
+  return 0;
+}
+
+
+#endif
diff -urN linux-2.4.1/net/korbit/include/utime.h linux-2.4.1-korbit/net/korbit/include/utime.h
--- linux-2.4.1/net/korbit/include/utime.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/include/utime.h	Thu Feb  1 11:46:54 2001
@@ -0,0 +1,4 @@
+#ifndef __KORBIT_UTIME_H__
+#define __KORBIT_UTIME_H__
+#include <linux/utime.h>
+#endif
diff -urN linux-2.4.1/net/korbit/kglib/CVS/Entries linux-2.4.1-korbit/net/korbit/kglib/CVS/Entries
--- linux-2.4.1/net/korbit/kglib/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/CVS/Entries	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,15 @@
+/Makefile/1.4/Thu Feb  1 09:46:56 2001//
+/garray.c/1.3/Thu Feb  1 09:46:56 2001//
+/ghash.c/1.2/Thu Feb  1 09:46:56 2001//
+/glib.h/1.3/Thu Feb  1 09:46:56 2001//
+/glibconfig.h/1.2/Thu Feb  1 09:46:56 2001//
+/glist.c/1.1.1.1/Thu Feb  1 09:46:57 2001//
+/gmem.c/1.2/Thu Feb  1 09:46:57 2001//
+/gprimes.c/1.1.1.1/Thu Feb  1 09:46:57 2001//
+/gslist.c/1.1.1.1/Thu Feb  1 09:46:57 2001//
+/gstrfuncs.c/1.2/Thu Feb  1 09:46:57 2001//
+/gstring.c/1.1.1.1/Thu Feb  1 09:46:57 2001//
+/gtree.c/1.1.1.1/Thu Feb  1 09:46:57 2001//
+/gutils.c/1.2/Thu Feb  1 09:46:57 2001//
+/korbit_errno.c/1.1/Thu Feb  1 09:46:57 2001//
+D
diff -urN linux-2.4.1/net/korbit/kglib/CVS/Repository linux-2.4.1-korbit/net/korbit/kglib/CVS/Repository
--- linux-2.4.1/net/korbit/kglib/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/CVS/Repository	Thu Feb  1 11:46:56 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/kglib
diff -urN linux-2.4.1/net/korbit/kglib/CVS/Root linux-2.4.1-korbit/net/korbit/kglib/CVS/Root
--- linux-2.4.1/net/korbit/kglib/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/CVS/Root	Thu Feb  1 11:46:56 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/kglib/Makefile linux-2.4.1-korbit/net/korbit/kglib/Makefile
--- linux-2.4.1/net/korbit/kglib/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/Makefile	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,18 @@
+#
+# Makefile for KORBit/kglib
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := kglib.o
+
+#obj-m := $(O_TARGET)
+obj-y := garray.o glist.o gprimes.o gstrfuncs.o gtree.o \
+          ghash.o gmem.o gslist.o gstring.o gutils.o korbit_errno.o
+
+EXTRA_CFLAGS = -D__KORBIT__ -DHAVE_CONFIG_H -DHAVE_UNISTD_H -I. -I.. -I../include -nostdinc
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/kglib/garray.c linux-2.4.1-korbit/net/korbit/kglib/garray.c
--- linux-2.4.1/net/korbit/kglib/garray.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/garray.c	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,431 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include <string.h>
+#include "glib.h"
+
+
+#define MIN_ARRAY_SIZE  16
+
+
+typedef struct _GRealArray  GRealArray;
+
+struct _GRealArray
+{
+  guint8 *data;
+  guint   len;
+  guint   alloc;
+  guint   elt_size;
+  guint   zero_terminated : 1;
+  guint   clear : 1;
+};
+
+
+static gint g_nearest_pow        (gint        num);
+static void g_array_maybe_expand (GRealArray *array,
+				  gint        len);
+
+static GMemChunk *array_mem_chunk = NULL;
+G_LOCK_DEFINE_STATIC (array_mem_chunk);
+
+GArray*
+g_array_new (gboolean zero_terminated,
+	     gboolean clear,
+	     guint    elt_size)
+{
+  GRealArray *array;
+
+  G_LOCK (array_mem_chunk);
+  if (!array_mem_chunk)
+    array_mem_chunk = g_mem_chunk_new ("array mem chunk",
+				       sizeof (GRealArray),
+				       1024, G_ALLOC_AND_FREE);
+
+  array = g_chunk_new (GRealArray, array_mem_chunk);
+  G_UNLOCK (array_mem_chunk);
+
+  array->data            = NULL;
+  array->len             = 0;
+  array->alloc           = 0;
+  array->zero_terminated = (zero_terminated ? 1 : 0);
+  array->clear           = (clear ? 1 : 0);
+  array->elt_size        = elt_size;
+
+  return (GArray*) array;
+}
+
+void
+g_array_free (GArray  *array,
+	      gboolean free_segment)
+{
+  if (free_segment)
+    g_free (array->data);
+
+  G_LOCK (array_mem_chunk);
+  g_mem_chunk_free (array_mem_chunk, array);
+  G_UNLOCK (array_mem_chunk);
+}
+
+GArray*
+g_array_append_vals (GArray       *farray,
+		     gconstpointer data,
+		     guint         len)
+{
+  GRealArray *array = (GRealArray*) farray;
+
+  g_array_maybe_expand (array, len);
+
+  memcpy (array->data + array->elt_size * array->len, data, array->elt_size * len);
+
+  array->len += len;
+
+  return farray;
+}
+
+GArray*
+g_array_prepend_vals (GArray        *farray,
+		      gconstpointer  data,
+		      guint          len)
+{
+  GRealArray *array = (GRealArray*) farray;
+
+  g_array_maybe_expand (array, len);
+
+  g_memmove (array->data + array->elt_size * len, array->data, array->elt_size * array->len);
+
+  memcpy (array->data, data, len * array->elt_size);
+
+  array->len += len;
+
+  return farray;
+}
+
+GArray*
+g_array_insert_vals (GArray        *farray,
+		     guint          index,
+		     gconstpointer  data,
+		     guint          len)
+{
+  GRealArray *array = (GRealArray*) farray;
+
+  g_array_maybe_expand (array, len);
+
+  g_memmove (array->data + array->elt_size * (len + index), 
+	     array->data + array->elt_size * index, 
+	     array->elt_size * (array->len - index));
+
+  memcpy (array->data + array->elt_size * index, data, len * array->elt_size);
+
+  array->len += len;
+
+  return farray;
+}
+
+GArray*
+g_array_set_size (GArray *farray,
+		  guint   length)
+{
+  GRealArray *array = (GRealArray*) farray;
+
+  if (array->len < length)
+    g_array_maybe_expand (array, length - array->len);
+
+  array->len = length;
+
+  return farray;
+}
+
+GArray*
+g_array_remove_index (GArray* farray,
+		      guint index)
+{
+  GRealArray* array = (GRealArray*) farray;
+
+  g_return_val_if_fail (array, NULL);
+
+  g_return_val_if_fail (index < array->len, NULL);
+
+  if (index != array->len - 1)
+      g_memmove (array->data + array->elt_size * index, 
+		 array->data + array->elt_size * (index + 1), 
+		 array->elt_size * (array->len - index - 1));
+  
+  if (array->zero_terminated)
+    memset (array->data + array->elt_size * (array->len - 1), 0, 
+	    array->elt_size);
+
+  array->len -= 1;
+
+  return farray;
+}
+
+GArray*
+g_array_remove_index_fast (GArray* farray,
+			   guint index)
+{
+  GRealArray* array = (GRealArray*) farray;
+
+  g_return_val_if_fail (array, NULL);
+
+  g_return_val_if_fail (index < array->len, NULL);
+
+  if (index != array->len - 1)
+    g_memmove (array->data + array->elt_size * index, 
+	       array->data + array->elt_size * (array->len - 1), 
+	       array->elt_size);
+  
+  if (array->zero_terminated)
+    memset (array->data + array->elt_size * (array->len - 1), 0, 
+	    array->elt_size);
+
+  array->len -= 1;
+
+  return farray;
+}
+
+static gint
+g_nearest_pow (gint num)
+{
+  gint n = 1;
+
+  while (n < num)
+    n <<= 1;
+
+  return n;
+}
+
+static void
+g_array_maybe_expand (GRealArray *array,
+		      gint        len)
+{
+  guint want_alloc = (array->len + len + array->zero_terminated) * array->elt_size;
+
+  if (want_alloc > array->alloc)
+    {
+      guint old_alloc = array->alloc;
+
+      array->alloc = g_nearest_pow (want_alloc);
+      array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
+
+      array->data = g_realloc (array->data, array->alloc);
+
+      if (array->clear || array->zero_terminated)
+	memset (array->data + old_alloc, 0, array->alloc - old_alloc);
+    }
+}
+
+/* Pointer Array
+ */
+
+typedef struct _GRealPtrArray  GRealPtrArray;
+
+struct _GRealPtrArray
+{
+  gpointer *pdata;
+  guint     len;
+  guint     alloc;
+};
+
+static void g_ptr_array_maybe_expand (GRealPtrArray *array,
+				      gint           len);
+
+static GMemChunk *ptr_array_mem_chunk = NULL;
+G_LOCK_DEFINE_STATIC (ptr_array_mem_chunk);
+
+
+GPtrArray*
+g_ptr_array_new (void)
+{
+  GRealPtrArray *array;
+
+  G_LOCK (ptr_array_mem_chunk);
+  if (!ptr_array_mem_chunk)
+    ptr_array_mem_chunk = g_mem_chunk_new ("array mem chunk",
+					   sizeof (GRealPtrArray),
+					   1024, G_ALLOC_AND_FREE);
+
+  array = g_chunk_new (GRealPtrArray, ptr_array_mem_chunk);
+  G_UNLOCK (ptr_array_mem_chunk);
+
+  array->pdata = NULL;
+  array->len = 0;
+  array->alloc = 0;
+
+  return (GPtrArray*) array;
+}
+
+void
+g_ptr_array_free (GPtrArray   *array,
+		  gboolean  free_segment)
+{
+  g_return_if_fail (array);
+
+  if (free_segment)
+    g_free (array->pdata);
+
+  G_LOCK (ptr_array_mem_chunk);
+  g_mem_chunk_free (ptr_array_mem_chunk, array);
+  G_UNLOCK (ptr_array_mem_chunk);
+}
+
+static void
+g_ptr_array_maybe_expand (GRealPtrArray *array,
+			  gint        len)
+{
+  guint old_alloc;
+
+  if ((array->len + len) > array->alloc)
+    {
+      old_alloc = array->alloc;
+
+      array->alloc = g_nearest_pow (array->len + len);
+      array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
+      if (array->pdata)
+	array->pdata = g_realloc (array->pdata, sizeof(gpointer) * array->alloc);
+      else
+	array->pdata = g_new0 (gpointer, array->alloc);
+
+      memset (array->pdata + old_alloc, 0, 
+	      sizeof (gpointer) * (array->alloc - old_alloc));
+    }
+}
+
+void
+g_ptr_array_set_size  (GPtrArray   *farray,
+		       gint	     length)
+{
+  GRealPtrArray* array = (GRealPtrArray*) farray;
+
+  g_return_if_fail (array);
+
+  if (length > array->len)
+    g_ptr_array_maybe_expand (array, (length - array->len));
+
+  array->len = length;
+}
+
+gpointer
+g_ptr_array_remove_index (GPtrArray* farray,
+			  guint index)
+{
+  GRealPtrArray* array = (GRealPtrArray*) farray;
+  gpointer result;
+
+  g_return_val_if_fail (array, NULL);
+
+  g_return_val_if_fail (index < array->len, NULL);
+
+  result = array->pdata[index];
+  
+  if (index != array->len - 1)
+    g_memmove (array->pdata + index, array->pdata + index + 1, 
+	       sizeof (gpointer) * (array->len - index - 1));
+  
+  array->pdata[array->len - 1] = NULL;
+
+  array->len -= 1;
+
+  return result;
+}
+
+gpointer
+g_ptr_array_remove_index_fast (GPtrArray* farray,
+			       guint index)
+{
+  GRealPtrArray* array = (GRealPtrArray*) farray;
+  gpointer result;
+
+  g_return_val_if_fail (array, NULL);
+
+  g_return_val_if_fail (index < array->len, NULL);
+
+  result = array->pdata[index];
+  
+  if (index != array->len - 1)
+    array->pdata[index] = array->pdata[array->len - 1];
+
+  array->pdata[array->len - 1] = NULL;
+
+  array->len -= 1;
+
+  return result;
+}
+
+gboolean
+g_ptr_array_remove (GPtrArray* farray,
+		    gpointer data)
+{
+  GRealPtrArray* array = (GRealPtrArray*) farray;
+  int i;
+
+  g_return_val_if_fail (array, FALSE);
+
+  for (i = 0; i < array->len; i += 1)
+    {
+      if (array->pdata[i] == data)
+	{
+	  g_ptr_array_remove_index (farray, i);
+	  return TRUE;
+	}
+    }
+
+  return FALSE;
+}
+
+gboolean
+g_ptr_array_remove_fast (GPtrArray* farray,
+			 gpointer data)
+{
+  GRealPtrArray* array = (GRealPtrArray*) farray;
+  int i;
+
+  g_return_val_if_fail (array, FALSE);
+
+  for (i = 0; i < array->len; i += 1)
+    {
+      if (array->pdata[i] == data)
+	{
+	  g_ptr_array_remove_index_fast (farray, i);
+	  return TRUE;
+	}
+    }
+
+  return FALSE;
+}
+
+void
+g_ptr_array_add (GPtrArray* farray,
+		 gpointer data)
+{
+  GRealPtrArray* array = (GRealPtrArray*) farray;
+
+  g_return_if_fail (array);
+
+  g_ptr_array_maybe_expand (array, 1);
+
+  array->pdata[array->len++] = data;
+}
+
diff -urN linux-2.4.1/net/korbit/kglib/ghash.c linux-2.4.1-korbit/net/korbit/kglib/ghash.c
--- linux-2.4.1/net/korbit/kglib/ghash.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/ghash.c	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,404 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "glib.h"
+
+
+#define HASH_TABLE_MIN_SIZE 11
+#define HASH_TABLE_MAX_SIZE 13845163
+
+
+typedef struct _GHashNode      GHashNode;
+
+struct _GHashNode
+{
+  gpointer key;
+  gpointer value;
+  GHashNode *next;
+};
+
+struct _GHashTable
+{
+  gint size;
+  gint nnodes;
+  guint frozen;
+  GHashNode **nodes;
+  GHashFunc hash_func;
+  GCompareFunc key_compare_func;
+};
+
+
+static void		g_hash_table_resize	 (GHashTable	*hash_table);
+static GHashNode**	g_hash_table_lookup_node (GHashTable	*hash_table,
+						  gconstpointer	 key);
+static GHashNode*	g_hash_node_new		 (gpointer	 key,
+						  gpointer	 value);
+static void		g_hash_node_destroy	 (GHashNode	*hash_node);
+static void		g_hash_nodes_destroy	 (GHashNode	*hash_node);
+
+
+G_LOCK_DEFINE_STATIC (g_hash_global);
+
+static GMemChunk *node_mem_chunk = NULL;
+static GHashNode *node_free_list = NULL;
+
+
+GHashTable*
+g_hash_table_new (GHashFunc    hash_func,
+		  GCompareFunc key_compare_func)
+{
+  GHashTable *hash_table;
+  guint i;
+  
+  hash_table = g_new (GHashTable, 1);
+  hash_table->size = HASH_TABLE_MIN_SIZE;
+  hash_table->nnodes = 0;
+  hash_table->frozen = FALSE;
+  hash_table->hash_func = hash_func ? hash_func : g_direct_hash;
+  hash_table->key_compare_func = key_compare_func;
+  hash_table->nodes = g_new (GHashNode*, hash_table->size);
+  
+  for (i = 0; i < hash_table->size; i++)
+    hash_table->nodes[i] = NULL;
+  
+  return hash_table;
+}
+
+void
+g_hash_table_destroy (GHashTable *hash_table)
+{
+  guint i;
+  
+  g_return_if_fail (hash_table != NULL);
+  
+  for (i = 0; i < hash_table->size; i++)
+    g_hash_nodes_destroy (hash_table->nodes[i]);
+  
+  g_free (hash_table->nodes);
+  g_free (hash_table);
+}
+
+static inline GHashNode**
+g_hash_table_lookup_node (GHashTable	*hash_table,
+			  gconstpointer	 key)
+{
+  GHashNode **node;
+  
+  node = &hash_table->nodes
+    [(* hash_table->hash_func) (key) % hash_table->size];
+  
+  /* Hash table lookup needs to be fast.
+   *  We therefore remove the extra conditional of testing
+   *  whether to call the key_compare_func or not from
+   *  the inner loop.
+   */
+  if (hash_table->key_compare_func)
+    while (*node && !(*hash_table->key_compare_func) ((*node)->key, key))
+      node = &(*node)->next;
+  else
+    while (*node && (*node)->key != key)
+      node = &(*node)->next;
+  
+  return node;
+}
+
+gpointer
+g_hash_table_lookup (GHashTable	  *hash_table,
+		     gconstpointer key)
+{
+  GHashNode *node;
+  
+  g_return_val_if_fail (hash_table != NULL, NULL);
+  
+  node = *g_hash_table_lookup_node (hash_table, key);
+  
+  return node ? node->value : NULL;
+}
+
+void
+g_hash_table_insert (GHashTable *hash_table,
+		     gpointer	 key,
+		     gpointer	 value)
+{
+  GHashNode **node;
+  
+  g_return_if_fail (hash_table != NULL);
+  
+  node = g_hash_table_lookup_node (hash_table, key);
+  
+  if (*node)
+    {
+      /* do not reset node->key in this place, keeping
+       * the old key might be intended.
+       * a g_hash_table_remove/g_hash_table_insert pair
+       * can be used otherwise.
+       *
+       * node->key = key; */
+      (*node)->value = value;
+    }
+  else
+    {
+      *node = g_hash_node_new (key, value);
+      hash_table->nnodes++;
+      if (!hash_table->frozen)
+	g_hash_table_resize (hash_table);
+    }
+}
+
+void
+g_hash_table_remove (GHashTable	     *hash_table,
+		     gconstpointer    key)
+{
+  GHashNode **node, *dest;
+  
+  g_return_if_fail (hash_table != NULL);
+  
+  node = g_hash_table_lookup_node (hash_table, key);
+
+  if (*node)
+    {
+      dest = *node;
+      (*node) = dest->next;
+      g_hash_node_destroy (dest);
+      hash_table->nnodes--;
+  
+      if (!hash_table->frozen)
+        g_hash_table_resize (hash_table);
+    }
+}
+
+gboolean
+g_hash_table_lookup_extended (GHashTable	*hash_table,
+			      gconstpointer	 lookup_key,
+			      gpointer		*orig_key,
+			      gpointer		*value)
+{
+  GHashNode *node;
+  
+  g_return_val_if_fail (hash_table != NULL, FALSE);
+  
+  node = *g_hash_table_lookup_node (hash_table, lookup_key);
+  
+  if (node)
+    {
+      if (orig_key)
+	*orig_key = node->key;
+      if (value)
+	*value = node->value;
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+void
+g_hash_table_freeze (GHashTable *hash_table)
+{
+  g_return_if_fail (hash_table != NULL);
+  
+  hash_table->frozen++;
+}
+
+void
+g_hash_table_thaw (GHashTable *hash_table)
+{
+  g_return_if_fail (hash_table != NULL);
+  
+  if (hash_table->frozen)
+    if (!(--hash_table->frozen))
+      g_hash_table_resize (hash_table);
+}
+
+guint
+g_hash_table_foreach_remove (GHashTable	*hash_table,
+			     GHRFunc	 func,
+			     gpointer	 user_data)
+{
+  GHashNode *node, *prev;
+  guint i;
+  guint deleted = 0;
+  
+  g_return_val_if_fail (hash_table != NULL, 0);
+  g_return_val_if_fail (func != NULL, 0);
+  
+  for (i = 0; i < hash_table->size; i++)
+    {
+    restart:
+      
+      prev = NULL;
+      
+      for (node = hash_table->nodes[i]; node; prev = node, node = node->next)
+	{
+	  if ((* func) (node->key, node->value, user_data))
+	    {
+	      deleted += 1;
+	      
+	      hash_table->nnodes -= 1;
+	      
+	      if (prev)
+		{
+		  prev->next = node->next;
+		  g_hash_node_destroy (node);
+		  node = prev;
+		}
+	      else
+		{
+		  hash_table->nodes[i] = node->next;
+		  g_hash_node_destroy (node);
+		  goto restart;
+		}
+	    }
+	}
+    }
+  
+  if (!hash_table->frozen)
+    g_hash_table_resize (hash_table);
+  
+  return deleted;
+}
+
+void
+g_hash_table_foreach (GHashTable *hash_table,
+		      GHFunc	  func,
+		      gpointer	  user_data)
+{
+  GHashNode *node;
+  gint i;
+  
+  g_return_if_fail (hash_table != NULL);
+  g_return_if_fail (func != NULL);
+  
+  for (i = 0; i < hash_table->size; i++)
+    for (node = hash_table->nodes[i]; node; node = node->next)
+      (* func) (node->key, node->value, user_data);
+}
+
+/* Returns the number of elements contained in the hash table. */
+guint
+g_hash_table_size (GHashTable *hash_table)
+{
+  g_return_val_if_fail (hash_table != NULL, 0);
+  
+  return hash_table->nnodes;
+}
+
+static void
+g_hash_table_resize (GHashTable *hash_table)
+{
+  GHashNode **new_nodes;
+  GHashNode *node;
+  GHashNode *next;
+#ifdef __KORBIT__
+  guint nodes_per_list;
+#else
+  gfloat nodes_per_list;
+#endif
+  guint hash_val;
+  gint new_size;
+  gint i;
+  
+  nodes_per_list = (hash_table->nnodes * 10) / hash_table->size;
+  
+  if ((nodes_per_list > 3 || hash_table->size <= HASH_TABLE_MIN_SIZE) &&
+      (nodes_per_list < 30 || hash_table->size >= HASH_TABLE_MAX_SIZE))
+    return;
+  
+  new_size = CLAMP(g_spaced_primes_closest (hash_table->nnodes),
+		   HASH_TABLE_MIN_SIZE,
+		   HASH_TABLE_MAX_SIZE);
+  new_nodes = g_new0 (GHashNode*, new_size);
+  
+  for (i = 0; i < hash_table->size; i++)
+    for (node = hash_table->nodes[i]; node; node = next)
+      {
+	next = node->next;
+
+	hash_val = (* hash_table->hash_func) (node->key) % new_size;
+
+	node->next = new_nodes[hash_val];
+	new_nodes[hash_val] = node;
+      }
+  
+  g_free (hash_table->nodes);
+  hash_table->nodes = new_nodes;
+  hash_table->size = new_size;
+}
+
+static GHashNode*
+g_hash_node_new (gpointer key,
+		 gpointer value)
+{
+  GHashNode *hash_node;
+  
+  G_LOCK (g_hash_global);
+  if (node_free_list)
+    {
+      hash_node = node_free_list;
+      node_free_list = node_free_list->next;
+    }
+  else
+    {
+      if (!node_mem_chunk)
+	node_mem_chunk = g_mem_chunk_new ("hash node mem chunk",
+					  sizeof (GHashNode),
+					  1024, G_ALLOC_ONLY);
+      
+      hash_node = g_chunk_new (GHashNode, node_mem_chunk);
+    }
+  G_UNLOCK (g_hash_global);
+  
+  hash_node->key = key;
+  hash_node->value = value;
+  hash_node->next = NULL;
+  
+  return hash_node;
+}
+
+static void
+g_hash_node_destroy (GHashNode *hash_node)
+{
+  G_LOCK (g_hash_global);
+  hash_node->next = node_free_list;
+  node_free_list = hash_node;
+  G_UNLOCK (g_hash_global);
+}
+
+static void
+g_hash_nodes_destroy (GHashNode *hash_node)
+{
+  if (hash_node)
+    {
+      GHashNode *node = hash_node;
+  
+      while (node->next)
+        node = node->next;
+  
+      G_LOCK (g_hash_global);
+      node->next = node_free_list;
+      node_free_list = hash_node;
+      G_UNLOCK (g_hash_global);
+    }
+}
diff -urN linux-2.4.1/net/korbit/kglib/glib.h linux-2.4.1-korbit/net/korbit/kglib/glib.h
--- linux-2.4.1/net/korbit/kglib/glib.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/glib.h	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,1671 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_LIB_H__
+#define __G_LIB_H__
+
+#ifdef __KORBIT__
+#define G_DISABLE_ASSERT 1
+#include <stdio.h>
+#endif
+
+#include "config.h"
+
+/* system specific config file glibconfig.h provides definitions for
+ * the extrema of many of the standard types. These are:
+ *
+ *  G_MINSHORT, G_MAXSHORT
+ *  G_MININT, G_MAXINT
+ *  G_MINLONG, G_MAXLONG
+ *  G_MINFLOAT, G_MAXFLOAT
+ *  G_MINDOUBLE, G_MAXDOUBLE
+ *
+ * It also provides the following typedefs:
+ *
+ *  gint8, guint8
+ *  gint16, guint16
+ *  gint32, guint32
+ *  gint64, guint64
+ *
+ * It defines the G_BYTE_ORDER symbol to one of G_*_ENDIAN (see later in
+ * this file). 
+ *
+ * And it provides a way to store and retrieve a `gint' in/from a `gpointer'.
+ * This is useful to pass an integer instead of a pointer to a callback.
+ *
+ *  GINT_TO_POINTER(i), GUINT_TO_POINTER(i)
+ *  GPOINTER_TO_INT(p), GPOINTER_TO_UINT(p)
+ *
+ * Finally, it provide the following wrappers to STDC functions:
+ *
+ *  g_ATEXIT
+ *    To register hooks which are executed on exit().
+ *    Usually a wrapper for STDC atexit.
+ *
+ *  void *g_memmove(void *dest, const void *src, guint count);
+ *    A wrapper for STDC memmove, or an implementation, if memmove doesn't
+ *    exist.  The prototype looks like the above, give or take a const,
+ *    or size_t.
+ */
+#include <glibconfig.h>
+
+/* include varargs functions for assertment macros
+ */
+#include <stdarg.h>
+
+#define G_DIR_SEPARATOR '/'
+#define G_DIR_SEPARATOR_S "/"
+#define G_SEARCHPATH_SEPARATOR ':'
+#define G_SEARCHPATH_SEPARATOR_S ":"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Provide definitions for some commonly used macros.
+ *  Some of them are only provided if they haven't already
+ *  been defined. It is assumed that if they are already
+ *  defined then the current definition is correct.
+ */
+#ifndef	NULL
+#define	NULL	((void*) 0)
+#endif
+
+#ifndef	FALSE
+#define	FALSE	(0)
+#endif
+
+#ifndef	TRUE
+#define	TRUE	(!FALSE)
+#endif
+
+#undef	MAX
+#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
+
+#undef	MIN
+#define MIN(a, b)  (((a) < (b)) ? (a) : (b))
+
+#undef	ABS
+#define ABS(a)	   (((a) < 0) ? -(a) : (a))
+
+#undef	CLAMP
+#define CLAMP(x, low, high)  (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
+
+
+/* Define G_VA_COPY() to do the right thing for copying va_list variables.
+ * glibconfig.h may have already defined G_VA_COPY as va_copy or __va_copy.
+ */
+#if !defined (G_VA_COPY)
+#  if defined (__GNUC__) && defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32))
+#  define G_VA_COPY(ap1, ap2)	  (*(ap1) = *(ap2))
+#  elif defined (G_VA_COPY_AS_ARRAY)
+#  define G_VA_COPY(ap1, ap2)	  g_memmove ((ap1), (ap2), sizeof (va_list))
+#  else /* va_list is a pointer */
+#  define G_VA_COPY(ap1, ap2)	  ((ap1) = (ap2))
+#  endif /* va_list is a pointer */
+#endif /* !G_VA_COPY */
+
+
+/* Provide convenience macros for handling structure
+ * fields through their offsets.
+ */
+#define G_STRUCT_OFFSET(struct_type, member)	\
+    ((gulong) ((gchar*) &((struct_type*) 0)->member))
+#define G_STRUCT_MEMBER_P(struct_p, struct_offset)   \
+    ((gpointer) ((gchar*) (struct_p) + (gulong) (struct_offset)))
+#define G_STRUCT_MEMBER(member_type, struct_p, struct_offset)   \
+    (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset)))
+
+
+/* inlining hassle. for compilers that don't allow the `inline' keyword,
+ * mostly because of strict ANSI C compliance or dumbness, we try to fall
+ * back to either `__inline__' or `__inline'.
+ * we define G_CAN_INLINE, if the compiler seems to be actually
+ * *capable* to do function inlining, in which case inline function bodys
+ * do make sense. we also define G_INLINE_FUNC to properly export the
+ * function prototypes if no inlining can be performed.
+ * we special case most of the stuff, so inline functions can have a normal
+ * implementation by defining G_INLINE_FUNC to extern and G_CAN_INLINE to 1.
+ */
+#ifndef G_INLINE_FUNC
+#  define G_CAN_INLINE 1
+#endif
+#ifdef G_HAVE_INLINE
+#  if defined (__GNUC__) && defined (__STRICT_ANSI__)
+#    undef inline
+#    define inline __inline__
+#  endif
+#else /* !G_HAVE_INLINE */
+#  undef inline
+#  if defined (G_HAVE___INLINE__)
+#    define inline __inline__
+#  else /* !inline && !__inline__ */
+#    if defined (G_HAVE___INLINE)
+#      define inline __inline
+#    else /* !inline && !__inline__ && !__inline */
+#      define inline /* don't inline, then */
+#      ifndef G_INLINE_FUNC
+#	 undef G_CAN_INLINE
+#      endif
+#    endif
+#  endif
+#endif
+#ifndef G_INLINE_FUNC
+#  ifdef __GNUC__
+#    ifdef __OPTIMIZE__
+#      define G_INLINE_FUNC extern inline
+#    else
+#      undef G_CAN_INLINE
+#      define G_INLINE_FUNC extern
+#    endif
+#  else /* !__GNUC__ */
+#    ifdef G_CAN_INLINE
+#      define G_INLINE_FUNC static inline
+#    else
+#      define G_INLINE_FUNC extern
+#    endif
+#  endif /* !__GNUC__ */
+#endif /* !G_INLINE_FUNC */
+
+
+/* Provide simple macro statement wrappers (adapted from Perl):
+ *  G_STMT_START { statements; } G_STMT_END;
+ *  can be used as a single statement, as in
+ *  if (x) G_STMT_START { ... } G_STMT_END; else ...
+ *
+ *  For gcc we will wrap the statements within `({' and `})' braces.
+ *  For SunOS they will be wrapped within `if (1)' and `else (void) 0',
+ *  and otherwise within `do' and `while (0)'.
+ */
+#if !(defined (G_STMT_START) && defined (G_STMT_END))
+#  if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus)
+#    define G_STMT_START	(void)(
+#    define G_STMT_END		)
+#  else
+#    if (defined (sun) || defined (__sun__))
+#      define G_STMT_START	if (1)
+#      define G_STMT_END	else (void)0
+#    else
+#      define G_STMT_START	do
+#      define G_STMT_END	while (0)
+#    endif
+#  endif
+#endif
+
+
+/* Provide macros to feature the GCC function attribute.
+ */
+#if	__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
+#define G_GNUC_PRINTF( format_idx, arg_idx )	\
+  __attribute__((format (printf, format_idx, arg_idx)))
+#define G_GNUC_SCANF( format_idx, arg_idx )	\
+  __attribute__((format (scanf, format_idx, arg_idx)))
+#define G_GNUC_FORMAT( arg_idx )		\
+  __attribute__((format_arg (arg_idx)))
+#define G_GNUC_NORETURN				\
+  __attribute__((noreturn))
+#define G_GNUC_CONST				\
+  __attribute__((const))
+#define G_GNUC_UNUSED				\
+  __attribute__((unused))
+#else	/* !__GNUC__ */
+#define G_GNUC_PRINTF( format_idx, arg_idx )
+#define G_GNUC_SCANF( format_idx, arg_idx )
+#define G_GNUC_FORMAT( arg_idx )
+#define G_GNUC_NORETURN
+#define G_GNUC_CONST
+#define	G_GNUC_UNUSED
+#endif	/* !__GNUC__ */
+
+
+/* Wrap the gcc __PRETTY_FUNCTION__ and __FUNCTION__ variables with
+ * macros, so we can refer to them as strings unconditionally.
+ */
+#ifdef	__GNUC__
+#define	G_GNUC_FUNCTION		__FUNCTION__
+#define	G_GNUC_PRETTY_FUNCTION	__PRETTY_FUNCTION__
+#else	/* !__GNUC__ */
+#define	G_GNUC_FUNCTION		""
+#define	G_GNUC_PRETTY_FUNCTION	""
+#endif	/* !__GNUC__ */
+
+/* we try to provide a usefull equivalent for ATEXIT if it is
+ * not defined, but use is actually abandoned. people should
+ * use g_atexit() instead.
+ */
+#ifndef ATEXIT
+# define ATEXIT(proc)	g_ATEXIT(proc)
+#else
+# define G_NATIVE_ATEXIT
+#endif /* ATEXIT */
+
+/* Hacker macro to place breakpoints for elected machines.
+ * Actual use is strongly deprecated of course ;)
+ */
+#if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2
+#define	G_BREAKPOINT()		G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END
+#elif defined (__alpha__) && defined (__GNUC__) && __GNUC__ >= 2
+#define	G_BREAKPOINT()		G_STMT_START{ __asm__ __volatile__ ("bpt"); }G_STMT_END
+#else	/* !__i386__ && !__alpha__ */
+#define	G_BREAKPOINT()
+#endif	/* __i386__ */
+
+
+/* Provide macros for easily allocating memory. The macros
+ *  will cast the allocated memory to the specified type
+ *  in order to avoid compiler warnings. (Makes the code neater).
+ */
+
+#ifdef __DMALLOC_H__
+#  define g_new(type, count)		(ALLOC (type, count))
+#  define g_new0(type, count)		(CALLOC (type, count))
+#  define g_renew(type, mem, count)	(REALLOC (mem, type, count))
+#else /* __DMALLOC_H__ */
+#  define g_new(type, count)	  \
+      ((type *) g_malloc ((unsigned) sizeof (type) * (count)))
+#  define g_new0(type, count)	  \
+      ((type *) g_malloc0 ((unsigned) sizeof (type) * (count)))
+#  define g_renew(type, mem, count)	  \
+      ((type *) g_realloc (mem, (unsigned) sizeof (type) * (count)))
+#endif /* __DMALLOC_H__ */
+
+#define g_mem_chunk_create(type, pre_alloc, alloc_type)	( \
+  g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", \
+		   sizeof (type), \
+		   sizeof (type) * (pre_alloc), \
+		   (alloc_type)) \
+)
+#define g_chunk_new(type, chunk)	( \
+  (type *) g_mem_chunk_alloc (chunk) \
+)
+#define g_chunk_new0(type, chunk)	( \
+  (type *) g_mem_chunk_alloc0 (chunk) \
+)
+#define g_chunk_free(mem, mem_chunk)	G_STMT_START { \
+  g_mem_chunk_free ((mem_chunk), (mem)); \
+} G_STMT_END
+
+
+#define g_string(x) #x
+
+
+/* Provide macros for error handling. The "assert" macros will
+ *  exit on failure. The "return" macros will exit the current
+ *  function. Two different definitions are given for the macros
+ *  if G_DISABLE_ASSERT is not defined, in order to support gcc's
+ *  __PRETTY_FUNCTION__ capability.
+ */
+
+#ifdef G_DISABLE_ASSERT
+
+#define g_assert(expr)
+#define g_assert_not_reached()
+
+#else /* !G_DISABLE_ASSERT */
+
+#ifdef __GNUC__
+
+#define g_assert(expr)			G_STMT_START{		\
+     if (!(expr))						\
+       g_log (G_LOG_DOMAIN,					\
+	      G_LOG_LEVEL_ERROR,				\
+	      "file %s: line %d (%s): assertion failed: (%s)",	\
+	      __FILE__,						\
+	      __LINE__,						\
+	      __PRETTY_FUNCTION__,				\
+	      #expr);			}G_STMT_END
+
+#define g_assert_not_reached()		G_STMT_START{		\
+     g_log (G_LOG_DOMAIN,					\
+	    G_LOG_LEVEL_ERROR,					\
+	    "file %s: line %d (%s): should not be reached",	\
+	    __FILE__,						\
+	    __LINE__,						\
+	    __PRETTY_FUNCTION__);	}G_STMT_END
+
+#else /* !__GNUC__ */
+
+#define g_assert(expr)			G_STMT_START{		\
+     if (!(expr))						\
+       g_log (G_LOG_DOMAIN,					\
+	      G_LOG_LEVEL_ERROR,				\
+	      "file %s: line %d: assertion failed: (%s)",	\
+	      __FILE__,						\
+	      __LINE__,						\
+	      #expr);			}G_STMT_END
+
+#define g_assert_not_reached()		G_STMT_START{	\
+     g_log (G_LOG_DOMAIN,				\
+	    G_LOG_LEVEL_ERROR,				\
+	    "file %s: line %d: should not be reached",	\
+	    __FILE__,					\
+	    __LINE__);		}G_STMT_END
+
+#endif /* __GNUC__ */
+
+#endif /* !G_DISABLE_ASSERT */
+
+
+#ifdef __KORBIT__
+
+#define g_return_if_fail(expr)		G_STMT_START{			\
+     if (!(expr))							\
+       {								\
+	 return;							\
+       };				}G_STMT_END
+
+#define g_return_val_if_fail(expr,val)	G_STMT_START{			\
+     if (!(expr))							\
+       {								\
+	 return val;							\
+       };				}G_STMT_END
+
+#else /* !__KORBIT__ */
+
+#ifdef G_DISABLE_CHECKS
+
+#define g_return_if_fail(expr)
+#define g_return_val_if_fail(expr,val)
+
+#else /* !G_DISABLE_CHECKS */
+
+#ifdef __GNUC__
+
+#define g_return_if_fail(expr)		G_STMT_START{			\
+     if (!(expr))							\
+       {								\
+	 g_log (G_LOG_DOMAIN,						\
+		G_LOG_LEVEL_CRITICAL,					\
+		"file %s: line %d (%s): assertion `%s' failed.",	\
+		__FILE__,						\
+		__LINE__,						\
+		__PRETTY_FUNCTION__,					\
+		#expr);							\
+	 return;							\
+       };				}G_STMT_END
+
+#define g_return_val_if_fail(expr,val)	G_STMT_START{			\
+     if (!(expr))							\
+       {								\
+	 g_log (G_LOG_DOMAIN,						\
+		G_LOG_LEVEL_CRITICAL,					\
+		"file %s: line %d (%s): assertion `%s' failed.",	\
+		__FILE__,						\
+		__LINE__,						\
+		__PRETTY_FUNCTION__,					\
+		#expr);							\
+	 return val;							\
+       };				}G_STMT_END
+
+#else /* !__GNUC__ */
+
+#define g_return_if_fail(expr)		G_STMT_START{		\
+     if (!(expr))						\
+       {							\
+	 g_log (G_LOG_DOMAIN,					\
+		G_LOG_LEVEL_CRITICAL,				\
+		"file %s: line %d: assertion `%s' failed.",	\
+		__FILE__,					\
+		__LINE__,					\
+		#expr);						\
+	 return;						\
+       };				}G_STMT_END
+
+#define g_return_val_if_fail(expr, val)	G_STMT_START{		\
+     if (!(expr))						\
+       {							\
+	 g_log (G_LOG_DOMAIN,					\
+		G_LOG_LEVEL_CRITICAL,				\
+		"file %s: line %d: assertion `%s' failed.",	\
+		__FILE__,					\
+		__LINE__,					\
+		#expr);						\
+	 return val;						\
+       };				}G_STMT_END
+
+#endif /* !__GNUC__ */
+
+#endif /* !G_DISABLE_CHECKS */
+
+#endif /* !__KORBIT__ */
+
+
+/* Provide type definitions for commonly used types.
+ *  These are useful because a "gint8" can be adjusted
+ *  to be 1 byte (8 bits) on all platforms. Similarly and
+ *  more importantly, "gint32" can be adjusted to be
+ *  4 bytes (32 bits) on all platforms.
+ */
+
+typedef char   gchar;
+typedef short  gshort;
+typedef long   glong;
+typedef int    gint;
+typedef gint   gboolean;
+
+typedef unsigned char	guchar;
+typedef unsigned short	gushort;
+typedef unsigned long	gulong;
+typedef unsigned int	guint;
+
+typedef float	gfloat;
+typedef double	gdouble;
+
+/* HAVE_LONG_DOUBLE doesn't work correctly on all platforms.
+ * Since gldouble isn't used anywhere, just disable it for now */
+
+#if 0
+#ifdef HAVE_LONG_DOUBLE
+typedef long double gldouble;
+#else /* HAVE_LONG_DOUBLE */
+typedef double gldouble;
+#endif /* HAVE_LONG_DOUBLE */
+#endif /* 0 */
+
+typedef void* gpointer;
+typedef const void *gconstpointer;
+
+
+typedef gint32	gssize;
+typedef guint32 gsize;
+typedef guint32 GQuark;
+typedef gint32	GTime;
+
+
+/* Portable endian checks and conversions
+ *
+ * glibconfig.h defines G_BYTE_ORDER which expands to one of
+ * the below macros.
+ */
+#define G_LITTLE_ENDIAN 1234
+#define G_BIG_ENDIAN    4321
+#define G_PDP_ENDIAN    3412		/* unused, need specific PDP check */	
+
+
+/* Basic bit swapping functions
+ */
+#define GUINT16_SWAP_LE_BE_CONSTANT(val)	((guint16) ( \
+    (((guint16) (val) & (guint16) 0x00ffU) << 8) | \
+    (((guint16) (val) & (guint16) 0xff00U) >> 8)))
+#define GUINT32_SWAP_LE_BE_CONSTANT(val)	((guint32) ( \
+    (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \
+    (((guint32) (val) & (guint32) 0x0000ff00U) <<  8) | \
+    (((guint32) (val) & (guint32) 0x00ff0000U) >>  8) | \
+    (((guint32) (val) & (guint32) 0xff000000U) >> 24)))
+
+/* Intel specific stuff for speed
+ */
+#if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2
+#  define GUINT16_SWAP_LE_BE_X86(val) \
+     (__extension__					\
+      ({ register guint16 __v;				\
+	 if (__builtin_constant_p (val))		\
+	   __v = GUINT16_SWAP_LE_BE_CONSTANT (val);	\
+	 else						\
+	   __asm__ __const__ ("rorw $8, %w0"		\
+			      : "=r" (__v)		\
+			      : "0" ((guint16) (val)));	\
+	__v; }))
+#  define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_X86 (val))
+#  if !defined(__i486__) && !defined(__i586__) \
+      && !defined(__pentium__) && !defined(__i686__) && !defined(__pentiumpro__)
+#     define GUINT32_SWAP_LE_BE_X86(val) \
+        (__extension__						\
+         ({ register guint32 __v;				\
+	    if (__builtin_constant_p (val))			\
+	      __v = GUINT32_SWAP_LE_BE_CONSTANT (val);		\
+	  else							\
+	    __asm__ __const__ ("rorw $8, %w0\n\t"		\
+			       "rorl $16, %0\n\t"		\
+			       "rorw $8, %w0"			\
+			       : "=r" (__v)			\
+			       : "0" ((guint32) (val)));	\
+	__v; }))
+#  else /* 486 and higher has bswap */
+#     define GUINT32_SWAP_LE_BE_X86(val) \
+        (__extension__						\
+         ({ register guint32 __v;				\
+	    if (__builtin_constant_p (val))			\
+	      __v = GUINT32_SWAP_LE_BE_CONSTANT (val);		\
+	  else							\
+	    __asm__ __const__ ("bswap %0"			\
+			       : "=r" (__v)			\
+			       : "0" ((guint32) (val)));	\
+	__v; }))
+#  endif /* processor specific 32-bit stuff */
+#  define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86 (val))
+#else /* !__i386__ */
+#  define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val))
+#  define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_CONSTANT (val))
+#endif /* __i386__ */
+
+#ifdef G_HAVE_GINT64
+#  define GUINT64_SWAP_LE_BE_CONSTANT(val)	((guint64) ( \
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0x00000000000000ffU)) << 56) |	\
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0x000000000000ff00U)) << 40) |	\
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0x0000000000ff0000U)) << 24) |	\
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0x00000000ff000000U)) <<  8) |	\
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0x000000ff00000000U)) >>  8) |	\
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0x0000ff0000000000U)) >> 24) |	\
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0x00ff000000000000U)) >> 40) |	\
+      (((guint64) (val) &						\
+	(guint64) G_GINT64_CONSTANT(0xff00000000000000U)) >> 56)))
+#  if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2
+#    define GUINT64_SWAP_LE_BE_X86(val) \
+	(__extension__						\
+	 ({ union { guint64 __ll;				\
+		    guint32 __l[2]; } __r;			\
+	    if (__builtin_constant_p (val))			\
+	      __r.__ll = GUINT64_SWAP_LE_BE_CONSTANT (val);	\
+	    else						\
+	      {							\
+	 	union { guint64 __ll;				\
+			guint32 __l[2]; } __w;			\
+		__w.__ll = ((guint64) val);			\
+		__r.__l[0] = GUINT32_SWAP_LE_BE (__w.__l[1]);	\
+		__r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]);	\
+	      }							\
+	  __r.__ll; }))
+#    define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86 (val))
+#  else /* !__i386__ */
+#    define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_CONSTANT(val))
+#  endif
+#endif
+
+#define GUINT16_SWAP_LE_PDP(val)	((guint16) (val))
+#define GUINT16_SWAP_BE_PDP(val)	(GUINT16_SWAP_LE_BE (val))
+#define GUINT32_SWAP_LE_PDP(val)	((guint32) ( \
+    (((guint32) (val) & (guint32) 0x0000ffffU) << 16) | \
+    (((guint32) (val) & (guint32) 0xffff0000U) >> 16)))
+#define GUINT32_SWAP_BE_PDP(val)	((guint32) ( \
+    (((guint32) (val) & (guint32) 0x00ff00ffU) << 8) | \
+    (((guint32) (val) & (guint32) 0xff00ff00U) >> 8)))
+
+/* The G*_TO_?E() macros are defined in glibconfig.h.
+ * The transformation is symmetric, so the FROM just maps to the TO.
+ */
+#define GINT16_FROM_LE(val)	(GINT16_TO_LE (val))
+#define GUINT16_FROM_LE(val)	(GUINT16_TO_LE (val))
+#define GINT16_FROM_BE(val)	(GINT16_TO_BE (val))
+#define GUINT16_FROM_BE(val)	(GUINT16_TO_BE (val))
+#define GINT32_FROM_LE(val)	(GINT32_TO_LE (val))
+#define GUINT32_FROM_LE(val)	(GUINT32_TO_LE (val))
+#define GINT32_FROM_BE(val)	(GINT32_TO_BE (val))
+#define GUINT32_FROM_BE(val)	(GUINT32_TO_BE (val))
+
+#ifdef G_HAVE_GINT64
+#define GINT64_FROM_LE(val)	(GINT64_TO_LE (val))
+#define GUINT64_FROM_LE(val)	(GUINT64_TO_LE (val))
+#define GINT64_FROM_BE(val)	(GINT64_TO_BE (val))
+#define GUINT64_FROM_BE(val)	(GUINT64_TO_BE (val))
+#endif
+
+#define GLONG_FROM_LE(val)	(GLONG_TO_LE (val))
+#define GULONG_FROM_LE(val)	(GULONG_TO_LE (val))
+#define GLONG_FROM_BE(val)	(GLONG_TO_BE (val))
+#define GULONG_FROM_BE(val)	(GULONG_TO_BE (val))
+
+#define GINT_FROM_LE(val)	(GINT_TO_LE (val))
+#define GUINT_FROM_LE(val)	(GUINT_TO_LE (val))
+#define GINT_FROM_BE(val)	(GINT_TO_BE (val))
+#define GUINT_FROM_BE(val)	(GUINT_TO_BE (val))
+
+
+/* Portable versions of host-network order stuff
+ */
+#define g_ntohl(val) (GUINT32_FROM_BE (val))
+#define g_ntohs(val) (GUINT16_FROM_BE (val))
+#define g_htonl(val) (GUINT32_TO_BE (val))
+#define g_htons(val) (GUINT16_TO_BE (val))
+
+
+/* Glib version.
+ * we prefix variable declarations so they can
+ * properly get exported in windows dlls.
+ */
+#define GUTILS_C_VAR extern
+
+
+GUTILS_C_VAR const guint glib_major_version;
+GUTILS_C_VAR const guint glib_minor_version;
+GUTILS_C_VAR const guint glib_micro_version;
+GUTILS_C_VAR const guint glib_interface_age;
+GUTILS_C_VAR const guint glib_binary_age;
+
+#define GLIB_CHECK_VERSION(major,minor,micro)    \
+    (GLIB_MAJOR_VERSION > (major) || \
+     (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) || \
+     (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && \
+      GLIB_MICRO_VERSION >= (micro)))
+
+/* Forward declarations of glib types.
+ */
+typedef struct _GAllocator	GAllocator;
+typedef struct _GArray		GArray;
+typedef struct _GByteArray	GByteArray;
+typedef struct _GDebugKey	GDebugKey;
+typedef struct _GHashTable	GHashTable;
+typedef struct _GList		GList;
+typedef struct _GMemChunk	GMemChunk;
+typedef struct _GNode		GNode;
+typedef struct _GPtrArray	GPtrArray;
+typedef struct _GSList		GSList;
+typedef struct _GString		GString;
+typedef struct _GStringChunk	GStringChunk;
+typedef struct _GTree		GTree;
+typedef struct _GTuples		GTuples;
+
+/* Tree traverse flags */
+typedef enum
+{
+  G_TRAVERSE_LEAFS	= 1 << 0,
+  G_TRAVERSE_NON_LEAFS	= 1 << 1,
+  G_TRAVERSE_ALL	= G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS,
+  G_TRAVERSE_MASK	= 0x03
+} GTraverseFlags;
+
+/* Tree traverse orders */
+typedef enum
+{
+  G_IN_ORDER,
+  G_PRE_ORDER,
+  G_POST_ORDER,
+  G_LEVEL_ORDER
+} GTraverseType;
+
+/* Log level shift offset for user defined
+ * log levels (0-7 are used by GLib).
+ */
+#define	G_LOG_LEVEL_USER_SHIFT	(8)
+
+/* Glib log levels and flags.
+ */
+typedef enum
+{
+  /* log flags */
+  G_LOG_FLAG_RECURSION		= 1 << 0,
+  G_LOG_FLAG_FATAL		= 1 << 1,
+  
+  /* GLib log levels */
+  G_LOG_LEVEL_ERROR		= 1 << 2,	/* always fatal */
+  G_LOG_LEVEL_CRITICAL		= 1 << 3,
+  G_LOG_LEVEL_WARNING		= 1 << 4,
+  G_LOG_LEVEL_MESSAGE		= 1 << 5,
+  G_LOG_LEVEL_INFO		= 1 << 6,
+  G_LOG_LEVEL_DEBUG		= 1 << 7,
+  
+  G_LOG_LEVEL_MASK		= ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
+} GLogLevelFlags;
+
+/* GLib log levels that are considered fatal by default */
+#define	G_LOG_FATAL_MASK	(G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR)
+
+
+typedef gint		(*GCompareFunc)		(gconstpointer	a,
+						 gconstpointer	b);
+typedef gchar*		(*GCompletionFunc)	(gpointer);
+typedef void		(*GDestroyNotify)	(gpointer	data);
+typedef void		(*GDataForeachFunc)	(GQuark		key_id,
+						 gpointer	data,
+						 gpointer	user_data);
+typedef void		(*GFunc)		(gpointer	data,
+						 gpointer	user_data);
+typedef guint		(*GHashFunc)		(gconstpointer	key);
+typedef void		(*GFreeFunc)		(gpointer	data);
+typedef void		(*GHFunc)		(gpointer	key,
+						 gpointer	value,
+						 gpointer	user_data);
+typedef gboolean	(*GHRFunc)		(gpointer	key,
+						 gpointer	value,
+						 gpointer	user_data);
+typedef void		(*GLogFunc)		(const gchar   *log_domain,
+						 GLogLevelFlags	log_level,
+						 const gchar   *message,
+						 gpointer	user_data);
+typedef gboolean	(*GNodeTraverseFunc)	(GNode	       *node,
+						 gpointer	data);
+typedef void		(*GNodeForeachFunc)	(GNode	       *node,
+						 gpointer	data);
+typedef gint		(*GSearchFunc)		(gpointer	key,
+						 gpointer	data);
+typedef gint		(*GTraverseFunc)	(gpointer	key,
+						 gpointer	value,
+						 gpointer	data);
+typedef	void		(*GVoidFunc)		(void);
+
+
+struct _GList
+{
+  gpointer data;
+  GList *next;
+  GList *prev;
+};
+
+struct _GSList
+{
+  gpointer data;
+  GSList *next;
+};
+
+struct _GString
+{
+  gchar *str;
+  gint len;
+};
+
+struct _GArray
+{
+  gchar *data;
+  guint len;
+};
+
+struct _GByteArray
+{
+  guint8 *data;
+  guint	  len;
+};
+
+struct _GPtrArray
+{
+  gpointer *pdata;
+  guint	    len;
+};
+
+struct _GTuples
+{
+  guint len;
+};
+
+struct _GDebugKey
+{
+  gchar *key;
+  guint	 value;
+};
+
+
+/* Doubly linked lists
+ */
+void   g_list_push_allocator    (GAllocator     *allocator);
+void   g_list_pop_allocator     (void);
+GList* g_list_alloc		(void);
+void   g_list_free		(GList		*list);
+void   g_list_free_1		(GList		*list);
+GList* g_list_append		(GList		*list,
+				 gpointer	 data);
+GList* g_list_prepend		(GList		*list,
+				 gpointer	 data);
+GList* g_list_insert		(GList		*list,
+				 gpointer	 data,
+				 gint		 position);
+GList* g_list_insert_sorted	(GList		*list,
+				 gpointer	 data,
+				 GCompareFunc	 func);
+GList* g_list_concat		(GList		*list1,
+				 GList		*list2);
+GList* g_list_remove		(GList		*list,
+				 gpointer	 data);
+GList* g_list_remove_link	(GList		*list,
+				 GList		*llink);
+GList* g_list_reverse		(GList		*list);
+GList* g_list_copy		(GList		*list);
+GList* g_list_nth		(GList		*list,
+				 guint		 n);
+GList* g_list_find		(GList		*list,
+				 gpointer	 data);
+GList* g_list_find_custom	(GList		*list,
+				 gpointer	 data,
+				 GCompareFunc	 func);
+gint   g_list_position		(GList		*list,
+				 GList		*llink);
+gint   g_list_index		(GList		*list,
+				 gpointer	 data);
+GList* g_list_last		(GList		*list);
+GList* g_list_first		(GList		*list);
+guint  g_list_length		(GList		*list);
+void   g_list_foreach		(GList		*list,
+				 GFunc		 func,
+				 gpointer	 user_data);
+GList* g_list_sort              (GList          *list,
+		                 GCompareFunc    compare_func);
+gpointer g_list_nth_data	(GList		*list,
+				 guint		 n);
+#define g_list_previous(list)	((list) ? (((GList *)(list))->prev) : NULL)
+#define g_list_next(list)	((list) ? (((GList *)(list))->next) : NULL)
+
+
+/* Singly linked lists
+ */
+void    g_slist_push_allocator  (GAllocator     *allocator);
+void    g_slist_pop_allocator   (void);
+GSList* g_slist_alloc		(void);
+void	g_slist_free		(GSList		*list);
+void	g_slist_free_1		(GSList		*list);
+GSList* g_slist_append		(GSList		*list,
+				 gpointer	 data);
+GSList* g_slist_prepend		(GSList		*list,
+				 gpointer	 data);
+GSList* g_slist_insert		(GSList		*list,
+				 gpointer	 data,
+				 gint		 position);
+GSList* g_slist_insert_sorted	(GSList		*list,
+				 gpointer	 data,
+				 GCompareFunc	 func);
+GSList* g_slist_concat		(GSList		*list1,
+				 GSList		*list2);
+GSList* g_slist_remove		(GSList		*list,
+				 gpointer	 data);
+GSList* g_slist_remove_link	(GSList		*list,
+				 GSList		*llink);
+GSList* g_slist_reverse		(GSList		*list);
+GSList*	g_slist_copy		(GSList		*list);
+GSList* g_slist_nth		(GSList		*list,
+				 guint		 n);
+GSList* g_slist_find		(GSList		*list,
+				 gpointer	 data);
+GSList* g_slist_find_custom	(GSList		*list,
+				 gpointer	 data,
+				 GCompareFunc	 func);
+gint	g_slist_position	(GSList		*list,
+				 GSList		*llink);
+gint	g_slist_index		(GSList		*list,
+				 gpointer	 data);
+GSList* g_slist_last		(GSList		*list);
+guint	g_slist_length		(GSList		*list);
+void	g_slist_foreach		(GSList		*list,
+				 GFunc		 func,
+				 gpointer	 user_data);
+GSList*  g_slist_sort           (GSList          *list,
+		                 GCompareFunc    compare_func);
+gpointer g_slist_nth_data	(GSList		*list,
+				 guint		 n);
+#define g_slist_next(slist)	((slist) ? (((GSList *)(slist))->next) : NULL)
+
+
+/* Hash tables
+ */
+GHashTable* g_hash_table_new		(GHashFunc	 hash_func,
+					 GCompareFunc	 key_compare_func);
+void	    g_hash_table_destroy	(GHashTable	*hash_table);
+void	    g_hash_table_insert		(GHashTable	*hash_table,
+					 gpointer	 key,
+					 gpointer	 value);
+void	    g_hash_table_remove		(GHashTable	*hash_table,
+					 gconstpointer	 key);
+gpointer    g_hash_table_lookup		(GHashTable	*hash_table,
+					 gconstpointer	 key);
+gboolean    g_hash_table_lookup_extended(GHashTable	*hash_table,
+					 gconstpointer	 lookup_key,
+					 gpointer	*orig_key,
+					 gpointer	*value);
+void	    g_hash_table_freeze		(GHashTable	*hash_table);
+void	    g_hash_table_thaw		(GHashTable	*hash_table);
+void	    g_hash_table_foreach	(GHashTable	*hash_table,
+					 GHFunc		 func,
+					 gpointer	 user_data);
+guint	    g_hash_table_foreach_remove	(GHashTable	*hash_table,
+					 GHRFunc	 func,
+					 gpointer	 user_data);
+guint	    g_hash_table_size		(GHashTable	*hash_table);
+
+
+
+
+/* Balanced binary trees
+ */
+GTree*	 g_tree_new	 (GCompareFunc	 key_compare_func);
+void	 g_tree_destroy	 (GTree		*tree);
+void	 g_tree_insert	 (GTree		*tree,
+			  gpointer	 key,
+			  gpointer	 value);
+void	 g_tree_remove	 (GTree		*tree,
+			  gpointer	 key);
+gpointer g_tree_lookup	 (GTree		*tree,
+			  gpointer	 key);
+void	 g_tree_traverse (GTree		*tree,
+			  GTraverseFunc	 traverse_func,
+			  GTraverseType	 traverse_type,
+			  gpointer	 data);
+gpointer g_tree_search	 (GTree		*tree,
+			  GSearchFunc	 search_func,
+			  gpointer	 data);
+gint	 g_tree_height	 (GTree		*tree);
+gint	 g_tree_nnodes	 (GTree		*tree);
+
+
+
+/* N-way tree implementation
+ */
+struct _GNode
+{
+  gpointer data;
+  GNode	  *next;
+  GNode	  *prev;
+  GNode	  *parent;
+  GNode	  *children;
+};
+
+#define	 G_NODE_IS_ROOT(node)	(((GNode*) (node))->parent == NULL && \
+				 ((GNode*) (node))->prev == NULL && \
+				 ((GNode*) (node))->next == NULL)
+#define	 G_NODE_IS_LEAF(node)	(((GNode*) (node))->children == NULL)
+
+void     g_node_push_allocator  (GAllocator       *allocator);
+void     g_node_pop_allocator   (void);
+GNode*	 g_node_new		(gpointer	   data);
+void	 g_node_destroy		(GNode		  *root);
+void	 g_node_unlink		(GNode		  *node);
+GNode*	 g_node_insert		(GNode		  *parent,
+				 gint		   position,
+				 GNode		  *node);
+GNode*	 g_node_insert_before	(GNode		  *parent,
+				 GNode		  *sibling,
+				 GNode		  *node);
+GNode*	 g_node_prepend		(GNode		  *parent,
+				 GNode		  *node);
+guint	 g_node_n_nodes		(GNode		  *root,
+				 GTraverseFlags	   flags);
+GNode*	 g_node_get_root	(GNode		  *node);
+gboolean g_node_is_ancestor	(GNode		  *node,
+				 GNode		  *descendant);
+guint	 g_node_depth		(GNode		  *node);
+GNode*	 g_node_find		(GNode		  *root,
+				 GTraverseType	   order,
+				 GTraverseFlags	   flags,
+				 gpointer	   data);
+
+/* convenience macros */
+#define g_node_append(parent, node)				\
+     g_node_insert_before ((parent), NULL, (node))
+#define	g_node_insert_data(parent, position, data)		\
+     g_node_insert ((parent), (position), g_node_new (data))
+#define	g_node_insert_data_before(parent, sibling, data)	\
+     g_node_insert_before ((parent), (sibling), g_node_new (data))
+#define	g_node_prepend_data(parent, data)			\
+     g_node_prepend ((parent), g_node_new (data))
+#define	g_node_append_data(parent, data)			\
+     g_node_insert_before ((parent), NULL, g_node_new (data))
+
+/* traversal function, assumes that `node' is root
+ * (only traverses `node' and its subtree).
+ * this function is just a high level interface to
+ * low level traversal functions, optimized for speed.
+ */
+void	 g_node_traverse	(GNode		  *root,
+				 GTraverseType	   order,
+				 GTraverseFlags	   flags,
+				 gint		   max_depth,
+				 GNodeTraverseFunc func,
+				 gpointer	   data);
+
+/* return the maximum tree height starting with `node', this is an expensive
+ * operation, since we need to visit all nodes. this could be shortened by
+ * adding `guint height' to struct _GNode, but then again, this is not very
+ * often needed, and would make g_node_insert() more time consuming.
+ */
+guint	 g_node_max_height	 (GNode *root);
+
+void	 g_node_children_foreach (GNode		  *node,
+				  GTraverseFlags   flags,
+				  GNodeForeachFunc func,
+				  gpointer	   data);
+void	 g_node_reverse_children (GNode		  *node);
+guint	 g_node_n_children	 (GNode		  *node);
+GNode*	 g_node_nth_child	 (GNode		  *node,
+				  guint		   n);
+GNode*	 g_node_last_child	 (GNode		  *node);
+GNode*	 g_node_find_child	 (GNode		  *node,
+				  GTraverseFlags   flags,
+				  gpointer	   data);
+gint	 g_node_child_position	 (GNode		  *node,
+				  GNode		  *child);
+gint	 g_node_child_index	 (GNode		  *node,
+				  gpointer	   data);
+
+GNode*	 g_node_first_sibling	 (GNode		  *node);
+GNode*	 g_node_last_sibling	 (GNode		  *node);
+
+#define	 g_node_prev_sibling(node)	((node) ? \
+					 ((GNode*) (node))->prev : NULL)
+#define	 g_node_next_sibling(node)	((node) ? \
+					 ((GNode*) (node))->next : NULL)
+#define	 g_node_first_child(node)	((node) ? \
+					 ((GNode*) (node))->children : NULL)
+
+
+
+/* Fatal error handlers.
+ * g_on_error_query() will prompt the user to either
+ * [E]xit, [H]alt, [P]roceed or show [S]tack trace.
+ * g_on_error_stack_trace() invokes gdb, which attaches to the current
+ * process and shows a stack trace.
+ * These function may cause different actions on non-unix platforms.
+ * The prg_name arg is required by gdb to find the executable, if it is
+ * passed as NULL, g_on_error_query() will try g_get_prgname().
+ */
+void g_on_error_query (const gchar *prg_name);
+void g_on_error_stack_trace (const gchar *prg_name);
+
+
+/* Logging mechanism
+ */
+extern	        const gchar		*g_log_domain_glib;
+guint		g_log_set_handler	(const gchar	*log_domain,
+					 GLogLevelFlags	 log_levels,
+					 GLogFunc	 log_func,
+					 gpointer	 user_data);
+void		g_log_remove_handler	(const gchar	*log_domain,
+					 guint		 handler_id);
+void		g_log_default_handler	(const gchar	*log_domain,
+					 GLogLevelFlags	 log_level,
+					 const gchar	*message,
+					 gpointer	 unused_data);
+#ifdef __KORBIT__
+#define g_log(log_domain, log_level, format, args...) \
+G_STMT_START { printf(format, ##args); printf("\n"); } G_STMT_END
+#define g_logv(log_domain, log_level, format, args...)
+#else /* !__KORBIT__ */
+void		g_log			(const gchar	*log_domain,
+					 GLogLevelFlags	 log_level,
+					 const gchar	*format,
+					 ...) G_GNUC_PRINTF (3, 4);
+void		g_logv			(const gchar	*log_domain,
+					 GLogLevelFlags	 log_level,
+					 const gchar	*format,
+					 va_list	 args);
+#endif /* !__KORBIT__ */
+GLogLevelFlags	g_log_set_fatal_mask	(const gchar	*log_domain,
+					 GLogLevelFlags	 fatal_mask);
+GLogLevelFlags	g_log_set_always_fatal	(GLogLevelFlags	 fatal_mask);
+#ifndef	G_LOG_DOMAIN
+#define	G_LOG_DOMAIN	((gchar*) 0)
+#endif	/* G_LOG_DOMAIN */
+#ifdef	__GNUC__
+#define	g_error(format, args...)	g_log (G_LOG_DOMAIN, \
+					       G_LOG_LEVEL_ERROR, \
+					       format, ##args)
+#define	g_message(format, args...)	g_log (G_LOG_DOMAIN, \
+					       G_LOG_LEVEL_MESSAGE, \
+					       format, ##args)
+#define	g_warning(format, args...)	g_log (G_LOG_DOMAIN, \
+					       G_LOG_LEVEL_WARNING, \
+					       format, ##args)
+#else	/* !__GNUC__ */
+static void
+g_error (const gchar *format,
+	 ...)
+{
+  va_list args;
+  va_start (args, format);
+  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
+  va_end (args);
+}
+static void
+g_message (const gchar *format,
+	   ...)
+{
+  va_list args;
+  va_start (args, format);
+  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, args);
+  va_end (args);
+}
+static void
+g_warning (const gchar *format,
+	   ...)
+{
+  va_list args;
+  va_start (args, format);
+  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, args);
+  va_end (args);
+}
+#endif	/* !__GNUC__ */
+
+typedef void	(*GPrintFunc)		(const gchar	*string);
+#ifdef __KORBIT__
+#define g_print(format, args...) printf(format, ##args)
+#else
+void		g_print			(const gchar	*format,
+					 ...) G_GNUC_PRINTF (1, 2);
+#endif
+GPrintFunc	g_set_print_handler	(GPrintFunc	 func);
+void		g_printerr		(const gchar	*format,
+					 ...) G_GNUC_PRINTF (1, 2);
+GPrintFunc	g_set_printerr_handler	(GPrintFunc	 func);
+
+/* deprecated compatibility functions, use g_log_set_handler() instead */
+typedef void		(*GErrorFunc)		(const gchar *str);
+typedef void		(*GWarningFunc)		(const gchar *str);
+GErrorFunc   g_set_error_handler   (GErrorFunc	 func);
+GWarningFunc g_set_warning_handler (GWarningFunc func);
+GPrintFunc   g_set_message_handler (GPrintFunc func);
+
+
+gpointer g_malloc      (gulong	  size);
+gpointer g_malloc0     (gulong	  size);
+gpointer g_realloc     (gpointer  mem,
+			gulong	  size);
+void	 g_free	       (gpointer  mem);
+
+/* Generic allocators
+ */
+GAllocator* g_allocator_new   (const gchar  *name,
+			       guint         n_preallocs);
+void        g_allocator_free  (GAllocator   *allocator);
+
+#define	G_ALLOCATOR_LIST	(1)
+#define	G_ALLOCATOR_SLIST	(2)
+#define	G_ALLOCATOR_NODE	(3)
+
+
+/* "g_mem_chunk_new" creates a new memory chunk.
+ * Memory chunks are used to allocate pieces of memory which are
+ *  always the same size. Lists are a good example of such a data type.
+ * The memory chunk allocates and frees blocks of memory as needed.
+ *  Just be sure to call "g_mem_chunk_free" and not "g_free" on data
+ *  allocated in a mem chunk. ("g_free" will most likely cause a seg
+ *  fault...somewhere).
+ *
+ * Oh yeah, GMemChunk is an opaque data type. (You don't really
+ *  want to know what's going on inside do you?)
+ */
+
+/* ALLOC_ONLY MemChunk's can only allocate memory. The free operation
+ *  is interpreted as a no op. ALLOC_ONLY MemChunk's save 4 bytes per
+ *  atom. (They are also useful for lists which use MemChunk to allocate
+ *  memory but are also part of the MemChunk implementation).
+ * ALLOC_AND_FREE MemChunk's can allocate and free memory.
+ */
+
+#define G_ALLOC_ONLY	  1
+#define G_ALLOC_AND_FREE  2
+
+GMemChunk* g_mem_chunk_new     (gchar	  *name,
+				gint	   atom_size,
+				gulong	   area_size,
+				gint	   type);
+void	   g_mem_chunk_destroy (GMemChunk *mem_chunk);
+gpointer   g_mem_chunk_alloc   (GMemChunk *mem_chunk);
+gpointer   g_mem_chunk_alloc0  (GMemChunk *mem_chunk);
+void	   g_mem_chunk_free    (GMemChunk *mem_chunk,
+				gpointer   mem);
+void	   g_mem_chunk_clean   (GMemChunk *mem_chunk);
+void	   g_mem_chunk_reset   (GMemChunk *mem_chunk);
+void	   g_mem_chunk_print   (GMemChunk *mem_chunk);
+void	   g_mem_chunk_info    (void);
+
+/* Ah yes...we have a "g_blow_chunks" function.
+ * "g_blow_chunks" simply compresses all the chunks. This operation
+ *  consists of freeing every memory area that should be freed (but
+ *  which we haven't gotten around to doing yet). And, no,
+ *  "g_blow_chunks" doesn't follow the naming scheme, but it is a
+ *  much better name than "g_mem_chunk_clean_all" or something
+ *  similar.
+ */
+void g_blow_chunks (void);
+
+
+/* String utility functions that modify a string argument or
+ * return a constant string that must not be freed.
+ */
+#define	 G_STR_DELIMITERS	"_-|> <."
+gchar*	 g_strdelimit		(gchar	     *string,
+				 const gchar *delimiters,
+				 gchar	      new_delimiter);
+#ifndef __KORBIT__
+gdouble	 g_strtod		(const gchar *nptr,
+				 gchar	    **endptr);
+#endif /* !__KORBIT__ */
+gchar*	 g_strerror		(gint	      errnum);
+gchar*	 g_strsignal		(gint	      signum);
+gint	 g_strcasecmp		(const gchar *s1,
+				 const gchar *s2);
+gint	 g_strncasecmp		(const gchar *s1,
+				 const gchar *s2,
+				 guint 	      n);
+void	 g_strdown		(gchar	     *string);
+void	 g_strup		(gchar	     *string);
+void	 g_strreverse		(gchar	     *string);
+/* removes leading spaces */
+gchar*   g_strchug              (gchar        *string);
+/* removes trailing spaces */
+gchar*  g_strchomp              (gchar        *string);
+/* removes leading & trailing spaces */
+#define g_strstrip( string )	g_strchomp (g_strchug (string))
+
+/* String utility functions that return a newly allocated string which
+ * ought to be freed from the caller at some point.
+ */
+gchar*	 g_strdup		(const gchar *str);
+gchar*	 g_strdup_printf	(const gchar *format,
+				 ...) G_GNUC_PRINTF (1, 2);
+gchar*	 g_strdup_vprintf	(const gchar *format,
+				 va_list      args);
+gchar*	 g_strndup		(const gchar *str,
+				 guint	      n);
+gchar*	 g_strnfill		(guint	      length,
+				 gchar	      fill_char);
+gchar*	 g_strconcat		(const gchar *string1,
+				 ...); /* NULL terminated */
+gchar*   g_strjoin		(const gchar  *separator,
+				 ...); /* NULL terminated */
+gchar*	 g_strescape		(gchar	      *string);
+gpointer g_memdup		(gconstpointer mem,
+				 guint	       byte_size);
+
+/* NULL terminated string arrays.
+ * g_strsplit() splits up string into max_tokens tokens at delim and
+ * returns a newly allocated string array.
+ * g_strjoinv() concatenates all of str_array's strings, sliding in an
+ * optional separator, the returned string is newly allocated.
+ * g_strfreev() frees the array itself and all of its strings.
+ */
+gchar**	 g_strsplit		(const gchar  *string,
+				 const gchar  *delimiter,
+				 gint          max_tokens);
+gchar*   g_strjoinv		(const gchar  *separator,
+				 gchar       **str_array);
+void     g_strfreev		(gchar       **str_array);
+
+
+
+/* calculate a string size, guarranteed to fit format + args.
+ */
+guint	g_printf_string_upper_bound (const gchar* format,
+				     va_list	  args);
+
+
+/* Retrive static string info
+ */
+gchar*	g_get_user_name		(void);
+gchar*	g_get_real_name		(void);
+gchar*	g_get_home_dir		(void);
+gchar*	g_get_tmp_dir		(void);
+gchar*	g_get_prgname		(void);
+void	g_set_prgname		(const gchar *prgname);
+
+
+/* Miscellaneous utility functions
+ */
+guint	g_parse_debug_string	(const gchar *string,
+				 GDebugKey   *keys,
+				 guint	      nkeys);
+gint	g_snprintf		(gchar	     *string,
+				 gulong	      n,
+				 gchar const *format,
+				 ...) G_GNUC_PRINTF (3, 4);
+gint	g_vsnprintf		(gchar	     *string,
+				 gulong	      n,
+				 gchar const *format,
+				 va_list      args);
+gchar*	g_basename		(const gchar *file_name);
+/* Check if a file name is an absolute path */
+gboolean g_path_is_absolute	(const gchar *file_name);
+/* In case of absolute paths, skip the root part */
+gchar*  g_path_skip_root	(gchar       *file_name);
+
+/* strings are newly allocated with g_malloc() */
+gchar*	g_dirname		(const gchar *file_name);
+gchar*	g_get_current_dir	(void);
+gchar*  g_getenv		(const gchar *variable);
+
+
+/* we use a GLib function as a replacement for ATEXIT, so
+ * the programmer is not required to check the return value
+ * (if there is any in the implementation) and doesn't encounter
+ * missing include files.
+ */
+void	g_atexit		(GVoidFunc    func);
+
+
+/* Bit tests
+ */
+G_INLINE_FUNC gint	g_bit_nth_lsf (guint32 mask,
+				       gint    nth_bit);
+#ifdef	G_CAN_INLINE
+G_INLINE_FUNC gint
+g_bit_nth_lsf (guint32 mask,
+	       gint    nth_bit)
+{
+  do
+    {
+      nth_bit++;
+      if (mask & (1 << (guint) nth_bit))
+	return nth_bit;
+    }
+  while (nth_bit < 32);
+  return -1;
+}
+#endif	/* G_CAN_INLINE */
+
+G_INLINE_FUNC gint	g_bit_nth_msf (guint32 mask,
+				       gint    nth_bit);
+#ifdef G_CAN_INLINE
+G_INLINE_FUNC gint
+g_bit_nth_msf (guint32 mask,
+	       gint    nth_bit)
+{
+  if (nth_bit < 0)
+    nth_bit = 32;
+  do
+    {
+      nth_bit--;
+      if (mask & (1 << (guint) nth_bit))
+	return nth_bit;
+    }
+  while (nth_bit > 0);
+  return -1;
+}
+#endif	/* G_CAN_INLINE */
+
+G_INLINE_FUNC guint	g_bit_storage (guint number);
+#ifdef G_CAN_INLINE
+G_INLINE_FUNC guint
+g_bit_storage (guint number)
+{
+  register guint n_bits = 0;
+  
+  do
+    {
+      n_bits++;
+      number >>= 1;
+    }
+  while (number);
+  return n_bits;
+}
+#endif	/* G_CAN_INLINE */
+
+/* String Chunks
+ */
+GStringChunk* g_string_chunk_new	   (gint size);
+void	      g_string_chunk_free	   (GStringChunk *chunk);
+gchar*	      g_string_chunk_insert	   (GStringChunk *chunk,
+					    const gchar	 *string);
+gchar*	      g_string_chunk_insert_const  (GStringChunk *chunk,
+					    const gchar	 *string);
+
+
+/* Strings
+ */
+GString* g_string_new	    (const gchar *init);
+GString* g_string_sized_new (guint	  dfl_size);
+void	 g_string_free	    (GString	 *string,
+			     gint	  free_segment);
+GString* g_string_assign    (GString	 *lval,
+			     const gchar *rval);
+GString* g_string_truncate  (GString	 *string,
+			     gint	  len);
+GString* g_string_append    (GString	 *string,
+			     const gchar *val);
+GString* g_string_append_c  (GString	 *string,
+			     gchar	  c);
+GString* g_string_prepend   (GString	 *string,
+			     const gchar *val);
+GString* g_string_prepend_c (GString	 *string,
+			     gchar	  c);
+GString* g_string_insert    (GString	 *string,
+			     gint	  pos,
+			     const gchar *val);
+GString* g_string_insert_c  (GString	 *string,
+			     gint	  pos,
+			     gchar	  c);
+GString* g_string_erase	    (GString	 *string,
+			     gint	  pos,
+			     gint	  len);
+GString* g_string_down	    (GString	 *string);
+GString* g_string_up	    (GString	 *string);
+void	 g_string_sprintf   (GString	 *string,
+			     const gchar *format,
+			     ...) G_GNUC_PRINTF (2, 3);
+void	 g_string_sprintfa  (GString	 *string,
+			     const gchar *format,
+			     ...) G_GNUC_PRINTF (2, 3);
+
+
+/* Resizable arrays, remove fills any cleared spot and shortens the
+ * array, while preserving the order. remove_fast will distort the
+ * order by moving the last element to the position of the removed 
+ */
+
+#define g_array_append_val(a,v)	  g_array_append_vals (a, &v, 1)
+#define g_array_prepend_val(a,v)  g_array_prepend_vals (a, &v, 1)
+#define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &v, 1)
+#define g_array_index(a,t,i)      (((t*) (a)->data) [(i)])
+
+GArray* g_array_new	          (gboolean	    zero_terminated,
+				   gboolean	    clear,
+				   guint	    element_size);
+void	g_array_free	          (GArray	   *array,
+				   gboolean	    free_segment);
+GArray* g_array_append_vals       (GArray	   *array,
+				   gconstpointer    data,
+				   guint	    len);
+GArray* g_array_prepend_vals      (GArray	   *array,
+				   gconstpointer    data,
+				   guint	    len);
+GArray* g_array_insert_vals       (GArray          *array,
+				   guint            index,
+				   gconstpointer    data,
+				   guint            len);
+GArray* g_array_set_size          (GArray	   *array,
+				   guint	    length);
+GArray* g_array_remove_index	  (GArray	   *array,
+				   guint	    index);
+GArray* g_array_remove_index_fast (GArray	   *array,
+				   guint	    index);
+
+/* Resizable pointer array.  This interface is much less complicated
+ * than the above.  Add appends appends a pointer.  Remove fills any
+ * cleared spot and shortens the array. remove_fast will again distort
+ * order.  
+ */
+#define	    g_ptr_array_index(array,index) (array->pdata)[index]
+GPtrArray*  g_ptr_array_new		   (void);
+void	    g_ptr_array_free		   (GPtrArray	*array,
+					    gboolean	 free_seg);
+void	    g_ptr_array_set_size	   (GPtrArray	*array,
+					    gint	 length);
+gpointer    g_ptr_array_remove_index	   (GPtrArray	*array,
+					    guint	 index);
+gpointer    g_ptr_array_remove_index_fast  (GPtrArray	*array,
+					    guint	 index);
+gboolean    g_ptr_array_remove		   (GPtrArray	*array,
+					    gpointer	 data);
+gboolean    g_ptr_array_remove_fast        (GPtrArray	*array,
+					    gpointer	 data);
+void	    g_ptr_array_add		   (GPtrArray	*array,
+					    gpointer	 data);
+
+/* Hash Functions
+ */
+gint  g_str_equal (gconstpointer   v,
+		   gconstpointer   v2);
+guint g_str_hash  (gconstpointer   v);
+
+gint  g_int_equal (gconstpointer   v,
+		   gconstpointer   v2);
+guint g_int_hash  (gconstpointer   v);
+
+/* This "hash" function will just return the key's adress as an
+ * unsigned integer. Useful for hashing on plain adresses or
+ * simple integer values.
+ * passing NULL into g_hash_table_new() as GHashFunc has the
+ * same effect as passing g_direct_hash().
+ */
+guint g_direct_hash  (gconstpointer v);
+gint  g_direct_equal (gconstpointer v,
+		      gconstpointer v2);
+
+
+
+/* Prime numbers.
+ */
+
+/* This function returns prime numbers spaced by approximately 1.5-2.0
+ * and is for use in resizing data structures which prefer
+ * prime-valued sizes.	The closest spaced prime function returns the
+ * next largest prime, or the highest it knows about which is about
+ * MAXINT/4.
+ */
+guint	   g_spaced_primes_closest (guint num);
+
+
+
+#ifndef __KORBIT__
+/* GLib Thread support
+ */
+typedef struct _GMutex		GMutex;
+typedef struct _GCond		GCond;
+typedef struct _GPrivate	GPrivate;
+typedef struct _GStaticPrivate	GStaticPrivate;
+typedef struct _GThreadFunctions GThreadFunctions;
+struct _GThreadFunctions
+{
+  GMutex*  (*mutex_new)       (void);
+  void     (*mutex_lock)      (GMutex		*mutex);
+  gboolean (*mutex_trylock)   (GMutex		*mutex);
+  void     (*mutex_unlock)    (GMutex		*mutex);
+  void     (*mutex_free)      (GMutex		*mutex);
+  GCond*   (*cond_new)        (void);
+  void     (*cond_signal)     (GCond		*cond);
+  void     (*cond_broadcast)  (GCond		*cond);
+  void     (*cond_wait)       (GCond		*cond,
+			       GMutex		*mutex);
+  gboolean (*cond_timed_wait) (GCond		*cond,
+			       GMutex		*mutex, 
+			       GTimeVal 	*end_time);
+  void      (*cond_free)      (GCond		*cond);
+  GPrivate* (*private_new)    (GDestroyNotify	 destructor);
+  gpointer  (*private_get)    (GPrivate		*private_key);
+  void      (*private_set)    (GPrivate		*private_key,
+			       gpointer		 data);
+};
+
+GUTILS_C_VAR GThreadFunctions	g_thread_functions_for_glib_use;
+GUTILS_C_VAR gboolean		g_thread_use_default_impl;
+GUTILS_C_VAR gboolean		g_threads_got_initialized;
+
+/* initializes the mutex/cond/private implementation for glib, might
+ * only be called once, and must not be called directly or indirectly
+ * from another glib-function, e.g. as a callback.
+ */
+void   g_thread_init   (GThreadFunctions       *vtable);
+
+/* internal function for fallback static mutex implementation */
+GMutex*	g_static_mutex_get_mutex_impl	(GMutex	**mutex);
+
+/* shorthands for conditional and unconditional function calls */
+#define G_THREAD_UF(name, arglist) \
+    (*g_thread_functions_for_glib_use . name) arglist
+#define G_THREAD_CF(name, fail, arg) \
+    (g_thread_supported () ? G_THREAD_UF (name, arg) : (fail))
+/* keep in mind, all those mutexes and static mutexes are not 
+ * recursive in general, don't rely on that
+ */
+#define	g_thread_supported()	(g_threads_got_initialized)
+#define g_mutex_new()            G_THREAD_UF (mutex_new,      ())
+#define g_mutex_lock(mutex)      G_THREAD_CF (mutex_lock,     (void)0, (mutex))
+#define g_mutex_trylock(mutex)   G_THREAD_CF (mutex_trylock,  TRUE,    (mutex))
+#define g_mutex_unlock(mutex)    G_THREAD_CF (mutex_unlock,   (void)0, (mutex))
+#define g_mutex_free(mutex)      G_THREAD_CF (mutex_free,     (void)0, (mutex))
+#define g_cond_new()             G_THREAD_UF (cond_new,       ())
+#define g_cond_signal(cond)      G_THREAD_CF (cond_signal,    (void)0, (cond))
+#define g_cond_broadcast(cond)   G_THREAD_CF (cond_broadcast, (void)0, (cond))
+#define g_cond_wait(cond, mutex) G_THREAD_CF (cond_wait,      (void)0, (cond, \
+                                                                        mutex))
+#define g_cond_free(cond)        G_THREAD_CF (cond_free,      (void)0, (cond))
+#define g_cond_timed_wait(cond, mutex, abs_time) G_THREAD_CF (cond_timed_wait, \
+                                                              TRUE, \
+                                                              (cond, mutex, \
+							       abs_time))
+#define g_private_new(destructor)	  G_THREAD_UF (private_new, (destructor))
+#define g_private_get(private_key)	  G_THREAD_CF (private_get, \
+                                                       ((gpointer)private_key), \
+                                                       (private_key))
+#define g_private_set(private_key, value) G_THREAD_CF (private_set, \
+                                                       (void) (private_key = \
+                                                        (GPrivate*) (value)), \
+                                                       (private_key, value))
+/* GStaticMutexes can be statically initialized with the value
+ * G_STATIC_MUTEX_INIT, and then they can directly be used, that is
+ * much easier, than having to explicitly allocate the mutex before
+ * use
+ */
+#define g_static_mutex_lock(mutex) \
+    g_mutex_lock (g_static_mutex_get_mutex (mutex))
+#define g_static_mutex_trylock(mutex) \
+    g_mutex_trylock (g_static_mutex_get_mutex (mutex))
+#define g_static_mutex_unlock(mutex) \
+    g_mutex_unlock (g_static_mutex_get_mutex (mutex)) 
+struct _GStaticPrivate
+{
+  guint index;
+};
+#define G_STATIC_PRIVATE_INIT { 0 }
+gpointer g_static_private_get (GStaticPrivate	*private_key);
+void     g_static_private_set (GStaticPrivate	*private_key, 
+			       gpointer        	 data,
+			       GDestroyNotify    notify);
+#endif /* __KORBIT__ */
+
+/* these are some convenience macros that expand to nothing if GLib
+ * was configured with --disable-threads. for using StaticMutexes,
+ * you define them with G_LOCK_DEFINE_STATIC (name) or G_LOCK_DEFINE (name)
+ * if you need to export the mutex. With G_LOCK_EXTERN (name) you can
+ * declare such an globally defined lock. name is a unique identifier
+ * for the protected varibale or code portion. locking, testing and
+ * unlocking of such mutexes can be done with G_LOCK(), G_UNLOCK() and
+ * G_TRYLOCK() respectively.  
+ */
+#ifdef __KORBIT__
+#undef G_THREADS_ENABLED
+#endif
+
+extern void glib_dummy_decl (void);
+#define G_LOCK_NAME(name)		(g__ ## name ## _lock)
+#ifdef	G_THREADS_ENABLED
+#  define G_LOCK_DEFINE_STATIC(name)	static G_LOCK_DEFINE (name)
+#  define G_LOCK_DEFINE(name)		\
+    GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT 
+#  define G_LOCK_EXTERN(name)		extern GStaticMutex G_LOCK_NAME (name)
+
+#    define G_LOCK(name) g_static_mutex_lock	   (&G_LOCK_NAME (name)) 
+#    define G_UNLOCK(name) g_static_mutex_unlock   (&G_LOCK_NAME (name))
+#    define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name))
+#else	/* !G_THREADS_ENABLED */
+#  define G_LOCK_DEFINE_STATIC(name)	extern void glib_dummy_decl (void)
+#  define G_LOCK_DEFINE(name)		extern void glib_dummy_decl (void)
+#  define G_LOCK_EXTERN(name)		extern void glib_dummy_decl (void)
+#  define G_LOCK(name)
+#  define G_UNLOCK(name)
+#  define G_TRYLOCK(name)		(FALSE)
+#endif	/* !G_THREADS_ENABLED */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __G_LIB_H__ */
diff -urN linux-2.4.1/net/korbit/kglib/glibconfig.h linux-2.4.1-korbit/net/korbit/kglib/glibconfig.h
--- linux-2.4.1/net/korbit/kglib/glibconfig.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/glibconfig.h	Thu Feb  1 11:46:56 2001
@@ -0,0 +1,131 @@
+/* glibconfig.h
+ *
+ * This is a generated file.  Please modify `configure.in'
+ */
+
+#ifndef GLIBCONFIG_H
+#define GLIBCONFIG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <limits.h>
+/*#include <float.h>*/
+#define GLIB_HAVE_SYS_POLL_H
+
+#define G_MINFLOAT	FLT_MIN
+#define G_MAXFLOAT	FLT_MAX
+#define G_MINDOUBLE	DBL_MIN
+#define G_MAXDOUBLE	DBL_MAX
+#define G_MINSHORT	SHRT_MIN
+#define G_MAXSHORT	SHRT_MAX
+#define G_MININT	INT_MIN
+#define G_MAXINT	INT_MAX
+#define G_MINLONG	LONG_MIN
+#define G_MAXLONG	LONG_MAX
+
+typedef signed char gint8;
+typedef unsigned char guint8;
+typedef signed short gint16;
+typedef unsigned short guint16;
+typedef signed int gint32;
+typedef unsigned int guint32;
+
+#if defined (__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8))
+#  define G_GNUC_EXTENSION __extension__
+#else
+#  define G_GNUC_EXTENSION
+#endif
+
+#define G_HAVE_GINT64 1
+
+G_GNUC_EXTENSION typedef signed long long gint64;
+G_GNUC_EXTENSION typedef unsigned long long guint64;
+
+#define G_GINT64_CONSTANT(val)	(G_GNUC_EXTENSION (val##LL))
+
+#define GPOINTER_TO_INT(p)	((gint)   (p))
+#define GPOINTER_TO_UINT(p)	((guint)  (p))
+
+#define GINT_TO_POINTER(i)	((gpointer)  (i))
+#define GUINT_TO_POINTER(u)	((gpointer)  (u))
+
+#ifdef NeXT /* @#%@! NeXTStep */
+# define g_ATEXIT(proc)	(!atexit (proc))
+#else
+# define g_ATEXIT(proc)	(atexit (proc))
+#endif
+
+#define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END
+
+#define GLIB_MAJOR_VERSION 1
+#define GLIB_MINOR_VERSION 2
+#define GLIB_MICRO_VERSION 8
+
+
+#define G_VA_COPY	__va_copy
+
+#ifdef	__cplusplus
+#define	G_HAVE_INLINE	1
+#else	/* !__cplusplus */
+#define G_HAVE_INLINE 1
+#define G_HAVE___INLINE 1
+#define G_HAVE___INLINE__ 1
+#endif	/* !__cplusplus */
+
+#define G_THREADS_ENABLED
+#define G_THREADS_IMPL_POSIX
+typedef struct _GStaticMutex GStaticMutex;
+struct _GStaticMutex
+{
+  struct _GMutex *runtime_mutex;
+  union {
+    char   pad[24];
+    double dummy_double;
+    void  *dummy_pointer;
+    long   dummy_long;
+  } aligned_pad_u;
+};
+#define	G_STATIC_MUTEX_INIT	{ NULL, { { 0,0,0,0,0,0,77,88,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } }
+#define	g_static_mutex_get_mutex(mutex)   (g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) :    g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
+
+#define GINT16_TO_BE(val)	((gint16) (val))
+#define GUINT16_TO_BE(val)	((guint16) (val))
+#define GINT16_TO_LE(val)	((gint16) GUINT16_SWAP_LE_BE (val))
+#define GUINT16_TO_LE(val)	(GUINT16_SWAP_LE_BE (val))
+#define GINT32_TO_BE(val)	((gint32) (val))
+#define GUINT32_TO_BE(val)	((guint32) (val))
+#define GINT32_TO_LE(val)	((gint32) GUINT32_SWAP_LE_BE (val))
+#define GUINT32_TO_LE(val)	(GUINT32_SWAP_LE_BE (val))
+#define GINT64_TO_BE(val)	((gint64) (val))
+#define GUINT64_TO_BE(val)	((guint64) (val))
+#define GINT64_TO_LE(val)	((gint64) GUINT64_SWAP_LE_BE (val))
+#define GUINT64_TO_LE(val)	(GUINT64_SWAP_LE_BE (val))
+#define GLONG_TO_LE(val)	((glong) GINT32_TO_LE (val))
+#define GULONG_TO_LE(val)	((gulong) GUINT32_TO_LE (val))
+#define GLONG_TO_BE(val)	((glong) GINT32_TO_BE (val))
+#define GULONG_TO_BE(val)	((gulong) GUINT32_TO_BE (val))
+#define GINT_TO_LE(val)		((gint) GINT32_TO_LE (val))
+#define GUINT_TO_LE(val)	((guint) GUINT32_TO_LE (val))
+#define GINT_TO_BE(val)		((gint) GINT32_TO_BE (val))
+#define GUINT_TO_BE(val)	((guint) GUINT32_TO_BE (val))
+#define G_BYTE_ORDER G_LITTLE_ENDIAN
+
+#define GLIB_SYSDEF_POLLIN =1
+#define GLIB_SYSDEF_POLLOUT =4
+#define GLIB_SYSDEF_POLLPRI =2
+#define GLIB_SYSDEF_POLLERR =8
+#define GLIB_SYSDEF_POLLHUP =16
+#define GLIB_SYSDEF_POLLNVAL =32
+
+
+#define G_HAVE_WCHAR_H 1
+#define G_HAVE_WCTYPE_H 1
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* GLIBCONFIG_H */
diff -urN linux-2.4.1/net/korbit/kglib/glist.c linux-2.4.1-korbit/net/korbit/kglib/glist.c
--- linux-2.4.1/net/korbit/kglib/glist.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/glist.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,666 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "glib.h"
+
+
+struct _GAllocator /* from gmem.c */
+{
+  gchar         *name;
+  guint16        n_preallocs;
+  guint          is_unused : 1;
+  guint          type : 4;
+  GAllocator    *last;
+  GMemChunk     *mem_chunk;
+  GList		*free_lists; /* implementation specific */
+};
+
+static GAllocator	*current_allocator = NULL;
+G_LOCK_DEFINE_STATIC (current_allocator);
+
+/* HOLDS: current_allocator_lock */
+static void
+g_list_validate_allocator (GAllocator *allocator)
+{
+  g_return_if_fail (allocator != NULL);
+  g_return_if_fail (allocator->is_unused == TRUE);
+
+  if (allocator->type != G_ALLOCATOR_LIST)
+    {
+      allocator->type = G_ALLOCATOR_LIST;
+      if (allocator->mem_chunk)
+	{
+	  g_mem_chunk_destroy (allocator->mem_chunk);
+	  allocator->mem_chunk = NULL;
+	}
+    }
+
+  if (!allocator->mem_chunk)
+    {
+      allocator->mem_chunk = g_mem_chunk_new (allocator->name,
+					      sizeof (GList),
+					      sizeof (GList) * allocator->n_preallocs,
+					      G_ALLOC_ONLY);
+      allocator->free_lists = NULL;
+    }
+
+  allocator->is_unused = FALSE;
+}
+
+void
+g_list_push_allocator(GAllocator *allocator)
+{
+  G_LOCK (current_allocator);
+  g_list_validate_allocator ( allocator );
+  allocator->last = current_allocator;
+  current_allocator = allocator;
+  G_UNLOCK (current_allocator);
+}
+
+void
+g_list_pop_allocator (void)
+{
+  G_LOCK (current_allocator);
+  if (current_allocator)
+    {
+      GAllocator *allocator;
+
+      allocator = current_allocator;
+      current_allocator = allocator->last;
+      allocator->last = NULL;
+      allocator->is_unused = TRUE;
+    }
+  G_UNLOCK (current_allocator);
+}
+
+GList*
+g_list_alloc (void)
+{
+  GList *list;
+
+  G_LOCK (current_allocator);
+  if (!current_allocator)
+    {
+      GAllocator *allocator = g_allocator_new ("GLib default GList allocator",
+					       128);
+      g_list_validate_allocator (allocator);
+      allocator->last = NULL;
+      current_allocator = allocator;
+    }
+  if (!current_allocator->free_lists)
+    {
+      list = g_chunk_new (GList, current_allocator->mem_chunk);
+      list->data = NULL;
+    }
+  else
+    {
+      if (current_allocator->free_lists->data)
+	{
+	  list = current_allocator->free_lists->data;
+	  current_allocator->free_lists->data = list->next;
+	  list->data = NULL;
+	}
+      else
+	{
+	  list = current_allocator->free_lists;
+	  current_allocator->free_lists = list->next;
+	}
+    }
+  G_UNLOCK (current_allocator);
+  list->next = NULL;
+  list->prev = NULL;
+  
+  return list;
+}
+
+void
+g_list_free (GList *list)
+{
+  if (list)
+    {
+      list->data = list->next;  
+      G_LOCK (current_allocator);
+      list->next = current_allocator->free_lists;
+      current_allocator->free_lists = list;
+      G_UNLOCK (current_allocator);
+    }
+}
+
+void
+g_list_free_1 (GList *list)
+{
+  if (list)
+    {
+      list->data = NULL;  
+      G_LOCK (current_allocator);
+      list->next = current_allocator->free_lists;
+      current_allocator->free_lists = list;
+      G_UNLOCK (current_allocator);
+    }
+}
+
+GList*
+g_list_append (GList	*list,
+	       gpointer	 data)
+{
+  GList *new_list;
+  GList *last;
+  
+  new_list = g_list_alloc ();
+  new_list->data = data;
+  
+  if (list)
+    {
+      last = g_list_last (list);
+      /* g_assert (last != NULL); */
+      last->next = new_list;
+      new_list->prev = last;
+
+      return list;
+    }
+  else
+    return new_list;
+}
+
+GList*
+g_list_prepend (GList	 *list,
+		gpointer  data)
+{
+  GList *new_list;
+  
+  new_list = g_list_alloc ();
+  new_list->data = data;
+  
+  if (list)
+    {
+      if (list->prev)
+	{
+	  list->prev->next = new_list;
+	  new_list->prev = list->prev;
+	}
+      list->prev = new_list;
+      new_list->next = list;
+    }
+  
+  return new_list;
+}
+
+GList*
+g_list_insert (GList	*list,
+	       gpointer	 data,
+	       gint	 position)
+{
+  GList *new_list;
+  GList *tmp_list;
+  
+  if (position < 0)
+    return g_list_append (list, data);
+  else if (position == 0)
+    return g_list_prepend (list, data);
+  
+  tmp_list = g_list_nth (list, position);
+  if (!tmp_list)
+    return g_list_append (list, data);
+  
+  new_list = g_list_alloc ();
+  new_list->data = data;
+  
+  if (tmp_list->prev)
+    {
+      tmp_list->prev->next = new_list;
+      new_list->prev = tmp_list->prev;
+    }
+  new_list->next = tmp_list;
+  tmp_list->prev = new_list;
+  
+  if (tmp_list == list)
+    return new_list;
+  else
+    return list;
+}
+
+GList *
+g_list_concat (GList *list1, GList *list2)
+{
+  GList *tmp_list;
+  
+  if (list2)
+    {
+      tmp_list = g_list_last (list1);
+      if (tmp_list)
+	tmp_list->next = list2;
+      else
+	list1 = list2;
+      list2->prev = tmp_list;
+    }
+  
+  return list1;
+}
+
+GList*
+g_list_remove (GList	*list,
+	       gpointer	 data)
+{
+  GList *tmp;
+  
+  tmp = list;
+  while (tmp)
+    {
+      if (tmp->data != data)
+	tmp = tmp->next;
+      else
+	{
+	  if (tmp->prev)
+	    tmp->prev->next = tmp->next;
+	  if (tmp->next)
+	    tmp->next->prev = tmp->prev;
+	  
+	  if (list == tmp)
+	    list = list->next;
+	  
+	  g_list_free_1 (tmp);
+	  
+	  break;
+	}
+    }
+  return list;
+}
+
+GList*
+g_list_remove_link (GList *list,
+		    GList *link)
+{
+  if (link)
+    {
+      if (link->prev)
+	link->prev->next = link->next;
+      if (link->next)
+	link->next->prev = link->prev;
+      
+      if (link == list)
+	list = list->next;
+      
+      link->next = NULL;
+      link->prev = NULL;
+    }
+  
+  return list;
+}
+
+GList*
+g_list_copy (GList *list)
+{
+  GList *new_list = NULL;
+
+  if (list)
+    {
+      GList *last;
+
+      new_list = g_list_alloc ();
+      new_list->data = list->data;
+      last = new_list;
+      list = list->next;
+      while (list)
+	{
+	  last->next = g_list_alloc ();
+	  last->next->prev = last;
+	  last = last->next;
+	  last->data = list->data;
+	  list = list->next;
+	}
+    }
+
+  return new_list;
+}
+
+GList*
+g_list_reverse (GList *list)
+{
+  GList *last;
+  
+  last = NULL;
+  while (list)
+    {
+      last = list;
+      list = last->next;
+      last->next = last->prev;
+      last->prev = list;
+    }
+  
+  return last;
+}
+
+GList*
+g_list_nth (GList *list,
+	    guint  n)
+{
+  while ((n-- > 0) && list)
+    list = list->next;
+  
+  return list;
+}
+
+gpointer
+g_list_nth_data (GList     *list,
+		 guint      n)
+{
+  while ((n-- > 0) && list)
+    list = list->next;
+  
+  return list ? list->data : NULL;
+}
+
+GList*
+g_list_find (GList    *list,
+	     gpointer  data)
+{
+  while (list)
+    {
+      if (list->data == data)
+	break;
+      list = list->next;
+    }
+  
+  return list;
+}
+
+GList*
+g_list_find_custom (GList       *list,
+		    gpointer     data,
+		    GCompareFunc func)
+{
+  g_return_val_if_fail (func != NULL, list);
+
+  while (list)
+    {
+      if (! func (list->data, data))
+	return list;
+      list = list->next;
+    }
+
+  return NULL;
+}
+
+
+gint
+g_list_position (GList *list,
+		 GList *link)
+{
+  gint i;
+
+  i = 0;
+  while (list)
+    {
+      if (list == link)
+	return i;
+      i++;
+      list = list->next;
+    }
+
+  return -1;
+}
+
+gint
+g_list_index (GList   *list,
+	      gpointer data)
+{
+  gint i;
+
+  i = 0;
+  while (list)
+    {
+      if (list->data == data)
+	return i;
+      i++;
+      list = list->next;
+    }
+
+  return -1;
+}
+
+GList*
+g_list_last (GList *list)
+{
+  if (list)
+    {
+      while (list->next)
+	list = list->next;
+    }
+  
+  return list;
+}
+
+GList*
+g_list_first (GList *list)
+{
+  if (list)
+    {
+      while (list->prev)
+	list = list->prev;
+    }
+  
+  return list;
+}
+
+guint
+g_list_length (GList *list)
+{
+  guint length;
+  
+  length = 0;
+  while (list)
+    {
+      length++;
+      list = list->next;
+    }
+  
+  return length;
+}
+
+void
+g_list_foreach (GList	 *list,
+		GFunc	  func,
+		gpointer  user_data)
+{
+  while (list)
+    {
+      (*func) (list->data, user_data);
+      list = list->next;
+    }
+}
+
+
+GList*
+g_list_insert_sorted (GList        *list,
+                      gpointer      data,
+                      GCompareFunc  func)
+{
+  GList *tmp_list = list;
+  GList *new_list;
+  gint cmp;
+
+  g_return_val_if_fail (func != NULL, list);
+  
+  if (!list) 
+    {
+      new_list = g_list_alloc();
+      new_list->data = data;
+      return new_list;
+    }
+  
+  cmp = (*func) (data, tmp_list->data);
+  
+  while ((tmp_list->next) && (cmp > 0))
+    {
+      tmp_list = tmp_list->next;
+      cmp = (*func) (data, tmp_list->data);
+    }
+
+  new_list = g_list_alloc();
+  new_list->data = data;
+
+  if ((!tmp_list->next) && (cmp > 0))
+    {
+      tmp_list->next = new_list;
+      new_list->prev = tmp_list;
+      return list;
+    }
+   
+  if (tmp_list->prev)
+    {
+      tmp_list->prev->next = new_list;
+      new_list->prev = tmp_list->prev;
+    }
+  new_list->next = tmp_list;
+  tmp_list->prev = new_list;
+ 
+  if (tmp_list == list)
+    return new_list;
+  else
+    return list;
+}
+
+static GList *
+g_list_sort_merge (GList       *l1, 
+		   GList       *l2,
+		   GCompareFunc compare_func)
+{
+  GList list, *l, *lprev;
+
+  l = &list; 
+  lprev = NULL;
+
+  while (l1 && l2)
+    {
+      if (compare_func (l1->data, l2->data) < 0)
+        {
+	  l->next = l1;
+	  l = l->next;
+	  l->prev = lprev; 
+	  lprev = l;
+	  l1 = l1->next;
+        } 
+      else 
+	{
+	  l->next = l2;
+	  l = l->next;
+	  l->prev = lprev; 
+	  lprev = l;
+	  l2 = l2->next;
+        }
+    }
+  l->next = l1 ? l1 : l2;
+  l->next->prev = l;
+
+  return list.next;
+}
+
+GList* 
+g_list_sort (GList       *list,
+	     GCompareFunc compare_func)
+{
+  GList *l1, *l2;
+  
+  if (!list) 
+    return NULL;
+  if (!list->next) 
+    return list;
+  
+  l1 = list; 
+  l2 = list->next;
+
+  while ((l2 = l2->next) != NULL)
+    {
+      if ((l2 = l2->next) == NULL) 
+	break;
+      l1 = l1->next;
+    }
+  l2 = l1->next; 
+  l1->next = NULL; 
+
+  return g_list_sort_merge (g_list_sort (list, compare_func),
+			    g_list_sort (l2,   compare_func),
+			    compare_func);
+}
+
+GList* 
+g_list_sort2 (GList       *list,
+	      GCompareFunc compare_func)
+{
+  GSList *runs = NULL;
+  GList *tmp;
+
+  /* Degenerate case.  */
+  if (!list) return NULL;
+
+  /* Assume: list = [12,2,4,11,2,4,6,1,1,12].  */
+  for (tmp = list; tmp; )
+    {
+      GList *tmp2;
+      for (tmp2 = tmp;
+	   tmp2->next && compare_func (tmp2->data, tmp2->next->data) <= 0;
+	   tmp2 = tmp2->next)
+	/* Nothing */;
+      runs = g_slist_append (runs, tmp);
+      tmp = tmp2->next;
+      tmp2->next = NULL;
+    }
+  /* Now: runs = [[12],[2,4,11],[2,4,6],[1,1,12]].  */
+  
+  while (runs->next)
+    {
+      /* We have more than one run.  Merge pairwise.  */
+      GSList *dst, *src, *dstprev = NULL;
+      dst = src = runs;
+      while (src && src->next)
+	{
+	  dst->data = g_list_sort_merge (src->data,
+					 src->next->data,
+					 compare_func);
+	  dstprev = dst;
+	  dst = dst->next;
+	  src = src->next->next;
+	}
+
+      /* If number of runs was odd, just keep the last.  */
+      if (src)
+	{
+	  dst->data = src->data;
+	  dstprev = dst;
+	  dst = dst->next;
+	}
+
+      dstprev->next = NULL;
+      g_slist_free (dst);
+    }
+
+  /* After 1st loop: runs = [[2,4,11,12],[1,1,2,4,6,12]].  */
+  /* After 2nd loop: runs = [[1,1,2,2,4,4,6,11,12,12]].  */
+
+  list = runs->data;
+  g_slist_free (runs);
+  return list;
+}
diff -urN linux-2.4.1/net/korbit/kglib/gmem.c linux-2.4.1-korbit/net/korbit/kglib/gmem.c
--- linux-2.4.1/net/korbit/kglib/gmem.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/gmem.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,767 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ *
+ * Mutilated on 10/22/00 by Fredrik and Chris
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include "glib.h"
+
+#define MEM_PROFILE_TABLE_SIZE 8192
+#define ENTER_MEM_CHUNK_ROUTINE()
+#define LEAVE_MEM_CHUNK_ROUTINE()
+
+/*
+ * This library can check for some attempts to do illegal things to
+ * memory (ENABLE_MEM_CHECK), and can do profiling
+ * (ENABLE_MEM_PROFILE).  Both features are implemented by storing
+ * words before the start of the memory chunk.
+ *
+ * The first, at offset -2*SIZEOF_LONG, is used only if
+ * ENABLE_MEM_CHECK is set, and stores 0 after the memory has been
+ * allocated and 1 when it has been freed.  The second, at offset
+ * -SIZEOF_LONG, is used if either flag is set and stores the size of
+ * the block.
+ *
+ * The MEM_CHECK flag is checked when memory is realloc'd and free'd,
+ * and it can be explicitly checked before using a block by calling
+ * g_mem_check().
+ */
+
+#define MEM_AREA_SIZE 4L
+
+#define MEM_ALIGN     sizeof(long)
+
+
+typedef struct _GFreeAtom      GFreeAtom;
+typedef struct _GMemArea       GMemArea;
+typedef struct _GRealMemChunk  GRealMemChunk;
+
+struct _GFreeAtom
+{
+  GFreeAtom *next;
+};
+
+struct _GMemArea
+{
+  GMemArea *next;            /* the next mem area */
+  GMemArea *prev;            /* the previous mem area */
+  gulong index;              /* the current index into the "mem" array */
+  gulong free;               /* the number of free bytes in this mem area */
+  gulong allocated;          /* the number of atoms allocated from this area */
+  gulong mark;               /* is this mem area marked for deletion */
+  gchar mem[MEM_AREA_SIZE];  /* the mem array from which atoms get allocated
+			      * the actual size of this array is determined by
+			      *  the mem chunk "area_size". ANSI says that it
+			      *  must be declared to be the maximum size it
+			      *  can possibly be (even though the actual size
+			      *  may be less).
+			      */
+};
+
+struct _GRealMemChunk
+{
+  gchar *name;               /* name of this MemChunk...used for debugging output */
+  gint type;                 /* the type of MemChunk: ALLOC_ONLY or ALLOC_AND_FREE */
+  gint num_mem_areas;        /* the number of memory areas */
+  gint num_marked_areas;     /* the number of areas marked for deletion */
+  guint atom_size;           /* the size of an atom */
+  gulong area_size;          /* the size of a memory area */
+  GMemArea *mem_area;        /* the current memory area */
+  GMemArea *mem_areas;       /* a list of all the mem areas owned by this chunk */
+  GMemArea *free_mem_area;   /* the free area...which is about to be destroyed */
+  GFreeAtom *free_atoms;     /* the free atoms list */
+  GTree *mem_tree;           /* tree of mem areas sorted by memory address */
+  GRealMemChunk *next;       /* pointer to the next chunk */
+  GRealMemChunk *prev;       /* pointer to the previous chunk */
+};
+
+
+static gulong g_mem_chunk_compute_size (gulong    size,
+					gulong    min_size);
+static gint   g_mem_chunk_area_compare (GMemArea *a,
+					GMemArea *b);
+static gint   g_mem_chunk_area_search  (GMemArea *a,
+					gchar    *addr);
+
+
+/* here we can't use StaticMutexes, as they depend upon a working
+ * g_malloc, the same holds true for StaticPrivate */
+#ifndef __KORBIT__
+static GMutex* mem_chunks_lock = NULL;
+#endif /* !__KORBIT__ */
+static GRealMemChunk *mem_chunks = NULL;
+
+
+gpointer
+g_malloc (gulong size)
+{
+  gpointer p;
+  
+  if (size == 0)
+    return NULL;
+  
+  p = (gpointer) malloc (size);
+  if (!p)
+    g_error ("could not allocate %ld bytes", size);
+  
+  return p;
+}
+
+gpointer
+g_malloc0 (gulong size)
+{
+  gpointer p;
+  
+  if (size == 0)
+    return NULL;
+  
+  p = (gpointer) calloc (size, 1);
+  if (!p)
+    g_error ("could not allocate %ld bytes", size);
+  
+  return p;
+}
+
+gpointer
+g_realloc (gpointer mem,
+	   gulong   size)
+{
+  gpointer p;
+  
+  if (size == 0)
+    {
+      g_free (mem);
+    
+      return NULL;
+    }
+  
+  if (!mem)
+    {
+#ifdef REALLOC_0_WORKS
+      p = (gpointer) realloc (NULL, size);
+#else /* !REALLOC_0_WORKS */
+      p = (gpointer) malloc (size);
+#endif /* !REALLOC_0_WORKS */
+    }
+  else
+    {
+      p = (gpointer) realloc (mem, size);
+    }
+  
+  if (!p)
+    g_error ("could not reallocate %lu bytes", (gulong) size);
+  
+  return p;
+}
+
+void
+g_free (gpointer mem)
+{
+  if (mem)
+    {
+      free (mem);
+    }
+}
+
+
+void
+g_mem_profile (void)
+{
+}
+
+void
+g_mem_check (gpointer mem)
+{
+}
+
+GMemChunk*
+g_mem_chunk_new (gchar  *name,
+		 gint    atom_size,
+		 gulong  area_size,
+		 gint    type)
+{
+  GRealMemChunk *mem_chunk;
+  gulong rarea_size;
+
+  g_return_val_if_fail (atom_size > 0, NULL);
+  g_return_val_if_fail (area_size >= atom_size, NULL);
+
+  ENTER_MEM_CHUNK_ROUTINE();
+
+  area_size = (area_size + atom_size - 1) / atom_size;
+  area_size *= atom_size;
+
+  mem_chunk = g_new (struct _GRealMemChunk, 1);
+  mem_chunk->name = name;
+  mem_chunk->type = type;
+  mem_chunk->num_mem_areas = 0;
+  mem_chunk->num_marked_areas = 0;
+  mem_chunk->mem_area = NULL;
+  mem_chunk->free_mem_area = NULL;
+  mem_chunk->free_atoms = NULL;
+  mem_chunk->mem_tree = NULL;
+  mem_chunk->mem_areas = NULL;
+  mem_chunk->atom_size = atom_size;
+  
+  if (mem_chunk->type == G_ALLOC_AND_FREE)
+    mem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
+  
+  if (mem_chunk->atom_size % MEM_ALIGN)
+    mem_chunk->atom_size += MEM_ALIGN - (mem_chunk->atom_size % MEM_ALIGN);
+
+  rarea_size = area_size + sizeof (GMemArea) - MEM_AREA_SIZE;
+  rarea_size = g_mem_chunk_compute_size (rarea_size, atom_size + sizeof (GMemArea) - MEM_AREA_SIZE);
+  mem_chunk->area_size = rarea_size - (sizeof (GMemArea) - MEM_AREA_SIZE);
+
+#ifndef __KORBIT__
+  g_mutex_lock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  mem_chunk->next = mem_chunks;
+  mem_chunk->prev = NULL;
+  if (mem_chunks)
+    mem_chunks->prev = mem_chunk;
+  mem_chunks = mem_chunk;
+#ifndef __KORBIT__
+  g_mutex_unlock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+
+  LEAVE_MEM_CHUNK_ROUTINE();
+
+  return ((GMemChunk*) mem_chunk);
+}
+
+void
+g_mem_chunk_destroy (GMemChunk *mem_chunk)
+{
+  GRealMemChunk *rmem_chunk;
+  GMemArea *mem_areas;
+  GMemArea *temp_area;
+  
+  g_return_if_fail (mem_chunk != NULL);
+
+  ENTER_MEM_CHUNK_ROUTINE();
+
+  rmem_chunk = (GRealMemChunk*) mem_chunk;
+  
+  mem_areas = rmem_chunk->mem_areas;
+  while (mem_areas)
+    {
+      temp_area = mem_areas;
+      mem_areas = mem_areas->next;
+      g_free (temp_area);
+    }
+  
+  if (rmem_chunk->next)
+    rmem_chunk->next->prev = rmem_chunk->prev;
+  if (rmem_chunk->prev)
+    rmem_chunk->prev->next = rmem_chunk->next;
+  
+#ifndef __KORBIT__
+  g_mutex_lock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  if (rmem_chunk == mem_chunks)
+    mem_chunks = mem_chunks->next;
+#ifndef __KORBIT__
+  g_mutex_unlock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  
+  if (rmem_chunk->type == G_ALLOC_AND_FREE)
+    g_tree_destroy (rmem_chunk->mem_tree);
+  
+  g_free (rmem_chunk);
+
+  LEAVE_MEM_CHUNK_ROUTINE();
+}
+
+gpointer
+g_mem_chunk_alloc (GMemChunk *mem_chunk)
+{
+  GRealMemChunk *rmem_chunk;
+  GMemArea *temp_area;
+  gpointer mem;
+
+  ENTER_MEM_CHUNK_ROUTINE();
+
+  g_return_val_if_fail (mem_chunk != NULL, NULL);
+  
+  rmem_chunk = (GRealMemChunk*) mem_chunk;
+  
+  while (rmem_chunk->free_atoms)
+    {
+      /* Get the first piece of memory on the "free_atoms" list.
+       * We can go ahead and destroy the list node we used to keep
+       *  track of it with and to update the "free_atoms" list to
+       *  point to its next element.
+       */
+      mem = rmem_chunk->free_atoms;
+      rmem_chunk->free_atoms = rmem_chunk->free_atoms->next;
+      
+      /* Determine which area this piece of memory is allocated from */
+      temp_area = g_tree_search (rmem_chunk->mem_tree,
+				 (GSearchFunc) g_mem_chunk_area_search,
+				 mem);
+      
+      /* If the area has been marked, then it is being destroyed.
+       *  (ie marked to be destroyed).
+       * We check to see if all of the segments on the free list that
+       *  reference this area have been removed. This occurs when
+       *  the ammount of free memory is less than the allocatable size.
+       * If the chunk should be freed, then we place it in the "free_mem_area".
+       * This is so we make sure not to free the mem area here and then
+       *  allocate it again a few lines down.
+       * If we don't allocate a chunk a few lines down then the "free_mem_area"
+       *  will be freed.
+       * If there is already a "free_mem_area" then we'll just free this mem area.
+       */
+      if (temp_area->mark)
+        {
+          /* Update the "free" memory available in that area */
+          temp_area->free += rmem_chunk->atom_size;
+	  
+          if (temp_area->free == rmem_chunk->area_size)
+            {
+              if (temp_area == rmem_chunk->mem_area)
+                rmem_chunk->mem_area = NULL;
+	      
+              if (rmem_chunk->free_mem_area)
+                {
+                  rmem_chunk->num_mem_areas -= 1;
+		  
+                  if (temp_area->next)
+                    temp_area->next->prev = temp_area->prev;
+                  if (temp_area->prev)
+                    temp_area->prev->next = temp_area->next;
+                  if (temp_area == rmem_chunk->mem_areas)
+                    rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
+		  
+		  if (rmem_chunk->type == G_ALLOC_AND_FREE)
+		    g_tree_remove (rmem_chunk->mem_tree, temp_area);
+                  g_free (temp_area);
+                }
+              else
+                rmem_chunk->free_mem_area = temp_area;
+	      
+	      rmem_chunk->num_marked_areas -= 1;
+	    }
+	}
+      else
+        {
+          /* Update the number of allocated atoms count.
+	   */
+          temp_area->allocated += 1;
+	  
+          /* The area wasn't marked...return the memory
+	   */
+	  goto outa_here;
+        }
+    }
+  
+  /* If there isn't a current mem area or the current mem area is out of space
+   *  then allocate a new mem area. We'll first check and see if we can use
+   *  the "free_mem_area". Otherwise we'll just malloc the mem area.
+   */
+  if ((!rmem_chunk->mem_area) ||
+      ((rmem_chunk->mem_area->index + rmem_chunk->atom_size) > rmem_chunk->area_size))
+    {
+      if (rmem_chunk->free_mem_area)
+        {
+          rmem_chunk->mem_area = rmem_chunk->free_mem_area;
+	  rmem_chunk->free_mem_area = NULL;
+        }
+      else
+        {
+	  rmem_chunk->mem_area = (GMemArea*) g_malloc (sizeof (GMemArea) -
+						       MEM_AREA_SIZE +
+						       rmem_chunk->area_size);
+	  
+	  rmem_chunk->num_mem_areas += 1;
+	  rmem_chunk->mem_area->next = rmem_chunk->mem_areas;
+	  rmem_chunk->mem_area->prev = NULL;
+	  
+	  if (rmem_chunk->mem_areas)
+	    rmem_chunk->mem_areas->prev = rmem_chunk->mem_area;
+	  rmem_chunk->mem_areas = rmem_chunk->mem_area;
+	  
+	  if (rmem_chunk->type == G_ALLOC_AND_FREE)
+	    g_tree_insert (rmem_chunk->mem_tree, rmem_chunk->mem_area, rmem_chunk->mem_area);
+        }
+      
+      rmem_chunk->mem_area->index = 0;
+      rmem_chunk->mem_area->free = rmem_chunk->area_size;
+      rmem_chunk->mem_area->allocated = 0;
+      rmem_chunk->mem_area->mark = 0;
+    }
+  
+  /* Get the memory and modify the state variables appropriately.
+   */
+  mem = (gpointer) &rmem_chunk->mem_area->mem[rmem_chunk->mem_area->index];
+  rmem_chunk->mem_area->index += rmem_chunk->atom_size;
+  rmem_chunk->mem_area->free -= rmem_chunk->atom_size;
+  rmem_chunk->mem_area->allocated += 1;
+
+outa_here:
+
+  LEAVE_MEM_CHUNK_ROUTINE();
+
+  return mem;
+}
+
+gpointer
+g_mem_chunk_alloc0 (GMemChunk *mem_chunk)
+{
+  gpointer mem;
+
+  mem = g_mem_chunk_alloc (mem_chunk);
+  if (mem)
+    {
+      GRealMemChunk *rmem_chunk = (GRealMemChunk*) mem_chunk;
+
+      memset (mem, 0, rmem_chunk->atom_size);
+    }
+
+  return mem;
+}
+
+void
+g_mem_chunk_free (GMemChunk *mem_chunk,
+		  gpointer   mem)
+{
+  GRealMemChunk *rmem_chunk;
+  GMemArea *temp_area;
+  GFreeAtom *free_atom;
+  
+  g_return_if_fail (mem_chunk != NULL);
+  g_return_if_fail (mem != NULL);
+
+  ENTER_MEM_CHUNK_ROUTINE();
+
+  rmem_chunk = (GRealMemChunk*) mem_chunk;
+  
+  /* Don't do anything if this is an ALLOC_ONLY chunk
+   */
+  if (rmem_chunk->type == G_ALLOC_AND_FREE)
+    {
+      /* Place the memory on the "free_atoms" list
+       */
+      free_atom = (GFreeAtom*) mem;
+      free_atom->next = rmem_chunk->free_atoms;
+      rmem_chunk->free_atoms = free_atom;
+      
+      temp_area = g_tree_search (rmem_chunk->mem_tree,
+				 (GSearchFunc) g_mem_chunk_area_search,
+				 mem);
+      
+      temp_area->allocated -= 1;
+      
+      if (temp_area->allocated == 0)
+	{
+	  temp_area->mark = 1;
+	  rmem_chunk->num_marked_areas += 1;
+	}
+    }
+
+  LEAVE_MEM_CHUNK_ROUTINE();
+}
+
+/* This doesn't free the free_area if there is one */
+void
+g_mem_chunk_clean (GMemChunk *mem_chunk)
+{
+  GRealMemChunk *rmem_chunk;
+  GMemArea *mem_area;
+  GFreeAtom *prev_free_atom;
+  GFreeAtom *temp_free_atom;
+  gpointer mem;
+  
+  g_return_if_fail (mem_chunk != NULL);
+  
+  rmem_chunk = (GRealMemChunk*) mem_chunk;
+  
+  if (rmem_chunk->type == G_ALLOC_AND_FREE)
+    {
+      prev_free_atom = NULL;
+      temp_free_atom = rmem_chunk->free_atoms;
+      
+      while (temp_free_atom)
+	{
+	  mem = (gpointer) temp_free_atom;
+	  
+	  mem_area = g_tree_search (rmem_chunk->mem_tree,
+				    (GSearchFunc) g_mem_chunk_area_search,
+				    mem);
+	  
+          /* If this mem area is marked for destruction then delete the
+	   *  area and list node and decrement the free mem.
+           */
+	  if (mem_area->mark)
+	    {
+	      if (prev_free_atom)
+		prev_free_atom->next = temp_free_atom->next;
+	      else
+		rmem_chunk->free_atoms = temp_free_atom->next;
+	      temp_free_atom = temp_free_atom->next;
+	      
+	      mem_area->free += rmem_chunk->atom_size;
+	      if (mem_area->free == rmem_chunk->area_size)
+		{
+		  rmem_chunk->num_mem_areas -= 1;
+		  rmem_chunk->num_marked_areas -= 1;
+		  
+		  if (mem_area->next)
+		    mem_area->next->prev = mem_area->prev;
+		  if (mem_area->prev)
+		    mem_area->prev->next = mem_area->next;
+		  if (mem_area == rmem_chunk->mem_areas)
+		    rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
+		  if (mem_area == rmem_chunk->mem_area)
+		    rmem_chunk->mem_area = NULL;
+		  
+		  if (rmem_chunk->type == G_ALLOC_AND_FREE)
+		    g_tree_remove (rmem_chunk->mem_tree, mem_area);
+		  g_free (mem_area);
+		}
+	    }
+	  else
+	    {
+	      prev_free_atom = temp_free_atom;
+	      temp_free_atom = temp_free_atom->next;
+	    }
+	}
+    }
+}
+
+void
+g_mem_chunk_reset (GMemChunk *mem_chunk)
+{
+  GRealMemChunk *rmem_chunk;
+  GMemArea *mem_areas;
+  GMemArea *temp_area;
+  
+  g_return_if_fail (mem_chunk != NULL);
+  
+  rmem_chunk = (GRealMemChunk*) mem_chunk;
+  
+  mem_areas = rmem_chunk->mem_areas;
+  rmem_chunk->num_mem_areas = 0;
+  rmem_chunk->mem_areas = NULL;
+  rmem_chunk->mem_area = NULL;
+  
+  while (mem_areas)
+    {
+      temp_area = mem_areas;
+      mem_areas = mem_areas->next;
+      g_free (temp_area);
+    }
+  
+  rmem_chunk->free_atoms = NULL;
+  
+  if (rmem_chunk->mem_tree)
+    g_tree_destroy (rmem_chunk->mem_tree);
+  rmem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
+}
+
+void
+g_mem_chunk_print (GMemChunk *mem_chunk)
+{
+  GRealMemChunk *rmem_chunk;
+  GMemArea *mem_areas;
+  gulong mem;
+  
+  g_return_if_fail (mem_chunk != NULL);
+  
+  rmem_chunk = (GRealMemChunk*) mem_chunk;
+  mem_areas = rmem_chunk->mem_areas;
+  mem = 0;
+  
+  while (mem_areas)
+    {
+      mem += rmem_chunk->area_size - mem_areas->free;
+      mem_areas = mem_areas->next;
+    }
+  
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+	 "%s: %ld bytes using %d mem areas",
+	 rmem_chunk->name, mem, rmem_chunk->num_mem_areas);
+}
+
+void
+g_mem_chunk_info (void)
+{
+  GRealMemChunk *mem_chunk;
+  gint count;
+  
+  count = 0;
+#ifndef __KORBIT__
+  g_mutex_lock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  mem_chunk = mem_chunks;
+  while (mem_chunk)
+    {
+      count += 1;
+      mem_chunk = mem_chunk->next;
+    }
+#ifndef __KORBIT__
+  g_mutex_unlock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%d mem chunks", count);
+  
+#ifndef __KORBIT__
+  g_mutex_lock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  mem_chunk = mem_chunks;
+#ifndef __KORBIT__
+  g_mutex_unlock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+
+  while (mem_chunk)
+    {
+      g_mem_chunk_print ((GMemChunk*) mem_chunk);
+      mem_chunk = mem_chunk->next;
+    }  
+}
+
+void
+g_blow_chunks (void)
+{
+  GRealMemChunk *mem_chunk;
+  
+#ifndef __KORBIT__
+  g_mutex_lock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  mem_chunk = mem_chunks;
+#ifndef __KORBIT__
+  g_mutex_unlock (mem_chunks_lock);
+#endif /* !__KORBIT__ */
+  while (mem_chunk)
+    {
+      g_mem_chunk_clean ((GMemChunk*) mem_chunk);
+      mem_chunk = mem_chunk->next;
+    }
+}
+
+
+static gulong
+g_mem_chunk_compute_size (gulong size,
+			  gulong min_size)
+{
+  gulong power_of_2;
+  gulong lower, upper;
+  
+  power_of_2 = 16;
+  while (power_of_2 < size)
+    power_of_2 <<= 1;
+  
+  lower = power_of_2 >> 1;
+  upper = power_of_2;
+  
+  if (size - lower < upper - size && lower >= min_size)
+    return lower;
+  else
+    return upper;
+}
+
+static gint
+g_mem_chunk_area_compare (GMemArea *a,
+			  GMemArea *b)
+{
+  if (a->mem > b->mem)
+	return 1;
+  else if (a->mem < b->mem)
+	return -1;
+  return 0;
+}
+
+static gint
+g_mem_chunk_area_search (GMemArea *a,
+			 gchar    *addr)
+{
+  if (a->mem <= addr)
+    {
+      if (addr < &a->mem[a->index])
+	return 0;
+      return 1;
+    }
+  return -1;
+}
+
+/* generic allocators
+ */
+struct _GAllocator /* from gmem.c */
+{
+  gchar		*name;
+  guint16	 n_preallocs;
+  guint		 is_unused : 1;
+  guint		 type : 4;
+  GAllocator	*last;
+  GMemChunk	*mem_chunk;
+  gpointer	 dummy; /* implementation specific */
+};
+
+GAllocator*
+g_allocator_new (const gchar *name,
+		 guint        n_preallocs)
+{
+  GAllocator *allocator;
+
+  g_return_val_if_fail (name != NULL, NULL);
+
+  allocator = g_new0 (GAllocator, 1);
+  allocator->name = g_strdup (name);
+  allocator->n_preallocs = CLAMP (n_preallocs, 1, 65535);
+  allocator->is_unused = TRUE;
+  allocator->type = 0;
+  allocator->last = NULL;
+  allocator->mem_chunk = NULL;
+  allocator->dummy = NULL;
+
+  return allocator;
+}
+
+void
+g_allocator_free (GAllocator *allocator)
+{
+  g_return_if_fail (allocator != NULL);
+  g_return_if_fail (allocator->is_unused == TRUE);
+
+  g_free (allocator->name);
+  if (allocator->mem_chunk)
+    g_mem_chunk_destroy (allocator->mem_chunk);
+
+  g_free (allocator);
+}
+
+void
+g_mem_init (void)
+{
+#ifndef __KORBIT__
+  mem_chunks_lock = g_mutex_new();
+#endif /* !__KORBIT__ */
+}
diff -urN linux-2.4.1/net/korbit/kglib/gprimes.c linux-2.4.1-korbit/net/korbit/kglib/gprimes.c
--- linux-2.4.1/net/korbit/kglib/gprimes.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/gprimes.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,79 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "glib.h"
+
+static const guint g_primes[] =
+{
+  11,
+  19,
+  37,
+  73,
+  109,
+  163,
+  251,
+  367,
+  557,
+  823,
+  1237,
+  1861,
+  2777,
+  4177,
+  6247,
+  9371,
+  14057,
+  21089,
+  31627,
+  47431,
+  71143,
+  106721,
+  160073,
+  240101,
+  360163,
+  540217,
+  810343,
+  1215497,
+  1823231,
+  2734867,
+  4102283,
+  6153409,
+  9230113,
+  13845163,
+};
+
+static const guint g_nprimes = sizeof (g_primes) / sizeof (g_primes[0]);
+
+guint
+g_spaced_primes_closest (guint num)
+{
+  gint i;
+
+  for (i = 0; i < g_nprimes; i++)
+    if (g_primes[i] > num)
+      return g_primes[i];
+
+  return g_primes[g_nprimes - 1];
+}
diff -urN linux-2.4.1/net/korbit/kglib/gslist.c linux-2.4.1-korbit/net/korbit/kglib/gslist.c
--- linux-2.4.1/net/korbit/kglib/gslist.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/gslist.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,591 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "glib.h"
+
+
+struct _GAllocator /* from gmem.c */
+{
+  gchar         *name;
+  guint16        n_preallocs;
+  guint          is_unused : 1;
+  guint          type : 4;
+  GAllocator    *last;
+  GMemChunk     *mem_chunk;
+  GSList        *free_lists; /* implementation specific */
+};
+
+G_LOCK_DEFINE_STATIC (current_allocator);
+static GAllocator       *current_allocator = NULL;
+
+/* HOLDS: current_allocator_lock */
+static void
+g_slist_validate_allocator (GAllocator *allocator)
+{
+  g_return_if_fail (allocator != NULL);
+  g_return_if_fail (allocator->is_unused == TRUE);
+
+  if (allocator->type != G_ALLOCATOR_SLIST)
+    {
+      allocator->type = G_ALLOCATOR_SLIST;
+      if (allocator->mem_chunk)
+	{
+	  g_mem_chunk_destroy (allocator->mem_chunk);
+	  allocator->mem_chunk = NULL;
+	}
+    }
+
+  if (!allocator->mem_chunk)
+    {
+      allocator->mem_chunk = g_mem_chunk_new (allocator->name,
+					      sizeof (GSList),
+					      sizeof (GSList) * allocator->n_preallocs,
+					      G_ALLOC_ONLY);
+      allocator->free_lists = NULL;
+    }
+
+  allocator->is_unused = FALSE;
+}
+
+void
+g_slist_push_allocator (GAllocator *allocator)
+{
+  G_LOCK (current_allocator);
+  g_slist_validate_allocator (allocator);
+  allocator->last = current_allocator;
+  current_allocator = allocator;
+  G_UNLOCK (current_allocator);
+}
+
+void
+g_slist_pop_allocator (void)
+{
+  G_LOCK (current_allocator);
+  if (current_allocator)
+    {
+      GAllocator *allocator;
+
+      allocator = current_allocator;
+      current_allocator = allocator->last;
+      allocator->last = NULL;
+      allocator->is_unused = TRUE;
+    }
+  G_UNLOCK (current_allocator);
+}
+
+GSList*
+g_slist_alloc (void)
+{
+  GSList *list;
+
+  G_LOCK (current_allocator);
+  if (!current_allocator)
+    {
+      GAllocator *allocator = g_allocator_new ("GLib default GSList allocator",
+					       128);
+      g_slist_validate_allocator (allocator);
+      allocator->last = NULL;
+      current_allocator = allocator; 
+    }
+  if (!current_allocator->free_lists)
+    {
+      list = g_chunk_new (GSList, current_allocator->mem_chunk);
+      list->data = NULL;
+    }
+  else
+    {
+      if (current_allocator->free_lists->data)
+	{
+	  list = current_allocator->free_lists->data;
+	  current_allocator->free_lists->data = list->next;
+	  list->data = NULL;
+	}
+      else
+	{
+	  list = current_allocator->free_lists;
+	  current_allocator->free_lists = list->next;
+	}
+    }
+  G_UNLOCK (current_allocator);
+  
+  list->next = NULL;
+
+  return list;
+}
+
+void
+g_slist_free (GSList *list)
+{
+  if (list)
+    {
+      list->data = list->next;
+      G_LOCK (current_allocator);
+      list->next = current_allocator->free_lists;
+      current_allocator->free_lists = list;
+      G_UNLOCK (current_allocator);
+    }
+}
+
+void
+g_slist_free_1 (GSList *list)
+{
+  if (list)
+    {
+      list->data = NULL;
+      G_LOCK (current_allocator);
+      list->next = current_allocator->free_lists;
+      current_allocator->free_lists = list;
+      G_UNLOCK (current_allocator);
+    }
+}
+
+GSList*
+g_slist_append (GSList   *list,
+		gpointer  data)
+{
+  GSList *new_list;
+  GSList *last;
+
+  new_list = g_slist_alloc ();
+  new_list->data = data;
+
+  if (list)
+    {
+      last = g_slist_last (list);
+      /* g_assert (last != NULL); */
+      last->next = new_list;
+
+      return list;
+    }
+  else
+      return new_list;
+}
+
+GSList*
+g_slist_prepend (GSList   *list,
+		 gpointer  data)
+{
+  GSList *new_list;
+
+  new_list = g_slist_alloc ();
+  new_list->data = data;
+  new_list->next = list;
+
+  return new_list;
+}
+
+GSList*
+g_slist_insert (GSList   *list,
+		gpointer  data,
+		gint      position)
+{
+  GSList *prev_list;
+  GSList *tmp_list;
+  GSList *new_list;
+
+  if (position < 0)
+    return g_slist_append (list, data);
+  else if (position == 0)
+    return g_slist_prepend (list, data);
+
+  new_list = g_slist_alloc ();
+  new_list->data = data;
+
+  if (!list)
+    return new_list;
+
+  prev_list = NULL;
+  tmp_list = list;
+
+  while ((position-- > 0) && tmp_list)
+    {
+      prev_list = tmp_list;
+      tmp_list = tmp_list->next;
+    }
+
+  if (prev_list)
+    {
+      new_list->next = prev_list->next;
+      prev_list->next = new_list;
+    }
+  else
+    {
+      new_list->next = list;
+      list = new_list;
+    }
+
+  return list;
+}
+
+GSList *
+g_slist_concat (GSList *list1, GSList *list2)
+{
+  if (list2)
+    {
+      if (list1)
+	g_slist_last (list1)->next = list2;
+      else
+	list1 = list2;
+    }
+
+  return list1;
+}
+
+GSList*
+g_slist_remove (GSList   *list,
+		gpointer  data)
+{
+  GSList *tmp;
+  GSList *prev;
+
+  prev = NULL;
+  tmp = list;
+
+  while (tmp)
+    {
+      if (tmp->data == data)
+	{
+	  if (prev)
+	    prev->next = tmp->next;
+	  if (list == tmp)
+	    list = list->next;
+
+	  tmp->next = NULL;
+	  g_slist_free (tmp);
+
+	  break;
+	}
+
+      prev = tmp;
+      tmp = tmp->next;
+    }
+
+  return list;
+}
+
+GSList*
+g_slist_remove_link (GSList *list,
+		     GSList *link)
+{
+  GSList *tmp;
+  GSList *prev;
+
+  prev = NULL;
+  tmp = list;
+
+  while (tmp)
+    {
+      if (tmp == link)
+	{
+	  if (prev)
+	    prev->next = tmp->next;
+	  if (list == tmp)
+	    list = list->next;
+
+	  tmp->next = NULL;
+	  break;
+	}
+
+      prev = tmp;
+      tmp = tmp->next;
+    }
+
+  return list;
+}
+
+GSList*
+g_slist_copy (GSList *list)
+{
+  GSList *new_list = NULL;
+
+  if (list)
+    {
+      GSList *last;
+
+      new_list = g_slist_alloc ();
+      new_list->data = list->data;
+      last = new_list;
+      list = list->next;
+      while (list)
+	{
+	  last->next = g_slist_alloc ();
+	  last = last->next;
+	  last->data = list->data;
+	  list = list->next;
+	}
+    }
+
+  return new_list;
+}
+
+GSList*
+g_slist_reverse (GSList *list)
+{
+  GSList *prev = NULL;
+
+  while (list)
+    {
+      GSList *next = list->next;
+
+      list->next = prev;
+
+      prev = list;
+      list = next;
+    }
+
+  return prev;
+}
+
+GSList*
+g_slist_nth (GSList *list,
+	     guint   n)
+{
+  while ((n-- > 0) && list)
+    list = list->next;
+
+  return list;
+}
+
+gpointer
+g_slist_nth_data (GSList   *list,
+		  guint     n)
+{
+  while ((n-- > 0) && list)
+    list = list->next;
+
+  return list ? list->data : NULL;
+}
+
+GSList*
+g_slist_find (GSList   *list,
+	      gpointer  data)
+{
+  while (list)
+    {
+      if (list->data == data)
+	break;
+      list = list->next;
+    }
+
+  return list;
+}
+
+GSList*
+g_slist_find_custom (GSList      *list,
+		     gpointer     data,
+		     GCompareFunc func)
+{
+  g_return_val_if_fail (func != NULL, list);
+
+  while (list)
+    {
+      if (! func (list->data, data))
+	return list;
+      list = list->next;
+    }
+
+  return NULL;
+}
+
+gint
+g_slist_position (GSList *list,
+		  GSList *link)
+{
+  gint i;
+
+  i = 0;
+  while (list)
+    {
+      if (list == link)
+	return i;
+      i++;
+      list = list->next;
+    }
+
+  return -1;
+}
+
+gint
+g_slist_index (GSList   *list,
+	       gpointer data)
+{
+  gint i;
+
+  i = 0;
+  while (list)
+    {
+      if (list->data == data)
+	return i;
+      i++;
+      list = list->next;
+    }
+
+  return -1;
+}
+
+GSList*
+g_slist_last (GSList *list)
+{
+  if (list)
+    {
+      while (list->next)
+	list = list->next;
+    }
+
+  return list;
+}
+
+guint
+g_slist_length (GSList *list)
+{
+  guint length;
+
+  length = 0;
+  while (list)
+    {
+      length++;
+      list = list->next;
+    }
+
+  return length;
+}
+
+void
+g_slist_foreach (GSList   *list,
+		 GFunc     func,
+		 gpointer  user_data)
+{
+  while (list)
+    {
+      (*func) (list->data, user_data);
+      list = list->next;
+    }
+}
+
+GSList*
+g_slist_insert_sorted (GSList       *list,
+                       gpointer      data,
+                       GCompareFunc  func)
+{
+  GSList *tmp_list = list;
+  GSList *prev_list = NULL;
+  GSList *new_list;
+  gint cmp;
+ 
+  g_return_val_if_fail (func != NULL, list);
+
+  if (!list)
+    {
+      new_list = g_slist_alloc();
+      new_list->data = data;
+      return new_list;
+    }
+ 
+  cmp = (*func) (data, tmp_list->data);
+ 
+  while ((tmp_list->next) && (cmp > 0))
+    {
+      prev_list = tmp_list;
+      tmp_list = tmp_list->next;
+      cmp = (*func) (data, tmp_list->data);
+    }
+
+  new_list = g_slist_alloc();
+  new_list->data = data;
+
+  if ((!tmp_list->next) && (cmp > 0))
+    {
+      tmp_list->next = new_list;
+      return list;
+    }
+  
+  if (prev_list)
+    {
+      prev_list->next = new_list;
+      new_list->next = tmp_list;
+      return list;
+    }
+  else
+    {
+      new_list->next = list;
+      return new_list;
+    }
+}
+
+static GSList* 
+g_slist_sort_merge  (GSList      *l1, 
+		     GSList      *l2,
+		     GCompareFunc compare_func)
+{
+  GSList list, *l;
+
+  l=&list;
+
+  while (l1 && l2)
+    {
+      if (compare_func(l1->data,l2->data) < 0)
+        {
+	  l=l->next=l1;
+	  l1=l1->next;
+        } 
+      else 
+	{
+	  l=l->next=l2;
+	  l2=l2->next;
+        }
+    }
+  l->next= l1 ? l1 : l2;
+  
+  return list.next;
+}
+
+GSList* 
+g_slist_sort (GSList       *list,
+	      GCompareFunc compare_func)
+{
+  GSList *l1, *l2;
+
+  if (!list) 
+    return NULL;
+  if (!list->next) 
+    return list;
+
+  l1 = list; 
+  l2 = list->next;
+
+  while ((l2 = l2->next) != NULL)
+    {
+      if ((l2 = l2->next) == NULL) 
+	break;
+      l1=l1->next;
+    }
+  l2 = l1->next; 
+  l1->next = NULL;
+
+  return g_slist_sort_merge (g_slist_sort (list, compare_func),
+			     g_slist_sort (l2,   compare_func),
+			     compare_func);
+}
diff -urN linux-2.4.1/net/korbit/kglib/gstrfuncs.c linux-2.4.1-korbit/net/korbit/kglib/gstrfuncs.c
--- linux-2.4.1/net/korbit/kglib/gstrfuncs.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/gstrfuncs.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,1308 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <locale.h>
+#include <ctype.h>		/* For tolower() */
+#if !defined (HAVE_STRSIGNAL) || !defined(NO_SYS_SIGLIST_DECL)
+#include <signal.h>
+#endif
+#include "glib.h"
+/* do not include <unistd.h> in this place since it
+ * inteferes with g_strsignal() on some OSes
+ */
+
+gchar*
+g_strdup (const gchar *str) {
+  gchar *new_str;
+
+  if (str)
+    {
+      new_str = g_new (char, strlen (str) + 1);
+      strcpy (new_str, str);
+    }
+  else
+    new_str = NULL;
+
+  return new_str;
+}
+
+gpointer
+g_memdup (gconstpointer mem,
+	  guint         byte_size)
+{
+  gpointer new_mem;
+
+  if (mem)
+    {
+      new_mem = g_malloc (byte_size);
+      memcpy (new_mem, mem, byte_size);
+    }
+  else
+    new_mem = NULL;
+
+  return new_mem;
+}
+
+gchar*
+g_strndup (const gchar *str,
+	   guint        n)
+{
+  gchar *new_str;
+
+  if (str)
+    {
+      new_str = g_new (gchar, n + 1);
+      strncpy (new_str, str, n);
+      new_str[n] = '\0';
+    }
+  else
+    new_str = NULL;
+
+  return new_str;
+}
+
+gchar*
+g_strnfill (guint length,
+	    gchar fill_char)
+{
+  register gchar *str, *s, *end;
+
+  str = g_new (gchar, length + 1);
+  s = str;
+  end = str + length;
+  while (s < end)
+    *(s++) = fill_char;
+  *s = 0;
+
+  return str;
+}
+
+gchar*
+g_strdup_vprintf (const gchar *format,
+		  va_list      args1)
+{
+  gchar *buffer;
+  va_list args2;
+
+  G_VA_COPY (args2, args1);
+
+  buffer = g_new (gchar, g_printf_string_upper_bound (format, args1));
+
+  vsprintf (buffer, format, args2);
+  va_end (args2);
+
+  return buffer;
+}
+
+gchar*
+g_strdup_printf (const gchar *format,
+		 ...)
+{
+  gchar *buffer;
+  va_list args;
+
+  va_start (args, format);
+  buffer = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  return buffer;
+}
+
+gchar*
+g_strconcat (const gchar *string1, ...)
+{
+  guint	  l;
+  va_list args;
+  gchar	  *s;
+  gchar	  *concat;
+
+  g_return_val_if_fail (string1 != NULL, NULL);
+
+  l = 1 + strlen (string1);
+  va_start (args, string1);
+  s = va_arg (args, gchar*);
+  while (s)
+    {
+      l += strlen (s);
+      s = va_arg (args, gchar*);
+    }
+  va_end (args);
+
+  concat = g_new (gchar, l);
+  concat[0] = 0;
+
+  strcat (concat, string1);
+  va_start (args, string1);
+  s = va_arg (args, gchar*);
+  while (s)
+    {
+      strcat (concat, s);
+      s = va_arg (args, gchar*);
+    }
+  va_end (args);
+
+  return concat;
+}
+
+#ifndef __KORBIT__
+gdouble
+g_strtod (const gchar *nptr,
+	  gchar **endptr)
+{
+  gchar *fail_pos_1;
+  gchar *fail_pos_2;
+  gdouble val_1;
+  gdouble val_2 = 0;
+
+  g_return_val_if_fail (nptr != NULL, 0);
+
+  fail_pos_1 = NULL;
+  fail_pos_2 = NULL;
+
+  val_1 = strtod (nptr, &fail_pos_1);
+
+  if (fail_pos_1 && fail_pos_1[0] != 0)
+    {
+      gchar *old_locale;
+
+      old_locale = g_strdup (setlocale (LC_NUMERIC, NULL));
+      setlocale (LC_NUMERIC, "C");
+      val_2 = strtod (nptr, &fail_pos_2);
+      setlocale (LC_NUMERIC, old_locale);
+      g_free (old_locale);
+    }
+
+  if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)
+    {
+      if (endptr)
+	*endptr = fail_pos_1;
+      return val_1;
+    }
+  else
+    {
+      if (endptr)
+	*endptr = fail_pos_2;
+      return val_2;
+    }
+}
+#endif /* !__KORBIT__ */
+
+gchar*
+g_strerror (gint errnum)
+{
+#ifndef __KORBIT__
+  static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
+  char *msg;
+#endif
+
+#ifdef __KORBIT__
+#undef HAVE_STRERROR
+#define NO_SYS_ERRLIST 1
+#endif
+
+#if defined(HAVE_STRERROR)
+  return strerror (errnum);
+#elif NO_SYS_ERRLIST
+  switch (errnum)
+    {
+#ifdef E2BIG
+    case E2BIG: return "argument list too long";
+#endif
+#ifdef EACCES
+    case EACCES: return "permission denied";
+#endif
+#ifdef EADDRINUSE
+    case EADDRINUSE: return "address already in use";
+#endif
+#ifdef EADDRNOTAVAIL
+    case EADDRNOTAVAIL: return "can't assign requested address";
+#endif
+#ifdef EADV
+    case EADV: return "advertise error";
+#endif
+#ifdef EAFNOSUPPORT
+    case EAFNOSUPPORT: return "address family not supported by protocol family";
+#endif
+#ifdef EAGAIN
+    case EAGAIN: return "try again";
+#endif
+#ifdef EALIGN
+    case EALIGN: return "EALIGN";
+#endif
+#ifdef EALREADY
+    case EALREADY: return "operation already in progress";
+#endif
+#ifdef EBADE
+    case EBADE: return "bad exchange descriptor";
+#endif
+#ifdef EBADF
+    case EBADF: return "bad file number";
+#endif
+#ifdef EBADFD
+    case EBADFD: return "file descriptor in bad state";
+#endif
+#ifdef EBADMSG
+    case EBADMSG: return "not a data message";
+#endif
+#ifdef EBADR
+    case EBADR: return "bad request descriptor";
+#endif
+#ifdef EBADRPC
+    case EBADRPC: return "RPC structure is bad";
+#endif
+#ifdef EBADRQC
+    case EBADRQC: return "bad request code";
+#endif
+#ifdef EBADSLT
+    case EBADSLT: return "invalid slot";
+#endif
+#ifdef EBFONT
+    case EBFONT: return "bad font file format";
+#endif
+#ifdef EBUSY
+    case EBUSY: return "mount device busy";
+#endif
+#ifdef ECHILD
+    case ECHILD: return "no children";
+#endif
+#ifdef ECHRNG
+    case ECHRNG: return "channel number out of range";
+#endif
+#ifdef ECOMM
+    case ECOMM: return "communication error on send";
+#endif
+#ifdef ECONNABORTED
+    case ECONNABORTED: return "software caused connection abort";
+#endif
+#ifdef ECONNREFUSED
+    case ECONNREFUSED: return "connection refused";
+#endif
+#ifdef ECONNRESET
+    case ECONNRESET: return "connection reset by peer";
+#endif
+#if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK)) && (!defined(EDEADLOCK) || (EDEADLK != EDEADLOCK))
+    case EDEADLK: return "resource deadlock avoided";
+#endif
+#ifdef EDEADLOCK
+    case EDEADLOCK: return "resource deadlock avoided";
+#endif
+#ifdef EDESTADDRREQ
+    case EDESTADDRREQ: return "destination address required";
+#endif
+#ifdef EDIRTY
+    case EDIRTY: return "mounting a dirty fs w/o force";
+#endif
+#ifdef EDOM
+    case EDOM: return "math argument out of range";
+#endif
+#ifdef EDOTDOT
+    case EDOTDOT: return "cross mount point";
+#endif
+#ifdef EDQUOT
+    case EDQUOT: return "disk quota exceeded";
+#endif
+#ifdef EDUPPKG
+    case EDUPPKG: return "duplicate package name";
+#endif
+#ifdef EEXIST
+    case EEXIST: return "file already exists";
+#endif
+#ifdef EFAULT
+    case EFAULT: return "bad address in system call argument";
+#endif
+#ifdef EFBIG
+    case EFBIG: return "file too large";
+#endif
+#ifdef EHOSTDOWN
+    case EHOSTDOWN: return "host is down";
+#endif
+#ifdef EHOSTUNREACH
+    case EHOSTUNREACH: return "host is unreachable";
+#endif
+#ifdef EIDRM
+    case EIDRM: return "identifier removed";
+#endif
+#ifdef EINIT
+    case EINIT: return "initialization error";
+#endif
+#ifdef EINPROGRESS
+    case EINPROGRESS: return "operation now in progress";
+#endif
+#ifdef EINTR
+    case EINTR: return "interrupted system call";
+#endif
+#ifdef EINVAL
+    case EINVAL: return "invalid argument";
+#endif
+#ifdef EIO
+    case EIO: return "I/O error";
+#endif
+#ifdef EISCONN
+    case EISCONN: return "socket is already connected";
+#endif
+#ifdef EISDIR
+    case EISDIR: return "illegal operation on a directory";
+#endif
+#ifdef EISNAME
+    case EISNAM: return "is a name file";
+#endif
+#ifdef ELBIN
+    case ELBIN: return "ELBIN";
+#endif
+#ifdef EL2HLT
+    case EL2HLT: return "level 2 halted";
+#endif
+#ifdef EL2NSYNC
+    case EL2NSYNC: return "level 2 not synchronized";
+#endif
+#ifdef EL3HLT
+    case EL3HLT: return "level 3 halted";
+#endif
+#ifdef EL3RST
+    case EL3RST: return "level 3 reset";
+#endif
+#ifdef ELIBACC
+    case ELIBACC: return "can not access a needed shared library";
+#endif
+#ifdef ELIBBAD
+    case ELIBBAD: return "accessing a corrupted shared library";
+#endif
+#ifdef ELIBEXEC
+    case ELIBEXEC: return "can not exec a shared library directly";
+#endif
+#ifdef ELIBMAX
+    case ELIBMAX: return "attempting to link in more shared libraries than system limit";
+#endif
+#ifdef ELIBSCN
+    case ELIBSCN: return ".lib section in a.out corrupted";
+#endif
+#ifdef ELNRNG
+    case ELNRNG: return "link number out of range";
+#endif
+#ifdef ELOOP
+    case ELOOP: return "too many levels of symbolic links";
+#endif
+#ifdef EMFILE
+    case EMFILE: return "too many open files";
+#endif
+#ifdef EMLINK
+    case EMLINK: return "too many links";
+#endif
+#ifdef EMSGSIZE
+    case EMSGSIZE: return "message too long";
+#endif
+#ifdef EMULTIHOP
+    case EMULTIHOP: return "multihop attempted";
+#endif
+#ifdef ENAMETOOLONG
+    case ENAMETOOLONG: return "file name too long";
+#endif
+#ifdef ENAVAIL
+    case ENAVAIL: return "not available";
+#endif
+#ifdef ENET
+    case ENET: return "ENET";
+#endif
+#ifdef ENETDOWN
+    case ENETDOWN: return "network is down";
+#endif
+#ifdef ENETRESET
+    case ENETRESET: return "network dropped connection on reset";
+#endif
+#ifdef ENETUNREACH
+    case ENETUNREACH: return "network is unreachable";
+#endif
+#ifdef ENFILE
+    case ENFILE: return "file table overflow";
+#endif
+#ifdef ENOANO
+    case ENOANO: return "anode table overflow";
+#endif
+#if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))
+    case ENOBUFS: return "no buffer space available";
+#endif
+#ifdef ENOCSI
+    case ENOCSI: return "no CSI structure available";
+#endif
+#ifdef ENODATA
+    case ENODATA: return "no data available";
+#endif
+#ifdef ENODEV
+    case ENODEV: return "no such device";
+#endif
+#ifdef ENOENT
+    case ENOENT: return "no such file or directory";
+#endif
+#ifdef ENOEXEC
+    case ENOEXEC: return "exec format error";
+#endif
+#ifdef ENOLCK
+    case ENOLCK: return "no locks available";
+#endif
+#ifdef ENOLINK
+    case ENOLINK: return "link has be severed";
+#endif
+#ifdef ENOMEM
+    case ENOMEM: return "not enough memory";
+#endif
+#ifdef ENOMSG
+    case ENOMSG: return "no message of desired type";
+#endif
+#ifdef ENONET
+    case ENONET: return "machine is not on the network";
+#endif
+#ifdef ENOPKG
+    case ENOPKG: return "package not installed";
+#endif
+#ifdef ENOPROTOOPT
+    case ENOPROTOOPT: return "bad proocol option";
+#endif
+#ifdef ENOSPC
+    case ENOSPC: return "no space left on device";
+#endif
+#ifdef ENOSR
+    case ENOSR: return "out of stream resources";
+#endif
+#ifdef ENOSTR
+    case ENOSTR: return "not a stream device";
+#endif
+#ifdef ENOSYM
+    case ENOSYM: return "unresolved symbol name";
+#endif
+#ifdef ENOSYS
+    case ENOSYS: return "function not implemented";
+#endif
+#ifdef ENOTBLK
+    case ENOTBLK: return "block device required";
+#endif
+#ifdef ENOTCONN
+    case ENOTCONN: return "socket is not connected";
+#endif
+#ifdef ENOTDIR
+    case ENOTDIR: return "not a directory";
+#endif
+#ifdef ENOTEMPTY
+    case ENOTEMPTY: return "directory not empty";
+#endif
+#ifdef ENOTNAM
+    case ENOTNAM: return "not a name file";
+#endif
+#ifdef ENOTSOCK
+    case ENOTSOCK: return "socket operation on non-socket";
+#endif
+#ifdef ENOTTY
+    case ENOTTY: return "inappropriate device for ioctl";
+#endif
+#ifdef ENOTUNIQ
+    case ENOTUNIQ: return "name not unique on network";
+#endif
+#ifdef ENXIO
+    case ENXIO: return "no such device or address";
+#endif
+#ifdef EOPNOTSUPP
+    case EOPNOTSUPP: return "operation not supported on socket";
+#endif
+#ifdef EPERM
+    case EPERM: return "not owner";
+#endif
+#ifdef EPFNOSUPPORT
+    case EPFNOSUPPORT: return "protocol family not supported";
+#endif
+#ifdef EPIPE
+    case EPIPE: return "broken pipe";
+#endif
+#ifdef EPROCLIM
+    case EPROCLIM: return "too many processes";
+#endif
+#ifdef EPROCUNAVAIL
+    case EPROCUNAVAIL: return "bad procedure for program";
+#endif
+#ifdef EPROGMISMATCH
+    case EPROGMISMATCH: return "program version wrong";
+#endif
+#ifdef EPROGUNAVAIL
+    case EPROGUNAVAIL: return "RPC program not available";
+#endif
+#ifdef EPROTO
+    case EPROTO: return "protocol error";
+#endif
+#ifdef EPROTONOSUPPORT
+    case EPROTONOSUPPORT: return "protocol not suppored";
+#endif
+#ifdef EPROTOTYPE
+    case EPROTOTYPE: return "protocol wrong type for socket";
+#endif
+#ifdef ERANGE
+    case ERANGE: return "math result unrepresentable";
+#endif
+#if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))
+    case EREFUSED: return "EREFUSED";
+#endif
+#ifdef EREMCHG
+    case EREMCHG: return "remote address changed";
+#endif
+#ifdef EREMDEV
+    case EREMDEV: return "remote device";
+#endif
+#ifdef EREMOTE
+    case EREMOTE: return "pathname hit remote file system";
+#endif
+#ifdef EREMOTEIO
+    case EREMOTEIO: return "remote i/o error";
+#endif
+#ifdef EREMOTERELEASE
+    case EREMOTERELEASE: return "EREMOTERELEASE";
+#endif
+#ifdef EROFS
+    case EROFS: return "read-only file system";
+#endif
+#ifdef ERPCMISMATCH
+    case ERPCMISMATCH: return "RPC version is wrong";
+#endif
+#ifdef ERREMOTE
+    case ERREMOTE: return "object is remote";
+#endif
+#ifdef ESHUTDOWN
+    case ESHUTDOWN: return "can't send afer socket shutdown";
+#endif
+#ifdef ESOCKTNOSUPPORT
+    case ESOCKTNOSUPPORT: return "socket type not supported";
+#endif
+#ifdef ESPIPE
+    case ESPIPE: return "invalid seek";
+#endif
+#ifdef ESRCH
+    case ESRCH: return "no such process";
+#endif
+#ifdef ESRMNT
+    case ESRMNT: return "srmount error";
+#endif
+#ifdef ESTALE
+    case ESTALE: return "stale remote file handle";
+#endif
+#ifdef ESUCCESS
+    case ESUCCESS: return "Error 0";
+#endif
+#ifdef ETIME
+    case ETIME: return "timer expired";
+#endif
+#ifdef ETIMEDOUT
+    case ETIMEDOUT: return "connection timed out";
+#endif
+#ifdef ETOOMANYREFS
+    case ETOOMANYREFS: return "too many references: can't splice";
+#endif
+#ifdef ETXTBSY
+    case ETXTBSY: return "text file or pseudo-device busy";
+#endif
+#ifdef EUCLEAN
+    case EUCLEAN: return "structure needs cleaning";
+#endif
+#ifdef EUNATCH
+    case EUNATCH: return "protocol driver not attached";
+#endif
+#ifdef EUSERS
+    case EUSERS: return "too many users";
+#endif
+#ifdef EVERSION
+    case EVERSION: return "version mismatch";
+#endif
+#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
+    case EWOULDBLOCK: return "operation would block";
+#endif
+#ifdef EXDEV
+    case EXDEV: return "cross-domain link";
+#endif
+#ifdef EXFULL
+    case EXFULL: return "message tables full";
+#endif
+    }
+#else /* NO_SYS_ERRLIST */
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+
+  if ((errnum > 0) && (errnum <= sys_nerr))
+    return sys_errlist [errnum];
+#endif /* NO_SYS_ERRLIST */
+
+#ifndef __KORBIT__
+  msg = g_static_private_get (&msg_private);
+  if (!msg)
+    {
+      msg = g_new (gchar, 64);
+      g_static_private_set (&msg_private, msg, g_free);
+    }
+
+  sprintf (msg, "unknown error (%d)", errnum);
+
+  return msg;
+#else
+  return "unknown error";
+#endif /* !__KORBIT__ */
+}
+
+gchar*
+g_strsignal (gint signum)
+{
+#ifndef __KORBIT__
+  static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
+  char *msg;
+#endif
+
+#ifdef HAVE_STRSIGNAL
+  extern char *strsignal (int sig);
+  return strsignal (signum);
+#elif NO_SYS_SIGLIST
+  switch (signum)
+    {
+#ifdef SIGHUP
+    case SIGHUP: return "Hangup";
+#endif
+#ifdef SIGINT
+    case SIGINT: return "Interrupt";
+#endif
+#ifdef SIGQUIT
+    case SIGQUIT: return "Quit";
+#endif
+#ifdef SIGILL
+    case SIGILL: return "Illegal instruction";
+#endif
+#ifdef SIGTRAP
+    case SIGTRAP: return "Trace/breakpoint trap";
+#endif
+#ifdef SIGABRT
+    case SIGABRT: return "IOT trap/Abort";
+#endif
+#ifdef SIGBUS
+    case SIGBUS: return "Bus error";
+#endif
+#ifdef SIGFPE
+    case SIGFPE: return "Floating point exception";
+#endif
+#ifdef SIGKILL
+    case SIGKILL: return "Killed";
+#endif
+#ifdef SIGUSR1
+    case SIGUSR1: return "User defined signal 1";
+#endif
+#ifdef SIGSEGV
+    case SIGSEGV: return "Segmentation fault";
+#endif
+#ifdef SIGUSR2
+    case SIGUSR2: return "User defined signal 2";
+#endif
+#ifdef SIGPIPE
+    case SIGPIPE: return "Broken pipe";
+#endif
+#ifdef SIGALRM
+    case SIGALRM: return "Alarm clock";
+#endif
+#ifdef SIGTERM
+    case SIGTERM: return "Terminated";
+#endif
+#ifdef SIGSTKFLT
+    case SIGSTKFLT: return "Stack fault";
+#endif
+#ifdef SIGCHLD
+    case SIGCHLD: return "Child exited";
+#endif
+#ifdef SIGCONT
+    case SIGCONT: return "Continued";
+#endif
+#ifdef SIGSTOP
+    case SIGSTOP: return "Stopped (signal)";
+#endif
+#ifdef SIGTSTP
+    case SIGTSTP: return "Stopped";
+#endif
+#ifdef SIGTTIN
+    case SIGTTIN: return "Stopped (tty input)";
+#endif
+#ifdef SIGTTOU
+    case SIGTTOU: return "Stopped (tty output)";
+#endif
+#ifdef SIGURG
+    case SIGURG: return "Urgent condition";
+#endif
+#ifdef SIGXCPU
+    case SIGXCPU: return "CPU time limit exceeded";
+#endif
+#ifdef SIGXFSZ
+    case SIGXFSZ: return "File size limit exceeded";
+#endif
+#ifdef SIGVTALRM
+    case SIGVTALRM: return "Virtual time alarm";
+#endif
+#ifdef SIGPROF
+    case SIGPROF: return "Profile signal";
+#endif
+#ifdef SIGWINCH
+    case SIGWINCH: return "Window size changed";
+#endif
+#ifdef SIGIO
+    case SIGIO: return "Possible I/O";
+#endif
+#ifdef SIGPWR
+    case SIGPWR: return "Power failure";
+#endif
+#ifdef SIGUNUSED
+    case SIGUNUSED: return "Unused signal";
+#endif
+    }
+#else /* NO_SYS_SIGLIST */
+
+#ifdef NO_SYS_SIGLIST_DECL
+  extern char *sys_siglist[];	/*(see Tue Jan 19 00:44:24 1999 in changelog)*/
+#endif
+
+  return (char*) /* this function should return const --josh */ sys_siglist [signum];
+#endif /* NO_SYS_SIGLIST */
+
+#ifndef __KORBIT__
+  msg = g_static_private_get (&msg_private);
+  if (!msg)
+    {
+      msg = g_new (gchar, 64);
+      g_static_private_set (&msg_private, msg, g_free);
+    }
+
+  sprintf (msg, "unknown signal (%d)", signum);
+
+  return msg;
+#else
+  return "unknown error";
+#endif /* !__KORBIT__ */
+}
+
+guint
+g_printf_string_upper_bound (const gchar* format,
+			     va_list      args)
+{
+  guint len = 1;
+
+  while (*format)
+    {
+      gboolean long_int = FALSE;
+      gboolean extra_long = FALSE;
+      gchar c;
+
+      c = *format++;
+
+      if (c == '%')
+	{
+	  gboolean done = FALSE;
+
+	  while (*format && !done)
+	    {
+	      switch (*format++)
+		{
+		  gchar *string_arg;
+
+		case '*':
+		  len += va_arg (args, int);
+		  break;
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+		  /* add specified format length, since it might exceed the
+		   * size we assume it to have.
+		   */
+		  format -= 1;
+		  len += strtol (format, (char**) &format, 10);
+		  break;
+		case 'h':
+		  /* ignore short int flag, since all args have at least the
+		   * same size as an int
+		   */
+		  break;
+		case 'l':
+		  if (long_int)
+		    extra_long = TRUE; /* linux specific */
+		  else
+		    long_int = TRUE;
+		  break;
+		case 'q':
+		case 'L':
+		  long_int = TRUE;
+		  extra_long = TRUE;
+		  break;
+		case 's':
+		  string_arg = va_arg (args, char *);
+		  if (string_arg)
+		    len += strlen (string_arg);
+		  else
+		    {
+		      /* add enough padding to hold "(null)" identifier */
+		      len += 16;
+		    }
+		  done = TRUE;
+		  break;
+		case 'd':
+		case 'i':
+		case 'o':
+		case 'u':
+		case 'x':
+		case 'X':
+#ifdef	G_HAVE_GINT64
+		  if (extra_long)
+		    (void) va_arg (args, gint64);
+		  else
+#endif	/* G_HAVE_GINT64 */
+		    {
+		      if (long_int)
+			(void) va_arg (args, long);
+		      else
+			(void) va_arg (args, int);
+		    }
+		  len += extra_long ? 64 : 32;
+		  done = TRUE;
+		  break;
+		case 'D':
+		case 'O':
+		case 'U':
+		  (void) va_arg (args, long);
+		  len += 32;
+		  done = TRUE;
+		  break;
+		case 'e':
+		case 'E':
+		case 'f':
+		case 'g':
+#ifdef HAVE_LONG_DOUBLE
+		  if (extra_long)
+		    (void) va_arg (args, long double);
+		  else
+#endif	/* HAVE_LONG_DOUBLE */
+		    (void) va_arg (args, double);
+		  len += extra_long ? 128 : 64;
+		  done = TRUE;
+		  break;
+		case 'c':
+		  (void) va_arg (args, int);
+		  len += 1;
+		  done = TRUE;
+		  break;
+		case 'p':
+		case 'n':
+		  (void) va_arg (args, void*);
+		  len += 32;
+		  done = TRUE;
+		  break;
+		case '%':
+		  len += 1;
+		  done = TRUE;
+		  break;
+		default:
+		  /* ignore unknow/invalid flags */
+		  break;
+		}
+	    }
+	}
+      else
+	len += 1;
+    }
+
+  return len;
+}
+
+void
+g_strdown (gchar *string)
+{
+  register guchar *s;
+
+  g_return_if_fail (string != NULL);
+
+  s = string;
+
+  while (*s)
+    {
+      *s = tolower (*s);
+      s++;
+    }
+}
+
+void
+g_strup (gchar *string)
+{
+  register guchar *s;
+
+  g_return_if_fail (string != NULL);
+
+  s = string;
+
+  while (*s)
+    {
+      *s = toupper (*s);
+      s++;
+    }
+}
+
+void
+g_strreverse (gchar *string)
+{
+  g_return_if_fail (string != NULL);
+
+  if (*string)
+    {
+      register gchar *h, *t;
+
+      h = string;
+      t = string + strlen (string) - 1;
+
+      while (h < t)
+	{
+	  register gchar c;
+
+	  c = *h;
+	  *h = *t;
+	  h++;
+	  *t = c;
+	  t--;
+	}
+    }
+}
+
+gint
+g_strcasecmp (const gchar *s1,
+	      const gchar *s2)
+{
+#ifdef HAVE_STRCASECMP
+  g_return_val_if_fail (s1 != NULL, 0);
+  g_return_val_if_fail (s2 != NULL, 0);
+
+  return strcasecmp (s1, s2);
+#else
+  gint c1, c2;
+
+  g_return_val_if_fail (s1 != NULL, 0);
+  g_return_val_if_fail (s2 != NULL, 0);
+
+  while (*s1 && *s2)
+    {
+      /* According to A. Cox, some platforms have islower's that
+       * don't work right on non-uppercase
+       */
+      c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
+      c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
+      if (c1 != c2)
+	return (c1 - c2);
+      s1++; s2++;
+    }
+
+  return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
+#endif
+}
+
+gint
+g_strncasecmp (const gchar *s1,
+	       const gchar *s2,
+	       guint n)
+{
+#ifdef HAVE_STRNCASECMP
+  return strncasecmp (s1, s2, n);
+#else
+  gint c1, c2;
+
+  g_return_val_if_fail (s1 != NULL, 0);
+  g_return_val_if_fail (s2 != NULL, 0);
+
+  while (n-- && *s1 && *s2)
+    {
+      /* According to A. Cox, some platforms have islower's that
+       * don't work right on non-uppercase
+       */
+      c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
+      c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
+      if (c1 != c2)
+	return (c1 - c2);
+      s1++; s2++;
+    }
+
+  if (n)
+    return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
+  else
+    return 0;
+#endif
+}
+
+gchar*
+g_strdelimit (gchar	  *string,
+	      const gchar *delimiters,
+	      gchar	   new_delim)
+{
+  register gchar *c;
+
+  g_return_val_if_fail (string != NULL, NULL);
+
+  if (!delimiters)
+    delimiters = G_STR_DELIMITERS;
+
+  for (c = string; *c; c++)
+    {
+      if (strchr (delimiters, *c))
+	*c = new_delim;
+    }
+
+  return string;
+}
+
+gchar*
+g_strescape (gchar *string)
+{
+  gchar *q;
+  gchar *escaped;
+  guint backslashes = 0;
+  gchar *p = string;
+
+  g_return_val_if_fail (string != NULL, NULL);
+
+  while (*p != '\000')
+    backslashes += (*p++ == '\\');
+
+  if (!backslashes)
+    return g_strdup (string);
+
+  escaped = g_new (gchar, strlen (string) + backslashes + 1);
+
+  p = string;
+  q = escaped;
+
+  while (*p != '\000')
+    {
+      if (*p == '\\')
+	*q++ = '\\';
+      *q++ = *p++;
+    }
+  *q = '\000';
+
+  return escaped;
+}
+
+/* blame Elliot for these next five routines */
+gchar*
+g_strchug (gchar *string)
+{
+  guchar *start;
+
+  g_return_val_if_fail (string != NULL, NULL);
+
+  for (start = string; *start && isspace (*start); start++)
+    ;
+
+  g_memmove(string, start, strlen(start) + 1);
+
+  return string;
+}
+
+gchar*
+g_strchomp (gchar *string)
+{
+  gchar *s;
+
+  g_return_val_if_fail (string != NULL, NULL);
+
+  if (!*string)
+    return string;
+
+  for (s = string + strlen (string) - 1; s >= string && isspace ((guchar)*s); 
+       s--)
+    *s = '\0';
+
+  return string;
+}
+
+gchar**
+g_strsplit (const gchar *string,
+	    const gchar *delimiter,
+	    gint         max_tokens)
+{
+  GSList *string_list = NULL, *slist;
+  gchar **str_array, *s;
+  guint i, n = 1;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_return_val_if_fail (delimiter != NULL, NULL);
+
+  if (max_tokens < 1)
+    max_tokens = G_MAXINT;
+
+  s = strstr (string, delimiter);
+  if (s)
+    {
+      guint delimiter_len = strlen (delimiter);
+
+      do
+	{
+	  guint len;
+	  gchar *new_string;
+
+	  len = s - string;
+	  new_string = g_new (gchar, len + 1);
+	  strncpy (new_string, string, len);
+	  new_string[len] = 0;
+	  string_list = g_slist_prepend (string_list, new_string);
+	  n++;
+	  string = s + delimiter_len;
+	  s = strstr (string, delimiter);
+	}
+      while (--max_tokens && s);
+    }
+  if (*string)
+    {
+      n++;
+      string_list = g_slist_prepend (string_list, g_strdup (string));
+    }
+
+  str_array = g_new (gchar*, n);
+
+  i = n - 1;
+
+  str_array[i--] = NULL;
+  for (slist = string_list; slist; slist = slist->next)
+    str_array[i--] = slist->data;
+
+  g_slist_free (string_list);
+
+  return str_array;
+}
+
+void
+g_strfreev (gchar **str_array)
+{
+  if (str_array)
+    {
+      int i;
+
+      for(i = 0; str_array[i] != NULL; i++)
+	g_free(str_array[i]);
+
+      g_free (str_array);
+    }
+}
+
+gchar*
+g_strjoinv (const gchar  *separator,
+	    gchar       **str_array)
+{
+  gchar *string;
+
+  g_return_val_if_fail (str_array != NULL, NULL);
+
+  if (separator == NULL)
+    separator = "";
+
+  if (*str_array)
+    {
+      guint i, len;
+      guint separator_len;
+
+      separator_len = strlen (separator);
+      len = 1 + strlen (str_array[0]);
+      for(i = 1; str_array[i] != NULL; i++)
+	len += separator_len + strlen(str_array[i]);
+
+      string = g_new (gchar, len);
+      *string = 0;
+      strcat (string, *str_array);
+      for (i = 1; str_array[i] != NULL; i++)
+	{
+	  strcat (string, separator);
+	  strcat (string, str_array[i]);
+	}
+      }
+  else
+    string = g_strdup ("");
+
+  return string;
+}
+
+gchar*
+g_strjoin (const gchar  *separator,
+	   ...)
+{
+  gchar *string, *s;
+  va_list args;
+  guint len;
+  guint separator_len;
+
+  if (separator == NULL)
+    separator = "";
+
+  separator_len = strlen (separator);
+
+  va_start (args, separator);
+
+  s = va_arg (args, gchar*);
+
+  if (s)
+    {
+      len = strlen (s);
+      
+      s = va_arg (args, gchar*);
+      while (s)
+	{
+	  len += separator_len + strlen (s);
+	  s = va_arg (args, gchar*);
+	}
+      va_end (args);
+      
+      string = g_new (gchar, len + 1);
+      *string = 0;
+      
+      va_start (args, separator);
+      
+      s = va_arg (args, gchar*);
+      strcat (string, s);
+      
+      s = va_arg (args, gchar*);
+      while (s)
+	{
+	  strcat (string, separator);
+	  strcat (string, s);
+	  s = va_arg (args, gchar*);
+	}
+    }
+  else
+    string = g_strdup ("");
+  
+  va_end (args);
+
+  return string;
+}
diff -urN linux-2.4.1/net/korbit/kglib/gstring.c linux-2.4.1-korbit/net/korbit/kglib/gstring.c
--- linux-2.4.1/net/korbit/kglib/gstring.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/gstring.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,508 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include "glib.h"
+
+
+typedef struct _GRealStringChunk GRealStringChunk;
+typedef struct _GRealString      GRealString;
+
+struct _GRealStringChunk
+{
+  GHashTable *const_table;
+  GSList     *storage_list;
+  gint        storage_next;
+  gint        this_size;
+  gint        default_size;
+};
+
+struct _GRealString
+{
+  gchar *str;
+  gint   len;
+  gint   alloc;
+};
+
+G_LOCK_DEFINE_STATIC (string_mem_chunk);
+static GMemChunk *string_mem_chunk = NULL;
+
+/* Hash Functions.
+ */
+
+gint
+g_str_equal (gconstpointer v, gconstpointer v2)
+{
+  return strcmp ((const gchar*) v, (const gchar*)v2) == 0;
+}
+
+/* 31 bit hash function */
+guint
+g_str_hash (gconstpointer key)
+{
+  const char *p = key;
+  guint h = *p;
+  
+  if (h)
+    for (p += 1; *p != '\0'; p++)
+      h = (h << 5) - h + *p;
+  
+  return h;
+}
+
+/* String Chunks.
+ */
+
+GStringChunk*
+g_string_chunk_new (gint default_size)
+{
+  GRealStringChunk *new_chunk = g_new (GRealStringChunk, 1);
+  gint size = 1;
+
+  while (size < default_size)
+    size <<= 1;
+
+  new_chunk->const_table       = NULL;
+  new_chunk->storage_list      = NULL;
+  new_chunk->storage_next      = size;
+  new_chunk->default_size      = size;
+  new_chunk->this_size         = size;
+
+  return (GStringChunk*) new_chunk;
+}
+
+void
+g_string_chunk_free (GStringChunk *fchunk)
+{
+  GRealStringChunk *chunk = (GRealStringChunk*) fchunk;
+  GSList *tmp_list;
+
+  g_return_if_fail (chunk != NULL);
+
+  if (chunk->storage_list)
+    {
+      for (tmp_list = chunk->storage_list; tmp_list; tmp_list = tmp_list->next)
+	g_free (tmp_list->data);
+
+      g_slist_free (chunk->storage_list);
+    }
+
+  if (chunk->const_table)
+    g_hash_table_destroy (chunk->const_table);
+
+  g_free (chunk);
+}
+
+gchar*
+g_string_chunk_insert (GStringChunk *fchunk,
+		       const gchar  *string)
+{
+  GRealStringChunk *chunk = (GRealStringChunk*) fchunk;
+  gint len = strlen (string);
+  char* pos;
+
+  g_return_val_if_fail (chunk != NULL, NULL);
+
+  if ((chunk->storage_next + len + 1) > chunk->this_size)
+    {
+      gint new_size = chunk->default_size;
+
+      while (new_size < len+1)
+	new_size <<= 1;
+
+      chunk->storage_list = g_slist_prepend (chunk->storage_list,
+					     g_new (char, new_size));
+
+      chunk->this_size = new_size;
+      chunk->storage_next = 0;
+    }
+
+  pos = ((char*)chunk->storage_list->data) + chunk->storage_next;
+
+  strcpy (pos, string);
+
+  chunk->storage_next += len + 1;
+
+  return pos;
+}
+
+gchar*
+g_string_chunk_insert_const (GStringChunk *fchunk,
+			     const gchar  *string)
+{
+  GRealStringChunk *chunk = (GRealStringChunk*) fchunk;
+  char* lookup;
+
+  g_return_val_if_fail (chunk != NULL, NULL);
+
+  if (!chunk->const_table)
+    chunk->const_table = g_hash_table_new (g_str_hash, g_str_equal);
+
+  lookup = (char*) g_hash_table_lookup (chunk->const_table, (gchar *)string);
+
+  if (!lookup)
+    {
+      lookup = g_string_chunk_insert (fchunk, string);
+      g_hash_table_insert (chunk->const_table, lookup, lookup);
+    }
+
+  return lookup;
+}
+
+/* Strings.
+ */
+static gint
+nearest_pow (gint num)
+{
+  gint n = 1;
+
+  while (n < num)
+    n <<= 1;
+
+  return n;
+}
+
+static void
+g_string_maybe_expand (GRealString* string, gint len)
+{
+  if (string->len + len >= string->alloc)
+    {
+      string->alloc = nearest_pow (string->len + len + 1);
+      string->str = g_realloc (string->str, string->alloc);
+    }
+}
+
+GString*
+g_string_sized_new (guint dfl_size)
+{
+  GRealString *string;
+
+  G_LOCK (string_mem_chunk);
+  if (!string_mem_chunk)
+    string_mem_chunk = g_mem_chunk_new ("string mem chunk",
+					sizeof (GRealString),
+					1024, G_ALLOC_AND_FREE);
+
+  string = g_chunk_new (GRealString, string_mem_chunk);
+  G_UNLOCK (string_mem_chunk);
+
+  string->alloc = 0;
+  string->len   = 0;
+  string->str   = NULL;
+
+  g_string_maybe_expand (string, MAX (dfl_size, 2));
+  string->str[0] = 0;
+
+  return (GString*) string;
+}
+
+GString*
+g_string_new (const gchar *init)
+{
+  GString *string;
+
+  string = g_string_sized_new (2);
+
+  if (init)
+    g_string_append (string, init);
+
+  return string;
+}
+
+void
+g_string_free (GString *string,
+	       gint free_segment)
+{
+  g_return_if_fail (string != NULL);
+
+  if (free_segment)
+    g_free (string->str);
+
+  G_LOCK (string_mem_chunk);
+  g_mem_chunk_free (string_mem_chunk, string);
+  G_UNLOCK (string_mem_chunk);
+}
+
+GString*
+g_string_assign (GString *lval,
+		 const gchar *rval)
+{
+  g_return_val_if_fail (lval != NULL, NULL);
+  g_return_val_if_fail (rval != NULL, NULL);
+  
+  g_string_truncate (lval, 0);
+  g_string_append (lval, rval);
+
+  return lval;
+}
+
+GString*
+g_string_truncate (GString* fstring,
+		   gint len)
+{
+  GRealString *string = (GRealString*)fstring;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_return_val_if_fail (len >= 0, NULL);
+
+  string->len = len;
+
+  string->str[len] = 0;
+
+  return fstring;
+}
+
+GString*
+g_string_append (GString *fstring,
+		 const gchar *val)
+{
+  GRealString *string = (GRealString*)fstring;
+  int len;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_return_val_if_fail (val != NULL, fstring);
+  
+  len = strlen (val);
+  g_string_maybe_expand (string, len);
+
+  strcpy (string->str + string->len, val);
+
+  string->len += len;
+
+  return fstring;
+}
+
+GString*
+g_string_append_c (GString *fstring,
+		   gchar c)
+{
+  GRealString *string = (GRealString*)fstring;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_string_maybe_expand (string, 1);
+
+  string->str[string->len++] = c;
+  string->str[string->len] = 0;
+
+  return fstring;
+}
+
+GString*
+g_string_prepend (GString *fstring,
+		  const gchar *val)
+{
+  GRealString *string = (GRealString*)fstring;
+  gint len;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_return_val_if_fail (val != NULL, fstring);
+
+  len = strlen (val);
+  g_string_maybe_expand (string, len);
+
+  g_memmove (string->str + len, string->str, string->len);
+
+  strncpy (string->str, val, len);
+
+  string->len += len;
+
+  string->str[string->len] = 0;
+
+  return fstring;
+}
+
+GString*
+g_string_prepend_c (GString *fstring,
+		    gchar    c)
+{
+  GRealString *string = (GRealString*)fstring;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_string_maybe_expand (string, 1);
+
+  g_memmove (string->str + 1, string->str, string->len);
+
+  string->str[0] = c;
+
+  string->len += 1;
+
+  string->str[string->len] = 0;
+
+  return fstring;
+}
+
+GString*
+g_string_insert (GString     *fstring,
+		 gint         pos,
+		 const gchar *val)
+{
+  GRealString *string = (GRealString*)fstring;
+  gint len;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_return_val_if_fail (val != NULL, fstring);
+  g_return_val_if_fail (pos >= 0, fstring);
+  g_return_val_if_fail (pos <= string->len, fstring);
+
+  len = strlen (val);
+  g_string_maybe_expand (string, len);
+
+  g_memmove (string->str + pos + len, string->str + pos, string->len - pos);
+
+  strncpy (string->str + pos, val, len);
+
+  string->len += len;
+
+  string->str[string->len] = 0;
+
+  return fstring;
+}
+
+GString *
+g_string_insert_c (GString *fstring,
+		   gint     pos,
+		   gchar    c)
+{
+  GRealString *string = (GRealString*)fstring;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_return_val_if_fail (pos <= string->len, fstring);
+
+  g_string_maybe_expand (string, 1);
+
+  g_memmove (string->str + pos + 1, string->str + pos, string->len - pos);
+
+  string->str[pos] = c;
+
+  string->len += 1;
+
+  string->str[string->len] = 0;
+
+  return fstring;
+}
+
+GString*
+g_string_erase (GString *fstring,
+		gint pos,
+		gint len)
+{
+  GRealString *string = (GRealString*)fstring;
+
+  g_return_val_if_fail (string != NULL, NULL);
+  g_return_val_if_fail (len >= 0, fstring);
+  g_return_val_if_fail (pos >= 0, fstring);
+  g_return_val_if_fail (pos <= string->len, fstring);
+  g_return_val_if_fail (pos + len <= string->len, fstring);
+
+  if (pos + len < string->len)
+    g_memmove (string->str + pos, string->str + pos + len, string->len - (pos + len));
+
+  string->len -= len;
+  
+  string->str[string->len] = 0;
+
+  return fstring;
+}
+
+GString*
+g_string_down (GString *fstring)
+{
+  GRealString *string = (GRealString*)fstring;
+  guchar *s;
+
+  g_return_val_if_fail (string != NULL, NULL);
+
+  s = string->str;
+
+  while (*s)
+    {
+      *s = tolower (*s);
+      s++;
+    }
+
+  return fstring;
+}
+
+GString*
+g_string_up (GString *fstring)
+{
+  GRealString *string = (GRealString*)fstring;
+  guchar *s;
+
+  g_return_val_if_fail (string != NULL, NULL);
+
+  s = string->str;
+
+  while (*s)
+    {
+      *s = toupper (*s);
+      s++;
+    }
+
+  return fstring;
+}
+
+static void
+g_string_sprintfa_int (GString     *string,
+		       const gchar *fmt,
+		       va_list      args)
+{
+  gchar *buffer;
+
+  buffer = g_strdup_vprintf (fmt, args);
+  g_string_append (string, buffer);
+  g_free (buffer);
+}
+
+void
+g_string_sprintf (GString *string,
+		  const gchar *fmt,
+		  ...)
+{
+  va_list args;
+
+  g_string_truncate (string, 0);
+
+  va_start (args, fmt);
+  g_string_sprintfa_int (string, fmt, args);
+  va_end (args);
+}
+
+void
+g_string_sprintfa (GString *string,
+		   const gchar *fmt,
+		   ...)
+{
+  va_list args;
+
+  va_start (args, fmt);
+  g_string_sprintfa_int (string, fmt, args);
+  va_end (args);
+}
diff -urN linux-2.4.1/net/korbit/kglib/gtree.c linux-2.4.1-korbit/net/korbit/kglib/gtree.c
--- linux-2.4.1/net/korbit/kglib/gtree.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/gtree.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,740 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "glib.h"
+
+
+typedef struct _GRealTree  GRealTree;
+typedef struct _GTreeNode  GTreeNode;
+
+struct _GRealTree
+{
+  GTreeNode *root;
+  GCompareFunc key_compare;
+};
+
+struct _GTreeNode
+{
+  gint balance;      /* height (left) - height (right) */
+  GTreeNode *left;   /* left subtree */
+  GTreeNode *right;  /* right subtree */
+  gpointer key;      /* key for this node */
+  gpointer value;    /* value stored at this node */
+};
+
+
+static GTreeNode* g_tree_node_new                   (gpointer        key,
+						     gpointer        value);
+static void       g_tree_node_destroy               (GTreeNode      *node);
+static GTreeNode* g_tree_node_insert                (GTreeNode      *node,
+						     GCompareFunc    compare,
+						     gpointer        key,
+						     gpointer        value,
+						     gint           *inserted);
+static GTreeNode* g_tree_node_remove                (GTreeNode      *node,
+						     GCompareFunc    compare,
+						     gpointer        key);
+static GTreeNode* g_tree_node_balance               (GTreeNode      *node);
+static GTreeNode* g_tree_node_remove_leftmost       (GTreeNode      *node,
+						     GTreeNode     **leftmost);
+static GTreeNode* g_tree_node_restore_left_balance  (GTreeNode      *node,
+						     gint            old_balance);
+static GTreeNode* g_tree_node_restore_right_balance (GTreeNode      *node,
+						     gint            old_balance);
+static gpointer   g_tree_node_lookup                (GTreeNode      *node,
+						     GCompareFunc    compare,
+						     gpointer        key);
+static gint       g_tree_node_count                 (GTreeNode      *node);
+static gint       g_tree_node_pre_order             (GTreeNode      *node,
+						     GTraverseFunc   traverse_func,
+						     gpointer        data);
+static gint       g_tree_node_in_order              (GTreeNode      *node,
+						     GTraverseFunc   traverse_func,
+						     gpointer        data);
+static gint       g_tree_node_post_order            (GTreeNode      *node,
+						     GTraverseFunc   traverse_func,
+						     gpointer        data);
+static gpointer   g_tree_node_search                (GTreeNode      *node,
+						     GSearchFunc     search_func,
+						     gpointer        data);
+static gint       g_tree_node_height                (GTreeNode      *node);
+static GTreeNode* g_tree_node_rotate_left           (GTreeNode      *node);
+static GTreeNode* g_tree_node_rotate_right          (GTreeNode      *node);
+static void       g_tree_node_check                 (GTreeNode      *node);
+
+
+G_LOCK_DEFINE_STATIC (g_tree_global);
+static GMemChunk *node_mem_chunk = NULL;
+static GTreeNode *node_free_list = NULL;
+
+
+static GTreeNode*
+g_tree_node_new (gpointer key,
+		 gpointer value)
+{
+  GTreeNode *node;
+
+  G_LOCK (g_tree_global);
+  if (node_free_list)
+    {
+      node = node_free_list;
+      node_free_list = node->right;
+    }
+  else
+    {
+      if (!node_mem_chunk)
+	node_mem_chunk = g_mem_chunk_new ("GLib GTreeNode mem chunk",
+					  sizeof (GTreeNode),
+					  1024,
+					  G_ALLOC_ONLY);
+
+      node = g_chunk_new (GTreeNode, node_mem_chunk);
+   }
+  G_UNLOCK (g_tree_global);
+
+  node->balance = 0;
+  node->left = NULL;
+  node->right = NULL;
+  node->key = key;
+  node->value = value;
+
+  return node;
+}
+
+static void
+g_tree_node_destroy (GTreeNode *node)
+{
+  if (node)
+    {
+      g_tree_node_destroy (node->right);
+      g_tree_node_destroy (node->left);
+      G_LOCK (g_tree_global);
+      node->right = node_free_list;
+      node_free_list = node;
+      G_UNLOCK (g_tree_global);
+   }
+}
+
+
+GTree*
+g_tree_new (GCompareFunc key_compare_func)
+{
+  GRealTree *rtree;
+
+  g_return_val_if_fail (key_compare_func != NULL, NULL);
+
+  rtree = g_new (GRealTree, 1);
+  rtree->root = NULL;
+  rtree->key_compare = key_compare_func;
+
+  return (GTree*) rtree;
+}
+
+void
+g_tree_destroy (GTree *tree)
+{
+  GRealTree *rtree;
+
+  g_return_if_fail (tree != NULL);
+
+  rtree = (GRealTree*) tree;
+
+  g_tree_node_destroy (rtree->root);
+  g_free (rtree);
+}
+
+void
+g_tree_insert (GTree    *tree,
+	       gpointer  key,
+	       gpointer  value)
+{
+  GRealTree *rtree;
+  gint inserted;
+
+  g_return_if_fail (tree != NULL);
+
+  rtree = (GRealTree*) tree;
+
+  inserted = FALSE;
+  rtree->root = g_tree_node_insert (rtree->root, rtree->key_compare,
+				    key, value, &inserted);
+}
+
+void
+g_tree_remove (GTree    *tree,
+	       gpointer  key)
+{
+  GRealTree *rtree;
+
+  g_return_if_fail (tree != NULL);
+
+  rtree = (GRealTree*) tree;
+
+  rtree->root = g_tree_node_remove (rtree->root, rtree->key_compare, key);
+}
+
+gpointer
+g_tree_lookup (GTree    *tree,
+	       gpointer  key)
+{
+  GRealTree *rtree;
+
+  g_return_val_if_fail (tree != NULL, NULL);
+
+  rtree = (GRealTree*) tree;
+
+  return g_tree_node_lookup (rtree->root, rtree->key_compare, key);
+}
+
+void
+g_tree_traverse (GTree         *tree,
+		 GTraverseFunc  traverse_func,
+		 GTraverseType  traverse_type,
+		 gpointer       data)
+{
+  GRealTree *rtree;
+
+  g_return_if_fail (tree != NULL);
+
+  rtree = (GRealTree*) tree;
+
+  if (!rtree->root)
+    return;
+
+  switch (traverse_type)
+    {
+    case G_PRE_ORDER:
+      g_tree_node_pre_order (rtree->root, traverse_func, data);
+      break;
+
+    case G_IN_ORDER:
+      g_tree_node_in_order (rtree->root, traverse_func, data);
+      break;
+
+    case G_POST_ORDER:
+      g_tree_node_post_order (rtree->root, traverse_func, data);
+      break;
+    
+    case G_LEVEL_ORDER:
+      g_warning ("g_tree_traverse(): traverse type G_LEVEL_ORDER isn't implemented.");
+      break;
+    }
+}
+
+gpointer
+g_tree_search (GTree       *tree,
+	       GSearchFunc  search_func,
+	       gpointer     data)
+{
+  GRealTree *rtree;
+
+  g_return_val_if_fail (tree != NULL, NULL);
+
+  rtree = (GRealTree*) tree;
+
+  if (rtree->root)
+    return g_tree_node_search (rtree->root, search_func, data);
+  else
+    return NULL;
+}
+
+gint
+g_tree_height (GTree *tree)
+{
+  GRealTree *rtree;
+
+  g_return_val_if_fail (tree != NULL, 0);
+
+  rtree = (GRealTree*) tree;
+
+  if (rtree->root)
+    return g_tree_node_height (rtree->root);
+  else
+    return 0;
+}
+
+gint
+g_tree_nnodes (GTree *tree)
+{
+  GRealTree *rtree;
+
+  g_return_val_if_fail (tree != NULL, 0);
+
+  rtree = (GRealTree*) tree;
+
+  if (rtree->root)
+    return g_tree_node_count (rtree->root);
+  else
+    return 0;
+}
+
+static GTreeNode*
+g_tree_node_insert (GTreeNode    *node,
+		    GCompareFunc  compare,
+		    gpointer      key,
+		    gpointer      value,
+		    gint         *inserted)
+{
+  gint old_balance;
+  gint cmp;
+
+  if (!node)
+    {
+      *inserted = TRUE;
+      return g_tree_node_new (key, value);
+    }
+
+  cmp = (* compare) (key, node->key);
+  if (cmp == 0)
+    {
+      *inserted = FALSE;
+      node->value = value;
+      return node;
+    }
+
+  if (cmp < 0)
+    {
+      if (node->left)
+	{
+	  old_balance = node->left->balance;
+	  node->left = g_tree_node_insert (node->left, compare, key, value, inserted);
+
+	  if ((old_balance != node->left->balance) && node->left->balance)
+	    node->balance -= 1;
+	}
+      else
+	{
+	  *inserted = TRUE;
+	  node->left = g_tree_node_new (key, value);
+	  node->balance -= 1;
+	}
+    }
+  else if (cmp > 0)
+    {
+      if (node->right)
+	{
+	  old_balance = node->right->balance;
+	  node->right = g_tree_node_insert (node->right, compare, key, value, inserted);
+
+	  if ((old_balance != node->right->balance) && node->right->balance)
+	    node->balance += 1;
+	}
+      else
+	{
+	  *inserted = TRUE;
+	  node->right = g_tree_node_new (key, value);
+	  node->balance += 1;
+	}
+    }
+
+  if (*inserted)
+    {
+      if ((node->balance < -1) || (node->balance > 1))
+	node = g_tree_node_balance (node);
+    }
+
+  return node;
+}
+
+static GTreeNode*
+g_tree_node_remove (GTreeNode    *node,
+		    GCompareFunc  compare,
+		    gpointer      key)
+{
+  GTreeNode *new_root;
+  gint old_balance;
+  gint cmp;
+
+  if (!node)
+    return NULL;
+
+  cmp = (* compare) (key, node->key);
+  if (cmp == 0)
+    {
+      GTreeNode *garbage;
+
+      garbage = node;
+
+      if (!node->right)
+	{
+	  node = node->left;
+	}
+      else
+	{
+	  old_balance = node->right->balance;
+	  node->right = g_tree_node_remove_leftmost (node->right, &new_root);
+	  new_root->left = node->left;
+	  new_root->right = node->right;
+	  new_root->balance = node->balance;
+	  node = g_tree_node_restore_right_balance (new_root, old_balance);
+	}
+
+      G_LOCK (g_tree_global);
+      garbage->right = node_free_list;
+      node_free_list = garbage;
+      G_UNLOCK (g_tree_global);
+   }
+  else if (cmp < 0)
+    {
+      if (node->left)
+	{
+	  old_balance = node->left->balance;
+	  node->left = g_tree_node_remove (node->left, compare, key);
+	  node = g_tree_node_restore_left_balance (node, old_balance);
+	}
+    }
+  else if (cmp > 0)
+    {
+      if (node->right)
+	{
+	  old_balance = node->right->balance;
+	  node->right = g_tree_node_remove (node->right, compare, key);
+	  node = g_tree_node_restore_right_balance (node, old_balance);
+	}
+    }
+
+  return node;
+}
+
+static GTreeNode*
+g_tree_node_balance (GTreeNode *node)
+{
+  if (node->balance < -1)
+    {
+      if (node->left->balance > 0)
+	node->left = g_tree_node_rotate_left (node->left);
+      node = g_tree_node_rotate_right (node);
+    }
+  else if (node->balance > 1)
+    {
+      if (node->right->balance < 0)
+	node->right = g_tree_node_rotate_right (node->right);
+      node = g_tree_node_rotate_left (node);
+    }
+
+  return node;
+}
+
+static GTreeNode*
+g_tree_node_remove_leftmost (GTreeNode  *node,
+			     GTreeNode **leftmost)
+{
+  gint old_balance;
+
+  if (!node->left)
+    {
+      *leftmost = node;
+      return node->right;
+    }
+
+  old_balance = node->left->balance;
+  node->left = g_tree_node_remove_leftmost (node->left, leftmost);
+  return g_tree_node_restore_left_balance (node, old_balance);
+}
+
+static GTreeNode*
+g_tree_node_restore_left_balance (GTreeNode *node,
+				  gint       old_balance)
+{
+  if (!node->left)
+    node->balance += 1;
+  else if ((node->left->balance != old_balance) &&
+	   (node->left->balance == 0))
+    node->balance += 1;
+
+  if (node->balance > 1)
+    return g_tree_node_balance (node);
+  return node;
+}
+
+static GTreeNode*
+g_tree_node_restore_right_balance (GTreeNode *node,
+				   gint       old_balance)
+{
+  if (!node->right)
+    node->balance -= 1;
+  else if ((node->right->balance != old_balance) &&
+	   (node->right->balance == 0))
+    node->balance -= 1;
+
+  if (node->balance < -1)
+    return g_tree_node_balance (node);
+  return node;
+}
+
+static gpointer
+g_tree_node_lookup (GTreeNode    *node,
+		    GCompareFunc  compare,
+		    gpointer      key)
+{
+  gint cmp;
+
+  if (!node)
+    return NULL;
+
+  cmp = (* compare) (key, node->key);
+  if (cmp == 0)
+    return node->value;
+
+  if (cmp < 0)
+    {
+      if (node->left)
+	return g_tree_node_lookup (node->left, compare, key);
+    }
+  else if (cmp > 0)
+    {
+      if (node->right)
+	return g_tree_node_lookup (node->right, compare, key);
+    }
+
+  return NULL;
+}
+
+static gint
+g_tree_node_count (GTreeNode *node)
+{
+  gint count;
+
+  count = 1;
+  if (node->left)
+    count += g_tree_node_count (node->left);
+  if (node->right)
+    count += g_tree_node_count (node->right);
+
+  return count;
+}
+
+static gint
+g_tree_node_pre_order (GTreeNode     *node,
+		       GTraverseFunc  traverse_func,
+		       gpointer       data)
+{
+  if ((*traverse_func) (node->key, node->value, data))
+    return TRUE;
+  if (node->left)
+    {
+      if (g_tree_node_pre_order (node->left, traverse_func, data))
+	return TRUE;
+    }
+  if (node->right)
+    {
+      if (g_tree_node_pre_order (node->right, traverse_func, data))
+	return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gint
+g_tree_node_in_order (GTreeNode     *node,
+		      GTraverseFunc  traverse_func,
+		      gpointer       data)
+{
+  if (node->left)
+    {
+      if (g_tree_node_in_order (node->left, traverse_func, data))
+	return TRUE;
+    }
+  if ((*traverse_func) (node->key, node->value, data))
+    return TRUE;
+  if (node->right)
+    {
+      if (g_tree_node_in_order (node->right, traverse_func, data))
+	return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gint
+g_tree_node_post_order (GTreeNode     *node,
+			GTraverseFunc  traverse_func,
+			gpointer       data)
+{
+  if (node->left)
+    {
+      if (g_tree_node_post_order (node->left, traverse_func, data))
+	return TRUE;
+    }
+  if (node->right)
+    {
+      if (g_tree_node_post_order (node->right, traverse_func, data))
+	return TRUE;
+    }
+  if ((*traverse_func) (node->key, node->value, data))
+    return TRUE;
+
+  return FALSE;
+}
+
+static gpointer
+g_tree_node_search (GTreeNode   *node,
+		    GSearchFunc  search_func,
+		    gpointer     data)
+{
+  gint dir;
+
+  if (!node)
+    return NULL;
+
+  do {
+    dir = (* search_func) (node->key, data);
+    if (dir == 0)
+      return node->value;
+
+    if (dir < 0)
+      node = node->left;
+    else if (dir > 0)
+      node = node->right;
+  } while (node && (dir != 0));
+
+  return NULL;
+}
+
+static gint
+g_tree_node_height (GTreeNode *node)
+{
+  gint left_height;
+  gint right_height;
+
+  if (node)
+    {
+      left_height = 0;
+      right_height = 0;
+
+      if (node->left)
+	left_height = g_tree_node_height (node->left);
+
+      if (node->right)
+	right_height = g_tree_node_height (node->right);
+
+      return MAX (left_height, right_height) + 1;
+    }
+
+  return 0;
+}
+
+static GTreeNode*
+g_tree_node_rotate_left (GTreeNode *node)
+{
+  GTreeNode *left;
+  GTreeNode *right;
+  gint a_bal;
+  gint b_bal;
+
+  left = node->left;
+  right = node->right;
+
+  node->right = right->left;
+  right->left = node;
+
+  a_bal = node->balance;
+  b_bal = right->balance;
+
+  if (b_bal <= 0)
+    {
+      if (a_bal >= 1)
+	right->balance = b_bal - 1;
+      else
+	right->balance = a_bal + b_bal - 2;
+      node->balance = a_bal - 1;
+    }
+  else
+    {
+      if (a_bal <= b_bal)
+	right->balance = a_bal - 2;
+      else
+	right->balance = b_bal - 1;
+      node->balance = a_bal - b_bal - 1;
+    }
+
+  return right;
+}
+
+static GTreeNode*
+g_tree_node_rotate_right (GTreeNode *node)
+{
+  GTreeNode *left;
+  gint a_bal;
+  gint b_bal;
+
+  left = node->left;
+
+  node->left = left->right;
+  left->right = node;
+
+  a_bal = node->balance;
+  b_bal = left->balance;
+
+  if (b_bal <= 0)
+    {
+      if (b_bal > a_bal)
+	left->balance = b_bal + 1;
+      else
+	left->balance = a_bal + 2;
+      node->balance = a_bal - b_bal + 1;
+    }
+  else
+    {
+      if (a_bal <= -1)
+	left->balance = b_bal + 1;
+      else
+	left->balance = a_bal + b_bal + 2;
+      node->balance = a_bal + 1;
+    }
+
+  return left;
+}
+
+static void
+g_tree_node_check (GTreeNode *node)
+{
+  gint left_height;
+  gint right_height;
+  gint balance;
+  
+  if (node)
+    {
+      left_height = 0;
+      right_height = 0;
+      
+      if (node->left)
+	left_height = g_tree_node_height (node->left);
+      if (node->right)
+	right_height = g_tree_node_height (node->right);
+      
+      balance = right_height - left_height;
+      if (balance != node->balance)
+	g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+	       "g_tree_node_check: failed: %d ( %d )\n",
+	       balance, node->balance);
+      
+      if (node->left)
+	g_tree_node_check (node->left);
+      if (node->right)
+	g_tree_node_check (node->right);
+    }
+}
diff -urN linux-2.4.1/net/korbit/kglib/gutils.c linux-2.4.1-korbit/net/korbit/kglib/gutils.c
--- linux-2.4.1/net/korbit/kglib/gutils.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/gutils.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1,915 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1998  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#define G_INLINE_FUNC extern
+#define G_CAN_INLINE 1
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+#include <sys/types.h>
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+#ifdef NATIVE_WIN32
+#  define STRICT			/* Strict typing, please */
+#  include <windows.h>
+#  include <direct.h>
+#  include <errno.h>
+#  include <ctype.h>
+#  ifdef _MSC_VER
+#    include <io.h>
+#  endif /* _MSC_VER */
+#endif /* NATIVE_WIN32 */
+
+/* implement Glib's inline functions
+ */
+#include "glib.h"
+
+#ifdef	MAXPATHLEN
+#define	G_PATH_LENGTH	(MAXPATHLEN + 1)
+#elif	defined (PATH_MAX)
+#define	G_PATH_LENGTH	(PATH_MAX + 1)
+#else	/* !MAXPATHLEN */
+#define G_PATH_LENGTH   (2048 + 1)
+#endif	/* !MAXPATHLEN && !PATH_MAX */
+
+const guint glib_major_version = 1;
+const guint glib_minor_version = 2;
+const guint glib_micro_version = 8;
+const guint glib_interface_age = 8;
+const guint glib_binary_age = 8;
+
+#if defined (NATIVE_WIN32) && defined (__LCC__)
+int __stdcall 
+LibMain (void         *hinstDll,
+	 unsigned long dwReason,
+	 void         *reserved)
+{
+  return 1;
+}
+#endif /* NATIVE_WIN32 && __LCC__ */
+
+void
+g_atexit (GVoidFunc func)
+{
+  gint result;
+  gchar *error = NULL;
+
+  /* keep this in sync with glib.h */
+
+#ifdef	G_NATIVE_ATEXIT
+  result = ATEXIT (func);
+  if (result)
+    error = g_strerror (errno);
+#elif defined (HAVE_ATEXIT)
+#  ifdef NeXT /* @#%@! NeXTStep */
+  result = !atexit ((void (*)(void)) func);
+  if (result)
+    error = g_strerror (errno);
+#  else
+  result = atexit ((void (*)(void)) func);
+  if (result)
+    error = g_strerror (errno);
+#  endif /* NeXT */
+#elif defined (HAVE_ON_EXIT)
+  result = on_exit ((void (*)(int, void *)) func, NULL);
+  if (result)
+    error = g_strerror (errno);
+#else
+  result = 0;
+  error = "no implementation";
+#endif /* G_NATIVE_ATEXIT */
+
+  if (error)
+    g_error ("Could not register atexit() function: %s", error);
+}
+
+gint
+g_snprintf (gchar	*str,
+	    gulong	 n,
+	    gchar const *fmt,
+	    ...)
+{
+#ifdef	HAVE_VSNPRINTF
+  va_list args;
+  gint retval;
+  
+  g_return_val_if_fail (str != NULL, 0);
+  g_return_val_if_fail (n > 0, 0);
+  g_return_val_if_fail (fmt != NULL, 0);
+
+  va_start (args, fmt);
+  retval = vsnprintf (str, n, fmt, args);
+  va_end (args);
+
+  if (retval < 0)
+    {
+      str[n-1] = '\0';
+      retval = strlen (str);
+    }
+
+  return retval;
+#else	/* !HAVE_VSNPRINTF */
+  gchar *printed;
+  va_list args;
+  
+  g_return_val_if_fail (str != NULL, 0);
+  g_return_val_if_fail (n > 0, 0);
+  g_return_val_if_fail (fmt != NULL, 0);
+
+  va_start (args, fmt);
+  printed = g_strdup_vprintf (fmt, args);
+  va_end (args);
+  
+  strncpy (str, printed, n);
+  str[n-1] = '\0';
+
+  g_free (printed);
+  
+  return strlen (str);
+#endif	/* !HAVE_VSNPRINTF */
+}
+
+gint
+g_vsnprintf (gchar	 *str,
+	     gulong	  n,
+	     gchar const *fmt,
+	     va_list      args)
+{
+#ifdef	HAVE_VSNPRINTF
+  gint retval;
+
+  g_return_val_if_fail (str != NULL, 0);
+  g_return_val_if_fail (n > 0, 0);
+  g_return_val_if_fail (fmt != NULL, 0);
+  
+  retval = vsnprintf (str, n, fmt, args);
+  
+  if (retval < 0)
+    {
+      str[n-1] = '\0';
+      retval = strlen (str);
+    }
+
+  return retval;
+#else	/* !HAVE_VSNPRINTF */
+  gchar *printed;
+  
+  g_return_val_if_fail (str != NULL, 0);
+  g_return_val_if_fail (n > 0, 0);
+  g_return_val_if_fail (fmt != NULL, 0);
+
+  printed = g_strdup_vprintf (fmt, args);
+  strncpy (str, printed, n);
+  str[n-1] = '\0';
+
+  g_free (printed);
+  
+  return strlen (str);
+#endif /* !HAVE_VSNPRINTF */
+}
+
+guint	     
+g_parse_debug_string  (const gchar *string, 
+		       GDebugKey   *keys, 
+		       guint	    nkeys)
+{
+  guint i;
+  guint result = 0;
+  
+  g_return_val_if_fail (string != NULL, 0);
+  
+  if (!g_strcasecmp (string, "all"))
+    {
+      for (i=0; i<nkeys; i++)
+	result |= keys[i].value;
+    }
+  else
+    {
+      gchar *str = g_strdup (string);
+      gchar *p = str;
+      gchar *q;
+      gboolean done = FALSE;
+      
+      while (*p && !done)
+	{
+	  q = strchr (p, ':');
+	  if (!q)
+	    {
+	      q = p + strlen(p);
+	      done = TRUE;
+	    }
+	  
+	  *q = 0;
+	  
+	  for (i=0; i<nkeys; i++)
+	    if (!g_strcasecmp(keys[i].key, p))
+	      result |= keys[i].value;
+	  
+	  p = q+1;
+	}
+      
+      g_free (str);
+    }
+  
+  return result;
+}
+
+gchar*
+g_basename (const gchar	   *file_name)
+{
+  register gchar *base;
+  
+  g_return_val_if_fail (file_name != NULL, NULL);
+  
+  base = strrchr (file_name, G_DIR_SEPARATOR);
+  if (base)
+    return base + 1;
+
+#ifdef NATIVE_WIN32
+  if (isalpha (file_name[0]) && file_name[1] == ':')
+    return (gchar*) file_name + 2;
+#endif /* NATIVE_WIN32 */
+  
+  return (gchar*) file_name;
+}
+
+gboolean
+g_path_is_absolute (const gchar *file_name)
+{
+  g_return_val_if_fail (file_name != NULL, FALSE);
+  
+  if (file_name[0] == G_DIR_SEPARATOR)
+    return TRUE;
+
+#ifdef NATIVE_WIN32
+  if (isalpha (file_name[0]) && file_name[1] == ':' && file_name[2] == G_DIR_SEPARATOR)
+    return TRUE;
+#endif
+
+  return FALSE;
+}
+
+gchar*
+g_path_skip_root (gchar *file_name)
+{
+  g_return_val_if_fail (file_name != NULL, NULL);
+  
+  if (file_name[0] == G_DIR_SEPARATOR)
+    return file_name + 1;
+
+#ifdef NATIVE_WIN32
+  if (isalpha (file_name[0]) && file_name[1] == ':' && file_name[2] == G_DIR_SEPARATOR)
+    return file_name + 3;
+#endif
+
+  return NULL;
+}
+
+gchar*
+g_dirname (const gchar	   *file_name)
+{
+  register gchar *base;
+  register guint len;
+  
+  g_return_val_if_fail (file_name != NULL, NULL);
+  
+  base = strrchr (file_name, G_DIR_SEPARATOR);
+  if (!base)
+    return g_strdup (".");
+  while (base > file_name && *base == G_DIR_SEPARATOR)
+    base--;
+  len = (guint) 1 + base - file_name;
+  
+  base = g_new (gchar, len + 1);
+  g_memmove (base, file_name, len);
+  base[len] = 0;
+  
+  return base;
+}
+
+#ifndef __KORBIT__
+gchar*
+g_get_current_dir (void)
+{
+  gchar *buffer;
+  gchar *dir;
+
+  buffer = g_new (gchar, G_PATH_LENGTH);
+  *buffer = 0;
+  
+  /* We don't use getcwd(3) on SUNOS, because, it does a popen("pwd")
+   * and, if that wasn't bad enough, hangs in doing so.
+   */
+#if	defined (sun) && !defined (__SVR4)
+  dir = getwd (buffer);
+#else	/* !sun */
+  dir = getcwd (buffer, G_PATH_LENGTH - 1);
+#endif	/* !sun */
+  
+  if (!dir || !*buffer)
+    {
+      /* hm, should we g_error() out here?
+       * this can happen if e.g. "./" has mode \0000
+       */
+      buffer[0] = G_DIR_SEPARATOR;
+      buffer[1] = 0;
+    }
+
+  dir = g_strdup (buffer);
+  g_free (buffer);
+  
+  return dir;
+}
+#endif /* !__KORBIT__ */
+
+gchar*
+g_getenv (const gchar *variable)
+{
+#ifndef NATIVE_WIN32
+  g_return_val_if_fail (variable != NULL, NULL);
+
+  return getenv (variable);
+#else
+  gchar *v;
+  guint k;
+  static gchar *p = NULL;
+  static gint l;
+  gchar dummy[2];
+
+  g_return_val_if_fail (variable != NULL, NULL);
+  
+  v = getenv (variable);
+  if (!v)
+    return NULL;
+  
+  /* On Windows NT, it is relatively typical that environment variables
+   * contain references to other environment variables. Handle that by
+   * calling ExpandEnvironmentStrings.
+   */
+
+  /* First check how much space we need */
+  k = ExpandEnvironmentStrings (v, dummy, 2);
+  /* Then allocate that much, and actualy do the expansion */
+  if (p == NULL)
+    {
+      p = g_malloc (k);
+      l = k;
+    }
+  else if (k > l)
+    {
+      p = g_realloc (p, k);
+      l = k;
+    }
+  ExpandEnvironmentStrings (v, p, k);
+  return p;
+#endif
+}
+
+
+G_LOCK_DEFINE_STATIC (g_utils_global);
+
+static	gchar	*g_tmp_dir = NULL;
+static	gchar	*g_user_name = NULL;
+static	gchar	*g_real_name = NULL;
+static	gchar	*g_home_dir = NULL;
+
+/* HOLDS: g_utils_global_lock */
+static void
+g_get_any_init (void)
+{
+  if (!g_tmp_dir)
+    {
+      g_tmp_dir = g_strdup (g_getenv ("TMPDIR"));
+      if (!g_tmp_dir)
+	g_tmp_dir = g_strdup (g_getenv ("TMP"));
+      if (!g_tmp_dir)
+	g_tmp_dir = g_strdup (g_getenv ("TEMP"));
+      
+#ifdef P_tmpdir
+      if (!g_tmp_dir)
+	{
+	  int k;
+	  g_tmp_dir = g_strdup (P_tmpdir);
+	  k = strlen (g_tmp_dir);
+	  if (g_tmp_dir[k-1] == G_DIR_SEPARATOR)
+	    g_tmp_dir[k-1] = '\0';
+	}
+#endif
+      
+      if (!g_tmp_dir)
+	{
+#ifndef NATIVE_WIN32
+	  g_tmp_dir = g_strdup ("/tmp");
+#else /* NATIVE_WIN32 */
+	  g_tmp_dir = g_strdup ("C:\\");
+#endif /* NATIVE_WIN32 */
+	}
+      
+      if (!g_home_dir)
+	g_home_dir = g_strdup (g_getenv ("HOME"));
+      
+#ifdef NATIVE_WIN32
+      if (!g_home_dir)
+	{
+	  /* The official way to specify a home directory on NT is
+	   * the HOMEDRIVE and HOMEPATH environment variables.
+	   *
+	   * This is inside #ifdef NATIVE_WIN32 because with the cygwin dll,
+	   * HOME should be a POSIX style pathname.
+	   */
+	  
+	  if (getenv ("HOMEDRIVE") != NULL && getenv ("HOMEPATH") != NULL)
+	    {
+	      gchar *homedrive, *homepath;
+	      
+	      homedrive = g_strdup (g_getenv ("HOMEDRIVE"));
+	      homepath = g_strdup (g_getenv ("HOMEPATH"));
+	      
+	      g_home_dir = g_strconcat (homedrive, homepath, NULL);
+	      g_free (homedrive);
+	      g_free (homepath);
+	    }
+	}
+#endif /* !NATIVE_WIN32 */
+      
+#ifdef HAVE_PWD_H
+      {
+	struct passwd *pw = NULL;
+	gpointer buffer = NULL;
+	
+#  ifdef HAVE_GETPWUID_R
+        struct passwd pwd;
+        guint bufsize = 64;
+        gint error;
+	
+        do
+          {
+            g_free (buffer);
+            buffer = g_malloc (bufsize);
+	    errno = 0;
+	    
+#    ifdef HAVE_GETPWUID_R_POSIX
+	    error = getpwuid_r (getuid (), &pwd, buffer, bufsize, &pw);
+            error = error < 0 ? errno : error;
+#    else /* !HAVE_GETPWUID_R_POSIX */
+#      ifdef _AIX
+	    error = getpwuid_r (getuid (), &pwd, buffer, bufsize);
+	    pw = error == 0 ? &pwd : NULL;
+#      else /* !_AIX */
+            pw = getpwuid_r (getuid (), &pwd, buffer, bufsize);
+            error = pw ? 0 : errno;
+#      endif /* !_AIX */            
+#    endif /* !HAVE_GETPWUID_R_POSIX */
+	    
+	    if (!pw)
+	      {
+		/* we bail out prematurely if the user id can't be found
+		 * (should be pretty rare case actually), or if the buffer
+		 * should be sufficiently big and lookups are still not
+		 * successfull.
+		 */
+		if (error == 0 || error == ENOENT)
+		  {
+		    g_warning ("getpwuid_r(): failed due to: No such user %d.",
+			       getuid ());
+		    break;
+		  }
+		if (bufsize > 32 * 1024)
+		  {
+		    g_warning ("getpwuid_r(): failed due to: %s.",
+			       g_strerror (error));
+		    break;
+		  }
+		
+		bufsize *= 2;
+	      }
+	  }
+	while (!pw);
+#  endif /* !HAVE_GETPWUID_R */
+	
+	if (!pw)
+	  {
+	    setpwent ();
+	    pw = getpwuid (getuid ());
+	    endpwent ();
+	  }
+	if (pw)
+	  {
+	    g_user_name = g_strdup (pw->pw_name);
+	    g_real_name = g_strdup (pw->pw_gecos);
+	    if (!g_home_dir)
+	      g_home_dir = g_strdup (pw->pw_dir);
+	  }
+	g_free (buffer);
+      }
+      
+#else /* !HAVE_PWD_H */
+      
+#  ifdef NATIVE_WIN32
+      {
+	guint len = 17;
+	gchar buffer[17];
+	
+	if (GetUserName (buffer, &len))
+	  {
+	    g_user_name = g_strdup (buffer);
+	    g_real_name = g_strdup (buffer);
+	  }
+      }
+#  endif /* NATIVE_WIN32 */
+      
+#endif /* !HAVE_PWD_H */
+      
+      if (!g_user_name)
+	g_user_name = g_strdup ("somebody");
+      if (!g_real_name)
+	g_real_name = g_strdup ("Unknown");
+      else
+	{
+	  gchar *p;
+
+	  for (p = g_real_name; *p; p++)
+	    if (*p == ',')
+	      {
+		*p = 0;
+		p = g_strdup (g_real_name);
+		g_free (g_real_name);
+		g_real_name = p;
+		break;
+	      }
+	}
+    }
+}
+
+gchar*
+g_get_user_name (void)
+{
+  G_LOCK (g_utils_global);
+  if (!g_tmp_dir)
+    g_get_any_init ();
+  G_UNLOCK (g_utils_global);
+  
+  return g_user_name;
+}
+
+gchar*
+g_get_real_name (void)
+{
+  G_LOCK (g_utils_global);
+  if (!g_tmp_dir)
+    g_get_any_init ();
+  G_UNLOCK (g_utils_global);
+ 
+  return g_real_name;
+}
+
+/* Return the home directory of the user. If there is a HOME
+ * environment variable, its value is returned, otherwise use some
+ * system-dependent way of finding it out. If no home directory can be
+ * deduced, return NULL.
+ */
+
+gchar*
+g_get_home_dir (void)
+{
+  G_LOCK (g_utils_global);
+  if (!g_tmp_dir)
+    g_get_any_init ();
+  G_UNLOCK (g_utils_global);
+  
+  return g_home_dir;
+}
+
+/* Return a directory to be used to store temporary files. This is the
+ * value of the TMPDIR, TMP or TEMP environment variables (they are
+ * checked in that order). If none of those exist, use P_tmpdir from
+ * stdio.h.  If that isn't defined, return "/tmp" on POSIXly systems,
+ * and C:\ on Windows.
+ */
+
+gchar*
+g_get_tmp_dir (void)
+{
+  G_LOCK (g_utils_global);
+  if (!g_tmp_dir)
+    g_get_any_init ();
+  G_UNLOCK (g_utils_global);
+  
+  return g_tmp_dir;
+}
+
+static gchar *g_prgname = NULL;
+
+gchar*
+g_get_prgname (void)
+{
+  gchar* retval;
+
+  G_LOCK (g_utils_global);
+  retval = g_prgname;
+  G_UNLOCK (g_utils_global);
+
+  return retval;
+}
+
+void
+g_set_prgname (const gchar *prgname)
+{
+  gchar *c;
+    
+  G_LOCK (g_utils_global);
+  c = g_prgname;
+  g_prgname = g_strdup (prgname);
+  g_free (c);
+  G_UNLOCK (g_utils_global);
+}
+
+guint
+g_direct_hash (gconstpointer v)
+{
+  return GPOINTER_TO_UINT (v);
+}
+
+gint
+g_direct_equal (gconstpointer v1,
+		gconstpointer v2)
+{
+  return v1 == v2;
+}
+
+gint
+g_int_equal (gconstpointer v1,
+	     gconstpointer v2)
+{
+  return *((const gint*) v1) == *((const gint*) v2);
+}
+
+guint
+g_int_hash (gconstpointer v)
+{
+  return *(const gint*) v;
+}
+
+#if 0 /* Old IO Channels */
+
+GIOChannel*
+g_iochannel_new (gint fd)
+{
+  GIOChannel *channel = g_new (GIOChannel, 1);
+
+  channel->fd = fd;
+
+#ifdef NATIVE_WIN32
+  channel->peer = 0;
+  channel->peer_fd = 0;
+  channel->offset = 0;
+  channel->need_wakeups = 0;
+#endif /* NATIVE_WIN32 */
+
+  return channel;
+}
+
+void
+g_iochannel_free (GIOChannel *channel)
+{
+  g_return_if_fail (channel != NULL);
+
+  g_free (channel);
+}
+
+void
+g_iochannel_close_and_free (GIOChannel *channel)
+{
+  g_return_if_fail (channel != NULL);
+
+  close (channel->fd);
+
+  g_iochannel_free (channel);
+}
+
+#undef g_iochannel_wakeup_peer
+
+void
+g_iochannel_wakeup_peer (GIOChannel *channel)
+{
+#ifdef NATIVE_WIN32
+  static guint message = 0;
+#endif
+
+  g_return_if_fail (channel != NULL);
+
+#ifdef NATIVE_WIN32
+  if (message == 0)
+    message = RegisterWindowMessage ("gdk-pipe-readable");
+
+#  if 0
+  g_print ("g_iochannel_wakeup_peer: calling PostThreadMessage (%#x, %d, %d, %d)\n",
+	   channel->peer, message, channel->peer_fd, channel->offset);
+#  endif
+  PostThreadMessage (channel->peer, message,
+		     channel->peer_fd, channel->offset);
+#endif /* NATIVE_WIN32 */
+}
+
+#endif /* Old IO Channels */
+
+#ifdef NATIVE_WIN32
+#ifdef _MSC_VER
+
+int
+gwin_ftruncate (gint  fd,
+		guint size)
+{
+  HANDLE hfile;
+  guint curpos;
+
+  g_return_val_if_fail (fd >= 0, -1);
+  
+  hfile = (HANDLE) _get_osfhandle (fd);
+  curpos = SetFilePointer (hfile, 0, NULL, FILE_CURRENT);
+  if (curpos == 0xFFFFFFFF
+      || SetFilePointer (hfile, size, NULL, FILE_BEGIN) == 0xFFFFFFFF
+      || !SetEndOfFile (hfile))
+    {
+      gint error = GetLastError ();
+
+      switch (error)
+	{
+	case ERROR_INVALID_HANDLE:
+	  errno = EBADF;
+	  break;
+	default:
+	  errno = EIO;
+	  break;
+	}
+
+      return -1;
+    }
+
+  return 0;
+}
+
+DIR*
+gwin_opendir (const char *dirname)
+{
+  DIR *result;
+  gchar *mask;
+  guint k;
+
+  g_return_val_if_fail (dirname != NULL, NULL);
+
+  result = g_new0 (DIR, 1);
+  result->find_file_data = g_new0 (WIN32_FIND_DATA, 1);
+  result->dir_name = g_strdup (dirname);
+  
+  k = strlen (result->dir_name);
+  if (k && result->dir_name[k - 1] == '\\')
+    {
+      result->dir_name[k - 1] = '\0';
+      k--;
+    }
+  mask = g_strdup_printf ("%s\\*", result->dir_name);
+
+  result->find_file_handle = (guint) FindFirstFile (mask,
+					     (LPWIN32_FIND_DATA) result->find_file_data);
+  g_free (mask);
+
+  if (result->find_file_handle == (guint) INVALID_HANDLE_VALUE)
+    {
+      int error = GetLastError ();
+
+      g_free (result->dir_name);
+      g_free (result->find_file_data);
+      g_free (result);
+      switch (error)
+	{
+	default:
+	  errno = EIO;
+	  return NULL;
+	}
+    }
+  result->just_opened = TRUE;
+
+  return result;
+}
+
+struct dirent*
+gwin_readdir (DIR *dir)
+{
+  static struct dirent result;
+
+  g_return_val_if_fail (dir != NULL, NULL);
+
+  if (dir->just_opened)
+    dir->just_opened = FALSE;
+  else
+    {
+      if (!FindNextFile ((HANDLE) dir->find_file_handle,
+			 (LPWIN32_FIND_DATA) dir->find_file_data))
+	{
+	  int error = GetLastError ();
+
+	  switch (error)
+	    {
+	    case ERROR_NO_MORE_FILES:
+	      return NULL;
+	    default:
+	      errno = EIO;
+	      return NULL;
+	    }
+	}
+    }
+  strcpy (result.d_name, g_basename (((LPWIN32_FIND_DATA) dir->find_file_data)->cFileName));
+      
+  return &result;
+}
+
+void
+gwin_rewinddir (DIR *dir)
+{
+  gchar *mask;
+
+  g_return_if_fail (dir != NULL);
+
+  if (!FindClose ((HANDLE) dir->find_file_handle))
+    g_warning ("gwin_rewinddir(): FindClose() failed\n");
+
+  mask = g_strdup_printf ("%s\\*", dir->dir_name);
+  dir->find_file_handle = (guint) FindFirstFile (mask,
+					  (LPWIN32_FIND_DATA) dir->find_file_data);
+  g_free (mask);
+
+  if (dir->find_file_handle == (guint) INVALID_HANDLE_VALUE)
+    {
+      int error = GetLastError ();
+
+      switch (error)
+	{
+	default:
+	  errno = EIO;
+	  return;
+	}
+    }
+  dir->just_opened = TRUE;
+}  
+
+gint
+gwin_closedir (DIR *dir)
+{
+  g_return_val_if_fail (dir != NULL, -1);
+
+  if (!FindClose ((HANDLE) dir->find_file_handle))
+    {
+      int error = GetLastError ();
+
+      switch (error)
+	{
+	default:
+	  errno = EIO; return -1;
+	}
+    }
+
+  g_free (dir->dir_name);
+  g_free (dir->find_file_data);
+  g_free (dir);
+
+  return 0;
+}
+
+#endif /* _MSC_VER */
+
+#endif /* NATIVE_WIN32 */
diff -urN linux-2.4.1/net/korbit/kglib/korbit_errno.c linux-2.4.1-korbit/net/korbit/kglib/korbit_errno.c
--- linux-2.4.1/net/korbit/kglib/korbit_errno.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/kglib/korbit_errno.c	Thu Feb  1 11:46:57 2001
@@ -0,0 +1 @@
+int korbit_errno;
diff -urN linux-2.4.1/net/korbit/korbit.h linux-2.4.1-korbit/net/korbit/korbit.h
--- linux-2.4.1/net/korbit/korbit.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/korbit.h	Thu Feb  1 11:46:49 2001
@@ -0,0 +1,53 @@
+
+#ifndef KORBIT_H
+#define KORBIT_H
+
+#ifdef __KERNEL__
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#endif
+
+#include "stdlib.h"
+
+#ifdef __KERNEL__
+static int korbit_get_ior_func(char *buffer, char **start, off_t offset,
+			       int length, int *eof, void *data) {
+  int Len = strlen((char*)data);
+  memcpy(buffer, data, Len);  // Data is the ior...
+  buffer[Len++] = '\n';       // Add a newline to make fredrik happy
+  buffer[Len] = 0;            // Null terminate the buffer...
+  *start = buffer + offset;
+  *eof = 1;
+
+  Len -= offset;
+  if (Len > length)
+    Len = length;
+  if (Len < 0)
+    Len = 0;
+
+  return Len;
+}
+
+#endif
+
+
+static inline void korbit_register_ior(const char *name, CORBA_Object obj, 
+				       CORBA_ORB orb, CORBA_Environment *ev) {
+  char *retval = CORBA_ORB_object_to_string(orb, obj, ev);
+#if defined(__KERNEL__) && defined(CONFIG_PROC_FS)
+  char *procdirname = malloc(strlen(name)+7); // 7 = len("corba/\0")
+  strcpy(procdirname, "corba/");
+  strcpy(procdirname+6, name);
+
+  create_proc_read_entry(procdirname, 0, 0, korbit_get_ior_func, retval);
+
+  free(procdirname);
+  // Don't free the ior in the /proc handling case...
+#else
+  // No procfs support, just print to console... :(
+  g_print("%s IOR:\n%s\n", name, retval);
+  CORBA_free(retval);
+#endif
+}
+#endif
diff -urN linux-2.4.1/net/korbit/modules/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CVS/Entries	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,5 @@
+/Config.in/1.8/Thu Feb  1 09:46:58 2001//
+/Makefile/1.8/Thu Feb  1 09:46:58 2001//
+/Makefile.module/1.2/Thu Feb  1 09:46:58 2001//
+/README/1.1/Thu Feb  1 09:46:58 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/modules/CVS/Entries.Log
--- linux-2.4.1/net/korbit/modules/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CVS/Entries.Log	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,6 @@
+A D/CharDev////
+A D/Console////
+A D/CorbaFS////
+A D/Echo////
+A D/FileServer////
+A D/UserFS////
diff -urN linux-2.4.1/net/korbit/modules/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CVS/Repository	Thu Feb  1 11:46:57 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules
diff -urN linux-2.4.1/net/korbit/modules/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CVS/Root
--- linux-2.4.1/net/korbit/modules/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CVS/Root	Thu Feb  1 11:46:57 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CharDev/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CharDev/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Entries	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,4 @@
+/Makefile/1.3/Thu Feb  1 09:46:58 2001//
+/README/1.1/Thu Feb  1 09:46:58 2001//
+/chardev.idl/1.1/Thu Feb  1 09:46:58 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CharDev/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Entries.Log
--- linux-2.4.1/net/korbit/modules/CharDev/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Entries.Log	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,3 @@
+A D/kernel////
+A D/kernel-perl////
+A D/userspace////
diff -urN linux-2.4.1/net/korbit/modules/CharDev/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CharDev/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Repository	Thu Feb  1 11:46:58 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CharDev
diff -urN linux-2.4.1/net/korbit/modules/CharDev/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Root
--- linux-2.4.1/net/korbit/modules/CharDev/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/CVS/Root	Thu Feb  1 11:46:58 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CharDev/Makefile linux-2.4.1-korbit/net/korbit/modules/CharDev/Makefile
--- linux-2.4.1/net/korbit/modules/CharDev/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/Makefile	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,11 @@
+#
+# Makefile for KORBit - CharDev
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+
+subdir-$(CONFIG_CORBA_CHARDEV) := kernel
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/modules/CharDev/README linux-2.4.1-korbit/net/korbit/modules/CharDev/README
--- linux-2.4.1/net/korbit/modules/CharDev/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/README	Thu Feb  1 11:46:58 2001
@@ -0,0 +1 @@
+This module is used to implement a character device with kORBit.
diff -urN linux-2.4.1/net/korbit/modules/CharDev/chardev.idl linux-2.4.1-korbit/net/korbit/modules/CharDev/chardev.idl
--- linux-2.4.1/net/korbit/modules/CharDev/chardev.idl	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/chardev.idl	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,5 @@
+typedef sequence<octet> Buffer;
+
+interface CharDev {
+    long read(out Buffer buffer, in long size);
+};
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CharDev/kernel/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/CVS/Entries	Thu Feb  1 11:46:59 2001
@@ -0,0 +1,4 @@
+/Makefile/1.2/Thu Feb  1 09:46:59 2001//
+/README/1.2/Thu Feb  1 09:46:59 2001//
+/chardev-kernel.c/1.9/Thu Feb  1 09:46:59 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CharDev/kernel/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/CVS/Repository	Thu Feb  1 11:46:59 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CharDev/kernel
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/CVS/Root
--- linux-2.4.1/net/korbit/modules/CharDev/kernel/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/CVS/Root	Thu Feb  1 11:46:59 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel/Makefile linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/Makefile
--- linux-2.4.1/net/korbit/modules/CharDev/kernel/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/Makefile	Thu Feb  1 11:46:59 2001
@@ -0,0 +1,20 @@
+#
+# Makefile for KORBit / chardev
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := corba-chardev-kernel.o
+
+obj-y := chardev-common.o chardev-stubs.o chardev-kernel.o
+obj-m := $(O_TARGET)
+
+include ../../Makefile.module
+
+chardev-kernel.c: chardev.h
+
+chardev.h chardev-stubs.c chardev-common.c: ../chardev.idl
+	$(ORBIT_IDL) ../chardev.idl
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel/README linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/README
--- linux-2.4.1/net/korbit/modules/CharDev/kernel/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/README	Thu Feb  1 11:46:59 2001
@@ -0,0 +1,5 @@
+This module is used to implement the kernel side of the CORBA Character 
+device.
+
+ORB: kORBit
+Status: Working!!!
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel/chardev-kernel.c linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/chardev-kernel.c
--- linux-2.4.1/net/korbit/modules/CharDev/kernel/chardev-kernel.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel/chardev-kernel.c	Thu Feb  1 11:46:59 2001
@@ -0,0 +1,140 @@
+//-----------------------------------------------------------------------------
+//
+// chardev-kernel - Kernel miscdevice to CORBA glue.
+//
+// This file implements a standard Linux Kernel "miscdevice".  This device 
+// operates by forwarding all calls across to a remote CORBA server.  This
+// server is located by reading the file /tmp/chardev-ior at the time the 
+// device is opened.  The device exported is major #10, minor #42.  Create this
+// device with 'mknod' like all the others.
+//
+// No implementations of CORBA functions should block, although I think it 
+// might be just fine, I'm not sure.  Let's just make this a TODO.  :) -CAL
+//
+// TODO: Locking, finish exporting all "miscdevice" functions, send position
+//       on READ request.
+//
+// History:
+//   Keith Wessel  - Initial hack, initial idea
+//   Andy Reitz    - Get it to compile
+//   Chris Lattner - Make it work.  :)
+//
+//-----------------------------------------------------------------------------
+
+
+#include "chardev.h"
+#include <stdio.h>
+#include "orb/orbit.h"
+#include "korbit.h"
+#include <linux/miscdevice.h>
+
+#define DEV_MINOR 42
+
+CORBA_ORB               orb;
+CORBA_Environment       *ev;
+
+static int open_dev(struct inode *inode, struct file *file) {
+  char *iorstr = (char *)malloc(10240);
+  int error = -EINVAL;
+  int fd, len;
+  
+  if (iorstr == 0) return -ENOMEM;
+  
+  if ((fd = open ("/tmp/chardev-ior", O_RDONLY, 0)) == -1) {
+    printk("kORBit: chararacter driver couldn't open /tmp/chardev-ior!\n");
+    goto outfree;
+  }
+
+  len = read(fd, iorstr, 10240);
+  close(fd);
+  if (len == -1) 
+    goto outfree;
+  
+  iorstr[len] = 0; // Null terminate string!
+  
+  printk("CharDEV IOR String = %s\n", iorstr);
+  file->private_data = (void*)CORBA_ORB_string_to_object(orb, iorstr, ev);
+  if (!file->private_data)
+    goto outfree;
+
+  // TODO: Send create_dev message out over CORBA
+  
+  error = 0;
+ outfree:
+  free(iorstr);
+  return error;
+}
+
+static int release_dev(struct inode *inode, struct file *file) {
+  // TODO: Send release_dev message out over CORBA...
+  if (file->private_data)
+    CORBA_free(file->private_data);
+  return 0;
+}
+
+
+static ssize_t read_dev(struct file * file, char * buf, size_t count, 
+			loff_t *ppos) {
+  Buffer *octet_buffer = NULL;
+  if (!file->private_data) return -EINVAL;
+  if (!count) return 0;
+
+  if (!access_ok(VERIFY_WRITE, buf, count))
+    return -EFAULT;
+  
+  CharDev_read(file->private_data, &octet_buffer, count, ev);
+  
+  if (!octet_buffer)
+    return -EPERM;
+  
+  if (copy_to_user(buf, octet_buffer->_buffer, octet_buffer->_length))
+    return -EFAULT;
+
+  // TODO: Should free octet_buffer here!?!?!?
+
+  return octet_buffer->_length;
+}
+
+
+//-----------------------------------------------------------------------------
+//                      Kernel Callbacks for miscdevice
+//-----------------------------------------------------------------------------
+
+
+static struct file_operations dev_fops = {
+  owner:   THIS_MODULE,
+  open:    open_dev,
+  read:    read_dev,
+  release: release_dev,
+  // mmap: mmap_dev,
+  // llseek: llseek_dev,
+  // write: write_dev,
+};
+
+static struct miscdevice cdev = {
+  DEV_MINOR,
+  "CORBA Character device",
+  &dev_fops
+};
+
+
+//-----------------------------------------------------------------------------
+//                     Module Initializion/Finalization
+//-----------------------------------------------------------------------------
+
+static int __init CharDev_init(void) {
+  int argc = 1; 
+  char *argv[] = { "CharDev-kernel", 0 };
+  ev = g_new0(CORBA_Environment,1);
+  orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", ev);
+  
+  // Register the device
+  return misc_register(&cdev);
+}
+
+static void __exit CharDev_exit(void) {
+  misc_deregister(&cdev);
+}
+
+module_init(CharDev_init)
+module_exit(CharDev_exit)
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/CVS/Entries	Thu Feb  1 11:46:59 2001
@@ -0,0 +1,3 @@
+/PerlTest/1.1/Thu Feb  1 09:46:59 2001//
+/README/1.1/Thu Feb  1 09:46:59 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/CVS/Repository	Thu Feb  1 11:46:59 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CharDev/kernel-perl
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/CVS/Root
--- linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/CVS/Root	Thu Feb  1 11:46:59 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/PerlTest linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/PerlTest
--- linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/PerlTest	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/PerlTest	Thu Feb  1 11:46:59 2001
@@ -0,0 +1,17 @@
+#!/usr/bin/perl -w
+
+use CORBA::ORBit idl => [ qw(../chardev.idl) ];
+use Error qw(:try);
+use strict;
+
+my $orb = CORBA::ORB_init("orbit-local-orb");
+open IOR, "/tmp/chardev-ior" or die "no chardev server found!";
+my $ior = <IOR>;
+close IOR;
+#chomp($ior);  # Kill fredrik's newline...
+
+my $chardev = $orb->string_to_object($ior);
+# Echo echoString(in string astring, out long anum);
+my ($ressize, $buf) = $chardev->read(10);
+
+print "Return size = $ressize\nresult = $buf\n";
diff -urN linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/README linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/README
--- linux-2.4.1/net/korbit/modules/CharDev/kernel-perl/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/kernel-perl/README	Thu Feb  1 11:46:59 2001
@@ -0,0 +1,6 @@
+This module is used to test the user side of the CORBA Character 
+device.  It doesn't do anything really complex, just implements a quick
+sanity test for the server.
+
+ORB: ORBit - Perl
+Status: Working!
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/CVS/Entries	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,6 @@
+/Makefile/1.5/Thu Feb  1 09:47:00 2001//
+/README/1.1/Thu Feb  1 09:47:00 2001//
+/RunServer.sh/1.1/Thu Feb  1 09:47:00 2001//
+/chardev-server.c/1.5/Thu Feb  1 09:47:00 2001//
+/chardev-skelimpl.c/1.5/Thu Feb  1 09:47:00 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/CVS/Repository	Thu Feb  1 11:47:00 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CharDev/userspace
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/CVS/Root
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/CVS/Root	Thu Feb  1 11:47:00 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/Makefile linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/Makefile
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/Makefile	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,30 @@
+#
+# Makefile for KORBit / CharDev
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+CFLAGS = -Wall -I/usr/lib/glib/include
+LDFLAGS = -lORBit -lIIOP -lORBitutil
+OBJS = chardev-common.o chardev-skels.o chardev-server.o 
+ORBIT-IDL = /usr/bin/orbit-idl
+
+chardev-server: $(OBJS)
+	gcc -o chardev-server $(OBJS) $(LDFLAGS)
+
+chardev-server.o: chardev.h chardev-skelimpl.c
+
+chardev.h chardev-skels.c chardev-common.c: ../chardev.idl
+	$(ORBIT-IDL) ../chardev.idl
+
+chardev-skelimpl.c:
+
+%.o: %.c
+	gcc -c $< $(CFLAGS)
+clean:
+	rm -f $(OBJS) chardev-server chardev-common.c chardev-skels.c \
+		chardev-stubs.c chardev.h
+
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/README linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/README
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/README	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,4 @@
+This is an example character driver.
+
+ORB: ORBit
+Status: not yet working
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/RunServer.sh linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/RunServer.sh
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/RunServer.sh	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/RunServer.sh	Thu Feb  1 11:47:00 2001
@@ -0,0 +1 @@
+./chardev-server -ORBIIOPUSock=0 -ORBIIOPIPv4=1
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/chardev-server.c linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/chardev-server.c
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/chardev-server.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/chardev-server.c	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,77 @@
+//-----------------------------------------------------------------------------
+//
+// chardev-server.c - TEST Kernel miscdevice implementation
+//
+// This file implements the standard server code for a userspace server.  This
+// is basically cut and paste boilerplate code adapted from the CorbaFS server
+// by Fredrik Vraalsen.
+//
+// TODO: Locking, finish exporting all "miscdevice" functions, send position
+//       on READ request.
+//
+// History:
+//   Keith Wessel  - Initial hack, initial idea
+//   Andy Reitz    - Get it to compile
+//   Chris Lattner - Hack'n'slash, make it work, comment it, kill warnings.
+//
+//-----------------------------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <orb/orbit.h>
+
+// #include the C file because all the functions are static.  Bizarre.
+#include "chardev-skelimpl.c"
+
+int main(int argc, char *argv[]) {
+    PortableServer_POA poa;
+    PortableServer_POAManager pm;
+
+    CharDev chardev = CORBA_OBJECT_NIL;
+    impl_POA_CharDev *chardev_impl;
+    PortableServer_ObjectId *objid;
+
+    CORBA_Environment ev;
+    char *retval;
+    CORBA_ORB orb;
+    FILE *IORFILE;
+
+    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);
+    poa = (PortableServer_POA)CORBA_ORB_resolve_initial_references(orb, "RootPOA", &ev);
+
+    chardev = impl_CharDev__create(poa, &ev);
+    pm = PortableServer_POA__get_the_POAManager(poa, &ev);
+    PortableServer_POAManager_activate(pm, &ev);
+
+    if (!chardev) {
+	printf("Cannot get objref\n");
+	return 1;
+    }
+
+    chardev_impl = PortableServer_POA_reference_to_servant(poa, chardev, &ev);
+    objid = PortableServer_POA_servant_to_id(poa, chardev_impl, &ev);
+
+    retval = CORBA_ORB_object_to_string(orb, chardev, &ev);
+
+    g_print("FYI, this also goes into /tmp/chardev-ior for you.\n");
+    g_print("%s\n", retval); fflush(stdout);
+ 
+    IORFILE = fopen ("/tmp/chardev-ior", "w");
+    if (IORFILE == NULL) {
+      perror("ERROR: IOR_WRITE_TO_DISK");
+      exit(1);
+    }
+
+    fprintf(IORFILE, "%s", retval);
+    fclose(IORFILE);
+
+    CORBA_free(retval);  // Free the corba string like a good little CORBear
+
+
+    // La dee dah... I will never return for you mister.
+    CORBA_ORB_run(orb, &ev);
+    return 0;
+}
+
diff -urN linux-2.4.1/net/korbit/modules/CharDev/userspace/chardev-skelimpl.c linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/chardev-skelimpl.c
--- linux-2.4.1/net/korbit/modules/CharDev/userspace/chardev-skelimpl.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CharDev/userspace/chardev-skelimpl.c	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,119 @@
+//-----------------------------------------------------------------------------
+//
+// chardev-skelimpl.c - TEST Kernel miscdevice implementation
+//
+// This file implements a CORBA "miscdevice" (character device node).  
+// This device simply outputs a fixed string (set by "message", below) when
+// cat'd.  Pretty simple stuff, but you can obviously do much more creative
+// things with it.
+//
+// TODO: Locking, finish exporting all "miscdevice" functions, send position
+//       on READ request.
+//
+// Right now we have ONE server object with global state, so that when you 
+// read the string from that object, it is finished.  This should be reset
+// whenever an open request is had or when the file position is reset (duh).
+//
+// History:
+//   Keith Wessel  - Initial hack, initial idea
+//   Andy Reitz    - Get it to compile
+//   Chris Lattner - Make it work, comment it, no warnings.
+//
+//-----------------------------------------------------------------------------
+
+#include "chardev.h"
+
+// The message to spit out.
+const char *message = "Hello world!\nI love kORBit\n";
+
+
+/*** App-specific servant structures ***/
+
+typedef struct
+{
+   POA_CharDev servant;
+   PortableServer_POA poa;
+   int AmountRead;
+
+}
+impl_POA_CharDev;
+
+/*** Implementation stub prototypes ***/
+
+static inline void impl_CharDev__destroy(impl_POA_CharDev * servant,
+					 CORBA_Environment * ev);
+static CORBA_long
+impl_CharDev_read(impl_POA_CharDev * servant,
+		  Buffer ** buffer, CORBA_long size, CORBA_Environment * ev);
+
+/*** epv structures ***/
+
+static PortableServer_ServantBase__epv impl_CharDev_base_epv = {
+   NULL,			/* _private data */
+   NULL,			/* finalize routine */
+   NULL,			/* default_POA routine */
+};
+static POA_CharDev__epv impl_CharDev_epv = {
+   NULL,			/* _private */
+   (gpointer) & impl_CharDev_read,
+
+};
+
+/*** vepv structures ***/
+
+static POA_CharDev__vepv impl_CharDev_vepv = {
+   &impl_CharDev_base_epv,
+   &impl_CharDev_epv,
+};
+
+/*** Stub implementations ***/
+
+static CharDev
+impl_CharDev__create(PortableServer_POA poa, CORBA_Environment * ev)
+{
+   CharDev retval;
+   impl_POA_CharDev *newservant;
+   PortableServer_ObjectId *objid;
+
+   newservant = g_new0(impl_POA_CharDev, 1);
+   newservant->servant.vepv = &impl_CharDev_vepv;
+   newservant->poa = poa;
+   newservant->AmountRead = 0;  // Initialize chardev stuff...
+
+   POA_CharDev__init((PortableServer_Servant) newservant, ev);
+   objid = PortableServer_POA_activate_object(poa, newservant, ev);
+   CORBA_free(objid);
+   retval = PortableServer_POA_servant_to_reference(poa, newservant, ev);
+
+   return retval;
+}
+
+static inline void
+impl_CharDev__destroy(impl_POA_CharDev * servant, CORBA_Environment * ev)
+{
+   PortableServer_ObjectId *objid;
+
+   objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev);
+   PortableServer_POA_deactivate_object(servant->poa, objid, ev);
+   CORBA_free(objid);
+
+   POA_CharDev__fini((PortableServer_Servant) servant, ev);
+   g_free(servant);
+}
+
+static CORBA_long
+impl_CharDev_read(impl_POA_CharDev * servant,
+		  Buffer ** buffer, CORBA_long ReqSize, CORBA_Environment * ev)
+{
+   int AvailSize = strlen(message)-servant->AmountRead;
+   CORBA_long retval = (ReqSize > AvailSize) ? AvailSize : ReqSize;
+
+   *buffer = Buffer__alloc();
+   (*buffer)->_buffer = CORBA_octet_allocbuf(retval);
+   (*buffer)->_length = retval;
+
+   strncpy((*buffer)->_buffer, message + servant->AmountRead, retval);
+   servant->AmountRead += retval;
+   return retval;
+}
+
diff -urN linux-2.4.1/net/korbit/modules/Config.in linux-2.4.1-korbit/net/korbit/modules/Config.in
--- linux-2.4.1/net/korbit/modules/Config.in	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Config.in	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,11 @@
+# Console server
+#
+dep_tristate '    CORBA Console Server (EXPERIMENTAL)' CONFIG_CORBA_CONSOLE $CONFIG_KORBIT
+
+dep_tristate '    CORBA Echo Server (EXPERIMENTAL)' CONFIG_CORBA_ECHO $CONFIG_KORBIT
+
+dep_tristate '    CORBA FileSystem Access (EXPERIMENTAL)' CONFIG_CORBA_FILESERVER $CONFIG_KORBIT
+
+dep_tristate '    CORBA User-space FileSystem (EXPERIMENTAL)' CONFIG_CORBA_CORBAFS $CONFIG_KORBIT
+
+dep_tristate '    CORBA Character Device Interface (EXPERIMENTAL)' CONFIG_CORBA_CHARDEV $CONFIG_KORBIT
diff -urN linux-2.4.1/net/korbit/modules/Console/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Console/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Entries	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,4 @@
+/Makefile/1.2/Thu Feb  1 09:47:00 2001//
+/README/1.1/Thu Feb  1 09:47:00 2001//
+/console.idl/1.1/Thu Feb  1 09:47:00 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Console/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Entries.Log
--- linux-2.4.1/net/korbit/modules/Console/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Entries.Log	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,3 @@
+A D/PerlClient////
+A D/client////
+A D/server////
diff -urN linux-2.4.1/net/korbit/modules/Console/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Console/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Repository	Thu Feb  1 11:47:00 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Console
diff -urN linux-2.4.1/net/korbit/modules/Console/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Root
--- linux-2.4.1/net/korbit/modules/Console/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/CVS/Root	Thu Feb  1 11:47:00 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Console/Makefile linux-2.4.1-korbit/net/korbit/modules/Console/Makefile
--- linux-2.4.1/net/korbit/modules/Console/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/Makefile	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,11 @@
+#
+# Makefile for KORBit/modules/Console
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+
+subdir-$(CONFIG_CORBA_CONSOLE) := server
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/modules/Console/PerlClient/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Console/PerlClient/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/CVS/Entries	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,3 @@
+/Client/1.1/Thu Feb  1 09:47:01 2001//
+/README/1.1/Thu Feb  1 09:47:01 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Console/PerlClient/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Console/PerlClient/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/CVS/Repository	Thu Feb  1 11:47:01 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Console/PerlClient
diff -urN linux-2.4.1/net/korbit/modules/Console/PerlClient/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/CVS/Root
--- linux-2.4.1/net/korbit/modules/Console/PerlClient/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/CVS/Root	Thu Feb  1 11:47:01 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Console/PerlClient/Client linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/Client
--- linux-2.4.1/net/korbit/modules/Console/PerlClient/Client	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/Client	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,14 @@
+#!/usr/bin/perl -w
+
+use CORBA::ORBit idl => [ qw(../console.idl) ];
+use Error qw(:try);
+use strict;
+
+my $orb = CORBA::ORB_init("orbit-local-orb");
+open IOR, "/proc/corba/console-server" or die "no console server found!";
+my $ior = <IOR>;
+close IOR;
+chomp($ior);  # Kill fredrik's newline...
+
+my $console = $orb->string_to_object($ior);
+$console->print("Hello Strange World");
diff -urN linux-2.4.1/net/korbit/modules/Console/PerlClient/README linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/README
--- linux-2.4.1/net/korbit/modules/Console/PerlClient/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/PerlClient/README	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,3 @@
+This is a perl client for the Console server.
+
+ORB: ORBit
diff -urN linux-2.4.1/net/korbit/modules/Console/README linux-2.4.1-korbit/net/korbit/modules/Console/README
--- linux-2.4.1/net/korbit/modules/Console/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/README	Thu Feb  1 11:47:00 2001
@@ -0,0 +1 @@
+The "hello world" testcase.  This is used to write a string to the linux console.
diff -urN linux-2.4.1/net/korbit/modules/Console/client/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Console/client/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Console/client/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/client/CVS/Entries	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,4 @@
+/Makefile/1.2/Thu Feb  1 09:47:01 2001//
+/README/1.1/Thu Feb  1 09:47:01 2001//
+/console-client.c/1.1/Thu Feb  1 09:47:01 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Console/client/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Console/client/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Console/client/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/client/CVS/Repository	Thu Feb  1 11:47:01 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Console/client
diff -urN linux-2.4.1/net/korbit/modules/Console/client/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Console/client/CVS/Root
--- linux-2.4.1/net/korbit/modules/Console/client/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/client/CVS/Root	Thu Feb  1 11:47:01 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Console/client/Makefile linux-2.4.1-korbit/net/korbit/modules/Console/client/Makefile
--- linux-2.4.1/net/korbit/modules/Console/client/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/client/Makefile	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,32 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+PROJECT = console
+
+CFLAGS = -Wall `orbit-config --cflags client` -I../../..
+LDFLAGS = `orbit-config --libs client`
+OBJS = $(PROJECT)-common.o $(PROJECT)-stubs.o $(PROJECT)-client.o 
+ORBIT-IDL = orbit-idl
+
+$(PROJECT)-client: $(OBJS)
+	gcc -o $(PROJECT)-client $(OBJS) $(LDFLAGS)
+
+$(PROJECT)-client.c: $(PROJECT).h
+
+$(PROJECT).h $(PROJECT)-common.c $(PROJECT)-stubs.c: ../$(PROJECT).idl
+	$(ORBIT-IDL) --noskels ../$(PROJECT).idl
+
+clean:
+	rm -f $(OBJS) $(PROJECT)-client
+
+realclean: clean
+	rm -f $(PROJECT).h
+	rm -f $(PROJECT)-common.c
+	rm -f $(PROJECT)-stubs.c
+	rm -f *~
diff -urN linux-2.4.1/net/korbit/modules/Console/client/README linux-2.4.1-korbit/net/korbit/modules/Console/client/README
--- linux-2.4.1/net/korbit/modules/Console/client/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/client/README	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,3 @@
+C Client to access console server.
+
+ORB: ORBit
diff -urN linux-2.4.1/net/korbit/modules/Console/client/console-client.c linux-2.4.1-korbit/net/korbit/modules/Console/client/console-client.c
--- linux-2.4.1/net/korbit/modules/Console/client/console-client.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/client/console-client.c	Thu Feb  1 11:47:01 2001
@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <orb/orbit.h>
+
+#include "console.h"
+
+Console console_client;
+
+int
+main (int argc, char *argv[])
+{
+    CORBA_Environment ev;
+    CORBA_ORB orb;
+    char *Message = "Hey dood, nice hair";
+    int i;
+
+    int niters = 10;
+
+    CORBA_exception_init(&ev);
+    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);
+
+#if 0
+    for(i = 0; i < (sizeof(theblah) - 1); i++)
+	theblah[i] = 'a';
+    theblah[sizeof(theblah) - 1] = '\0';
+#endif
+
+    if(argc < 2)
+      {
+	printf("Need a binding ID thing as argv[1]\n");
+	return 1;
+      }
+
+    if(argc >= 3)
+	niters = atoi(argv[2]);
+
+    if (argc >= 4)
+      Message = argv[3];
+
+    console_client = CORBA_ORB_string_to_object(orb, argv[1], &ev);
+    if (!console_client) {
+	printf("Cannot bind to %s\n", argv[1]);
+	return 1;
+    }
+
+    printf("corba = %d, console = %d, foobar = %d\n",
+	CORBA_Object_is_a(console_client, "IDL:CORBA/Object:1.0", &ev),
+	CORBA_Object_is_a(console_client, "IDL:Empty:1.0", &ev),
+	CORBA_Object_is_a(console_client, "IDL:Foo/Bar:1.0", &ev));
+
+    for(i = 0; i < niters; i++) {
+	    Console_print(console_client, Message, &ev);
+	    if(ev._major != CORBA_NO_EXCEPTION) {
+	      printf("we got exception %d from doNothing!\n", ev._major);
+	      return 1;
+	    }
+    }
+
+    CORBA_Object_release(console_client, &ev);
+    CORBA_Object_release((CORBA_Object)orb, &ev);
+
+    return 0;
+}
diff -urN linux-2.4.1/net/korbit/modules/Console/console.idl linux-2.4.1-korbit/net/korbit/modules/Console/console.idl
--- linux-2.4.1/net/korbit/modules/Console/console.idl	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/console.idl	Thu Feb  1 11:47:00 2001
@@ -0,0 +1,3 @@
+interface Console {
+  void print(in string TheString);
+};
diff -urN linux-2.4.1/net/korbit/modules/Console/server/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Console/server/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Console/server/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/server/CVS/Entries	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,5 @@
+/Makefile/1.7/Thu Feb  1 09:47:02 2001//
+/Makefile.user/1.1/Thu Feb  1 09:47:02 2001//
+/README/1.1/Thu Feb  1 09:47:02 2001//
+/console-server.c/1.7/Thu Feb  1 09:47:02 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Console/server/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Console/server/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Console/server/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/server/CVS/Repository	Thu Feb  1 11:47:02 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Console/server
diff -urN linux-2.4.1/net/korbit/modules/Console/server/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Console/server/CVS/Root
--- linux-2.4.1/net/korbit/modules/Console/server/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/server/CVS/Root	Thu Feb  1 11:47:02 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Console/server/Makefile linux-2.4.1-korbit/net/korbit/modules/Console/server/Makefile
--- linux-2.4.1/net/korbit/modules/Console/server/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/server/Makefile	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,21 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := corba-cons-server.o
+
+obj-y := console-server.o console-skels.o console-common.o
+obj-m := $(O_TARGET)
+
+include ../../Makefile.module
+
+console-server.c: console.h console-common.c console-skels.c
+
+
+console.h console-skels.c: ../console.idl
+	$(ORBIT_IDL) ../console.idl
diff -urN linux-2.4.1/net/korbit/modules/Console/server/Makefile.user linux-2.4.1-korbit/net/korbit/modules/Console/server/Makefile.user
--- linux-2.4.1/net/korbit/modules/Console/server/Makefile.user	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/server/Makefile.user	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,32 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+PROJECT = console
+
+CFLAGS = -Wall `orbit-config --cflags server` -I../../..
+LDFLAGS = `orbit-config --libs server`
+OBJS = $(PROJECT)-common.o $(PROJECT)-skels.o $(PROJECT)-server.o 
+ORBIT-IDL = orbit-idl
+
+$(PROJECT)-server: $(OBJS)
+	gcc -o $(PROJECT)-server $(OBJS) $(LDFLAGS)
+
+$(PROJECT)-server.c: $(PROJECT).h
+
+$(PROJECT).h $(PROJECT)-common.c $(PROJECT)-skels.c: ../$(PROJECT).idl
+	$(ORBIT-IDL) --nostubs ../$(PROJECT).idl
+
+clean:
+	rm -f $(OBJS) $(PROJECT)-server
+
+realclean: clean
+	rm -f $(PROJECT).h
+	rm -f $(PROJECT)-common.c
+	rm -f $(PROJECT)-skels.c
+	rm -f *~
diff -urN linux-2.4.1/net/korbit/modules/Console/server/README linux-2.4.1-korbit/net/korbit/modules/Console/server/README
--- linux-2.4.1/net/korbit/modules/Console/server/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/server/README	Thu Feb  1 11:47:02 2001
@@ -0,0 +1 @@
+Kernel module to implement Console server.
diff -urN linux-2.4.1/net/korbit/modules/Console/server/console-server.c linux-2.4.1-korbit/net/korbit/modules/Console/server/console-server.c
--- linux-2.4.1/net/korbit/modules/Console/server/console-server.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Console/server/console-server.c	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <orb/orbit.h>
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include "console.h"
+#include "glib.h"
+#include "korbit.h"
+
+Console console_client = CORBA_OBJECT_NIL;
+
+static void corba_console_print(PortableServer_Servant _servant, 
+                                CORBA_char *TheString,
+                                CORBA_Environment *ev);
+
+PortableServer_ServantBase__epv base_epv = {
+  NULL,
+  NULL,
+  NULL
+};
+POA_Console__epv console_epv = { NULL, corba_console_print };
+POA_Console__vepv poa_console_vepv = { &base_epv, &console_epv };
+POA_Console poa_console_servant = { NULL, &poa_console_vepv };
+
+// MAke this global so that I can unregister the module...
+PortableServer_ObjectId objid = {0, sizeof("myFoo"), "myFoo"};
+CORBA_Environment *ev;
+PortableServer_POA poa;
+
+#ifdef __KERNEL__
+int __init corba_console_init(void) 
+#else
+int main(int argc, char *argv[])
+#endif
+{
+#ifdef __KERNEL__
+    int argc = 1; char *argv[] = { "server", 0 };
+#endif
+    CORBA_ORB orb;
+
+    ev = g_new0(CORBA_Environment, 1);
+    CORBA_exception_init(ev);
+    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", ev);
+
+    poa = (PortableServer_POA)CORBA_ORB_resolve_initial_references(orb, "RootPOA", ev);
+    PortableServer_POAManager_activate(PortableServer_POA__get_the_POAManager(poa, ev), ev);
+
+    POA_Console__init(&poa_console_servant, ev);
+
+    PortableServer_POA_activate_object_with_id(poa,
+					       &objid, &poa_console_servant, ev);
+
+    console_client = 
+      PortableServer_POA_servant_to_reference(poa, &poa_console_servant, ev);
+    if (!console_client) {
+	printf("Cannot get objref\n");
+	return 1;
+    }
+
+    korbit_register_ior("console-server", console_client, orb, ev);
+
+    CORBA_ORB_run(orb, ev);
+
+    return 0;
+}
+
+#ifdef __KERNEL__
+void corba_console_exit(void) { 
+  PortableServer_POA_deactivate_object(poa, &objid, ev);
+  remove_proc_entry("corba/console-server", 0);
+}
+
+module_init(corba_console_init)
+module_exit(corba_console_exit)
+#endif
+
+static void corba_console_print(PortableServer_Servant _servant, 
+                                CORBA_char *TheString,
+                                CORBA_Environment *ev) {
+  printf("Yo. Dood.  You said: '%s'!\n", TheString);
+}
+
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Entries	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,4 @@
+/CorbaFS.idl/1.7/Thu Feb  1 09:47:02 2001//
+/Makefile/1.4/Thu Feb  1 09:47:02 2001//
+/README/1.2/Thu Feb  1 09:47:02 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Entries.Log
--- linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Entries.Log	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,3 @@
+A D/client////
+A D/server////
+A D/server-perl////
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Repository	Thu Feb  1 11:47:02 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CorbaFS
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Root
--- linux-2.4.1/net/korbit/modules/CorbaFS/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CVS/Root	Thu Feb  1 11:47:02 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/CorbaFS.idl linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CorbaFS.idl
--- linux-2.4.1/net/korbit/modules/CorbaFS/CorbaFS.idl	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/CorbaFS.idl	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,38 @@
+// -----------------------------------------------------------------------------
+// CorbaDS Module - Implement Kernel functionality in Korba
+// -----------------------------------------------------------------------------
+//
+// Main source of information: 
+//    http://www.cse.unsw.edu.au/~neilb/oss/linux-commentary/vfs.html
+//
+module CorbaFS {
+
+  struct dirent
+  {
+    long inode;           // inode number 
+    string name;          // file name (null-terminated)
+  };
+
+  typedef sequence<dirent> DirEntSeq;
+  typedef sequence<octet> Buffer;
+        
+  interface Inode {
+    void getStatus(out unsigned short mode, out unsigned long uid, out unsigned long gid, 
+                   out unsigned long size, out unsigned long inodeNum, out unsigned short numLinks, 
+                   out long atime, out long mtime, out long ctime);
+    void readpage(out Buffer buffer, in long size, in long offset);
+    void release();
+  };
+
+  interface FileSystem {  
+    Inode getInode(in string path);
+
+    // DirectoryInode  getStatus implementation must have S_IFDIR in the S_IFMT
+    // field of the mode value.
+    DirEntSeq readdir(in string path);
+
+    // SymlinkInode getStatus implementation must have S_IFLNK in the S_IFMT
+    // field of the mode value.
+    string readlink(in string filename);
+  };
+};
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/Makefile linux-2.4.1-korbit/net/korbit/modules/CorbaFS/Makefile
--- linux-2.4.1/net/korbit/modules/CorbaFS/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/Makefile	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,11 @@
+#
+# Makefile for KORBit - CorbaFS
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+
+subdir-$(CONFIG_CORBA_CORBAFS) := client
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/README linux-2.4.1-korbit/net/korbit/modules/CorbaFS/README
--- linux-2.4.1/net/korbit/modules/CorbaFS/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/README	Thu Feb  1 11:47:02 2001
@@ -0,0 +1,14 @@
+This interface is used to implement linux FileSystems in CORBA.
+
+Status: Working for readonly filesystems.  Write capability is a todo.
+
+This lets you do all kinds of interesting things (just like the user level 
+filesystem proposals would let you do):
+  server/ implements NFS like capability of just exporting an existing FS
+  TODO:   webfs, ftpfs, cvsfs, mysqlfs...
+
+Usage:
+  insmod corba-corbafs.o
+  mount -t corbafs -o IOR:... none /mnt/corbafs
+
+Where the IOR comes from a filesystem server that you run somewhere...
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CVS/Entries	Thu Feb  1 11:47:03 2001
@@ -0,0 +1,6 @@
+/CorbaFS-client.c/1.9/Thu Feb  1 09:47:03 2001//
+/CorbaFS-user-client.c/1.3/Thu Feb  1 09:47:03 2001//
+/Makefile/1.4/Thu Feb  1 09:47:03 2001//
+/Makefile.user/1.1/Thu Feb  1 09:47:03 2001//
+/README/1.1/Thu Feb  1 09:47:03 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CVS/Repository	Thu Feb  1 11:47:03 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CorbaFS/client
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CVS/Root
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CVS/Root	Thu Feb  1 11:47:03 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-client.c linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-client.c
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-client.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-client.c	Fri Feb  2 02:20:21 2001
@@ -0,0 +1,469 @@
+/*
+ * corbafs - Interface glue between native linux VFS layer and CORBA
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/pagemap.h>
+#include <linux/init.h>
+#include <linux/string.h>
+#include <linux/locks.h>
+#include <linux/dirent.h>
+#include <linux/module.h>
+
+#include <asm/uaccess.h>
+#include "CorbaFS.h"
+
+/* some random number */
+#define CORBAFS_MAGIC	0xC02BAF5
+
+// CORBA Stuff...
+CORBA_ORB         orb;
+CORBA_Environment *ev;
+
+
+/*
+ *  FILE OPERATIONS     FILE OPERATIONS     FILE OPERATIONS     FILE OPERATIONS
+ */
+
+/* Declarations for the file_operations structure for normal files...
+ */
+static struct file_operations corbafs_file_operations = {
+        read:           generic_file_read,
+};
+
+
+/* Declarations for the file_operations structure for directories...
+ */
+static int corbafs_readdir(struct file *file, void *data, filldir_t filldir);
+
+static struct file_operations corbafs_dir_operations = {
+	read:		generic_read_dir,
+	readdir:	corbafs_readdir,
+};
+
+
+/*
+ * INODE OPERATIONS    INODE OPERATIONS    INODE OPERATIONS    INODE OPERATIONS
+ */
+
+/* Declarations for the inode_operations structure for symlinks...
+ */
+static int corbafs_readlink(struct dentry *dentry, char *buffer, int buflen);
+static int corbafs_followlink(struct dentry *link, struct nameidata *nd);
+
+static struct inode_operations corbafs_symlink_inode_operations = {
+        readlink:       corbafs_readlink,
+        follow_link:    corbafs_followlink,
+};
+
+
+/* Declarations for the inode_operations structure for directories...
+ */
+static struct dentry *corbafs_lookup(struct inode *dir, struct dentry *dentry);
+
+static struct inode_operations corbafs_dir_inode_operations = {
+	lookup:		corbafs_lookup,
+};
+
+
+/*
+ * OTHER OPERATIONS    OTHER OPERATIONS    OTHER OPERATIONS    OTHER OPERATIONS
+ */
+
+/* Declarations for the corba FS's address space ops...
+ */
+static int corbafs_readpage(struct file *file, struct page * page);
+
+static struct address_space_operations corbafs_aops = {
+	readpage:	corbafs_readpage,
+};
+
+
+/* Declarations for the super_operations structure...
+ */
+static int corbafs_statfs(struct super_block *sb, struct statfs *buf);
+static void corbafs_delete_inode(struct inode *);
+
+static struct super_operations corbafs_ops = {
+	statfs:		corbafs_statfs,
+	delete_inode: corbafs_delete_inode,
+};
+
+
+
+
+/* do_local_path - Modified version of d_path that is used to get the remote 
+ * filename that a dentry represents... 
+ */
+static char *d_local_path(struct dentry *dentry, char *buffer, int buflen) {
+        char * end = buffer+buflen;
+        char * retval;
+        int namelen;
+
+        *--end = '\0';
+        buflen--;
+
+        /* Get '/' right */
+        retval = end-1;
+        *retval = '/';
+        for (;;) {
+                if (IS_ROOT(dentry)) {
+                        if (dentry->d_name.len > 1 || 
+                            dentry->d_name.name[0] != '/' ||
+                            retval != end) {   /* Only for root directory */
+                                namelen = dentry->d_name.len;
+                                buflen -= namelen;
+                                if (buflen >= 0) {
+                                        end -= namelen;
+                                        memcpy(end, dentry->d_name.name, namelen);
+                                }
+                        }
+                        return end;
+                }
+                namelen = dentry->d_name.len;
+                buflen -= namelen + 1;
+                if (buflen < 0)
+                        break;
+                end -= namelen;
+                memcpy(end, dentry->d_name.name, namelen);
+                *--end = '/';
+                retval = end;
+                if (dentry == dentry->d_parent) break;
+                dentry = dentry->d_parent;
+        }
+        return retval;
+}
+
+
+/* corbafs_readpage - This request should be between a file_open and a 
+ * file_release, so file_fd(f) should be valid.  Just read the buffer...
+ */
+static int corbafs_readpage(struct file *f, struct page * page)
+{
+        struct inode *d_inode = f->f_dentry->d_inode;
+        CorbaFS_Inode inode;
+        CorbaFS_Buffer *buffer = NULL;
+        
+        int offset = page->index*PAGE_CACHE_SIZE;
+        int bytesRead;
+        
+#if 0
+        printk("*** READPAGE 0x%p: 0x%lX->0x%lX to 0x%p\n",
+               f, 
+               page->index, 
+               page->index*PAGE_CACHE_SIZE, 
+               page_address(page));
+#endif
+
+        inode = d_inode->u.generic_ip;
+        if (!inode) return -EPERM;
+
+        CorbaFS_Inode_readpage(inode, &buffer, PAGE_CACHE_SIZE, offset, ev);
+        if (!buffer) return -EPERM; /* ??? */
+        
+        bytesRead = buffer->_length;
+        memcpy(page_address(page), buffer->_buffer, bytesRead);
+        
+        if (bytesRead != PAGE_CACHE_SIZE) {  /* EOF? */
+                /* Zero out rest of page for security. */
+                memset((void*)(page_address(page)+bytesRead), 0, 
+                       PAGE_CACHE_SIZE-bytesRead);
+        }
+
+        SetPageUptodate(page);
+        UnlockPage(page);
+        return 0;
+}
+
+
+
+struct inode *corbafs_get_inode(struct super_block *sb, const char *path)
+{
+	struct inode * inode = get_empty_inode();
+        CorbaFS_FileSystem fs_client;
+        CorbaFS_Inode newInode;
+        
+	if (!inode) return 0;
+
+	inode->i_sb = sb;
+	inode->i_dev = sb->s_dev;
+
+	fs_client = sb->u.generic_sbp;
+//printk("\n \n  \nCorbaFS_FileSystem_getInode(0x%X, %s)\n", fs_client, path);
+	newInode = CorbaFS_FileSystem_getInode(fs_client, path, ev);
+//printk("NewInode = 0x%X\n \n  \n   \n", newInode);
+	if (!newInode) {
+		iput(inode);
+		return NULL;
+	}
+
+//printk("CorbaFS_Inode_getStatus\n");
+	CorbaFS_Inode_getStatus(newInode, 
+				&inode->i_mode, &inode->i_uid, &inode->i_gid, 
+				(CORBA_unsigned_long *)&inode->i_size, 
+				(CORBA_unsigned_long *)&inode->i_ino, 
+				&inode->i_nlink, 
+				(CORBA_long *)&inode->i_atime, 
+				(CORBA_long *)&inode->i_mtime, 
+				(CORBA_long *)&inode->i_ctime,
+				ev);
+//printk("Back from CorbaFS_Inode_getStatus\n \n  \n   \n");
+
+	inode->u.generic_ip = (void*)newInode;
+	
+        /* TODO: Map things back correctly??? */
+	inode->i_uid = 0 /*current->fsuid */;
+	inode->i_gid = 0 /*current->fsgid */;
+	
+	inode->i_blksize = PAGE_CACHE_SIZE;
+	inode->i_blocks = 0;
+	inode->i_rdev = 0;
+	inode->i_op = NULL;
+	inode->i_fop = NULL;
+	inode->i_mapping->a_ops = &corbafs_aops;
+	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+	
+	switch (inode->i_mode & S_IFMT) {
+	default:
+		/* Do I really want to expose device inodes? */
+		init_special_inode(inode, inode->i_mode, sb->s_dev);
+		break;
+	case S_IFREG:
+		inode->i_fop = &corbafs_file_operations;
+		break;
+	case S_IFDIR:
+		inode->i_op = &corbafs_dir_inode_operations;
+		inode->i_fop = &corbafs_dir_operations;
+		break;
+	case S_IFLNK:
+		inode->i_op = &corbafs_symlink_inode_operations;
+		break;
+	}
+	insert_inode_hash(inode);
+
+	return inode;
+}
+
+static int corbafs_readdir(struct file *file, void *data, filldir_t filldir) 
+{
+        struct inode *inode = file->f_dentry->d_inode;
+        struct super_block *sb = file->f_dentry->d_sb;
+        unsigned offset = file->f_pos;
+        char *path, *page = (char *)__get_free_page(GFP_KERNEL);
+        int i;
+        unsigned char d_type = DT_UNKNOWN;
+        CorbaFS_FileSystem fs_client;
+        CorbaFS_DirEntSeq *dirEntSeq;
+        CorbaFS_dirent *dirEnts;
+        
+        if (offset >= inode->i_size) return 0;
+
+        path = d_local_path(file->f_dentry, page, PAGE_SIZE);
+
+        fs_client = sb->u.generic_sbp;
+        if (!fs_client)
+                return -EPERM; /* ??? */
+
+//        printk("\n \n  \nCorbaFS_FileSystem_readdir(%s)\n", path);
+        
+        dirEntSeq = CorbaFS_FileSystem_readdir(fs_client, path, ev);
+
+//        printk("CorbaFS_FileSystem_readdir = %d\n \n  \n  \n", dirEntSeq->_length);
+
+        if (dirEntSeq->_length == 0) goto full;
+	
+        dirEnts = dirEntSeq->_buffer;
+	i = 0;
+	if (offset) {                   // We have read PART of the directory
+		int idxadj = offset;    // Start reading now from where we left
+		while (idxadj > 0) {        // off...
+			idxadj -= sizeof(struct dirent)+
+				  strlen(dirEnts[i].name);
+			i++;
+		}
+
+		if (idxadj < 0) {    // We should end up with exactly 0.
+			printf("Alert!  Readdir can't resume in the middle "
+			       "of a directory!  stopage.\n");
+			goto full;
+		}
+	}
+
+        for (; i < dirEntSeq->_length; i++) {
+                int myinode  = dirEnts[i].inode;
+                char *myname = dirEnts[i].name;
+		int namelen = strlen(myname);
+
+                if (filldir(data, myname, namelen, offset, myinode, d_type))
+                        goto full;
+                offset += sizeof(struct dirent)+namelen;
+        }
+
+ full:
+        file->f_pos = offset;
+	return 0;
+}
+
+static int corbafs_statfs(struct super_block *sb, struct statfs *buf) {
+	buf->f_type = CORBAFS_MAGIC;
+	buf->f_bsize = PAGE_CACHE_SIZE;
+	buf->f_namelen = 255;
+	return 0;
+}
+
+/*
+ * Lookup the data. Most of the grunt work is done by corbafs_get_inode.
+ */
+static struct dentry *corbafs_lookup(struct inode *dir, struct dentry *dentry)
+{
+        struct inode *New;
+        char *Path, *Page = (char *)__get_free_page(GFP_KERNEL);
+        if (Page == 0) goto out;   /* nomem? */
+
+        Path = d_local_path(dentry, Page, PAGE_SIZE);
+
+        New = corbafs_get_inode(dir->i_sb, Path);
+        free_page((unsigned long)Page);
+
+        if (New) {
+                d_add(dentry, New);
+                return 0;
+        }
+
+out:
+	d_add(dentry, NULL);
+	return 0;
+}
+
+
+static char *corbafs_read_a_link(struct dentry *dentry) {
+        char *path, *page, *s = 0;
+        struct super_block *sb = dentry->d_sb;
+        CorbaFS_FileSystem fs_client;
+        
+        page = (char *)__get_free_page(GFP_KERNEL);
+        if (page == 0) goto out;   /* nomem? */
+
+        path = d_local_path(dentry, page, PAGE_SIZE);
+
+        fs_client = sb->u.generic_sbp;
+//        printk("\n \n  \nCorbaFS_FileSystem_readlink(%s)\n", path);
+        s = CorbaFS_FileSystem_readlink(fs_client, path, ev);
+//        printk("CorbaFS_FileSystem_readlink = %s\n \n  \n   \n", s);
+
+        if (ev->_major != CORBA_NO_EXCEPTION) {
+		if (s) {
+			// CORBA_string_free(s,..);
+			s = 0;
+		}
+                goto outfree;
+	}
+ outfree:
+        free_page((unsigned long)page);
+ out:
+	return s;
+}
+
+
+static int corbafs_readlink(struct dentry *dentry, char *buffer, int buflen) {
+	char *str = corbafs_read_a_link(dentry);
+	int error = -EINVAL;
+
+	if (str) {
+		error = vfs_readlink(dentry, buffer, buflen, str);
+		// TODO: CORBA_string__free the string str.
+	}
+	return error;
+}
+
+/* Fill in nd->dentry
+ */
+static int corbafs_followlink(struct dentry *link, struct nameidata *nd) {
+        int Error = -ENOMEM;
+        char *Path = corbafs_read_a_link(link);
+	if (!Path) goto out;
+
+#if 1
+        printk("Followlink: %s\n", Path);
+#endif
+        Error = vfs_follow_link(nd, Path);
+	// TODO: CORBA_string__free the string str.
+
+ out:
+	return Error;
+}
+
+static void corbafs_delete_inode(struct inode *inode) {
+        CorbaFS_Inode Inode = inode->u.generic_ip;
+//        printk("\n \n  \nCorbaFS_Inode_Release\n");
+        CorbaFS_Inode_release(Inode, ev);
+//        printk("CorbaFS_Inode_Release done\n \n  \n   \n");
+}
+
+static void corbafs_put_super(struct super_block *sb) {
+//	MOD_DEC_USE_COUNT;
+}
+
+static struct super_block *corbafs_read_super(struct super_block * sb, void * data, int silent) {
+	struct dentry *root = 0;
+        struct inode  *root_inode = 0;
+        
+        CorbaFS_FileSystem fs_client;
+        
+	sb->s_blocksize      = PAGE_CACHE_SIZE;
+	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+	sb->s_magic          = CORBAFS_MAGIC;
+	sb->s_op             = &corbafs_ops;
+
+//printk("corbafs_read_super: '%s'\n", (char*)data);
+
+	// Note that the CORBA IOR is now in *data
+        fs_client = CORBA_ORB_string_to_object(orb, data, ev);
+
+//printk("fs_client: 0x%X\n", fs_client);
+        if (!fs_client) 
+                return NULL;
+
+	sb->u.generic_sbp = fs_client;
+
+        root_inode = corbafs_get_inode(sb, "/");
+//printk("root_inode = 0x%X\n", root_inode);
+	root = d_alloc_root(root_inode);
+	if (!root) {
+		iput(root_inode);
+		return NULL;
+	}
+	sb->s_root = root;
+
+//        MOD_INC_USE_COUNT;
+	return sb;
+}
+
+static DECLARE_FSTYPE(corbafs_fs_type, "corbafs", corbafs_read_super, 0);
+
+static int __init init_corbafs_fs(void) {
+	int argc = 1;
+	char *argv[] = { "client", 0 };
+	ev = g_new0(CORBA_Environment,1);
+	orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", ev);
+		
+	return register_filesystem(&corbafs_fs_type);
+}
+
+static void __exit exit_corbafs_fs(void)
+{
+	// remove object from orb.
+	printf("\n \n  \nCorbaFS_exit()\n");
+	unregister_filesystem(&corbafs_fs_type);
+	CORBA_Object_release((CORBA_Object)orb, ev);
+}
+
+module_init(init_corbafs_fs)
+module_exit(exit_corbafs_fs)
+
+/*
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-common.c linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-common.c
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-common.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-common.c	Thu Feb  1 16:36:08 2001
@@ -0,0 +1,370 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <string.h>
+#include "CorbaFS.h"
+
+#if ( (TC_IMPL_TC_CorbaFS_dirent_0 == 'C') \
+&& (TC_IMPL_TC_CorbaFS_dirent_1 == 'o') \
+&& (TC_IMPL_TC_CorbaFS_dirent_2 == 'r') \
+&& (TC_IMPL_TC_CorbaFS_dirent_3 == 'b') \
+&& (TC_IMPL_TC_CorbaFS_dirent_4 == 'a') \
+&& (TC_IMPL_TC_CorbaFS_dirent_5 == 'F') \
+&& (TC_IMPL_TC_CorbaFS_dirent_6 == 'S') \
+) && !defined(TC_DEF_TC_CorbaFS_dirent)
+#define TC_DEF_TC_CorbaFS_dirent 1
+static const char *anon_subnames_array1[] = { "inode", "name" };
+static const CORBA_TypeCode anon_subtypes_array2[] =
+   { (CORBA_TypeCode) & TC_CORBA_long_struct,
+      (CORBA_TypeCode) & TC_CORBA_string_struct };
+const struct CORBA_TypeCode_struct TC_CorbaFS_dirent_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_struct, "dirent", "IDL:CorbaFS/dirent:1.0",
+   0, 2,
+   (const char **) anon_subnames_array1,
+   (CORBA_TypeCode *) anon_subtypes_array2,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_0 == 'C') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_1 == 'o') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_2 == 'r') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_3 == 'b') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_4 == 'a') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_5 == 'F') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_6 == 'S') \
+) && !defined(TC_DEF_TC_CORBA_sequence_CorbaFS_dirent)
+#define TC_DEF_TC_CORBA_sequence_CorbaFS_dirent 1
+static const CORBA_TypeCode anon_subtypes_array6[] =
+   { (CORBA_TypeCode) & TC_CorbaFS_dirent_struct };
+const struct CORBA_TypeCode_struct TC_CORBA_sequence_CorbaFS_dirent_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_sequence, NULL, NULL,
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array6,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_0 == 'C') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_1 == 'o') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_2 == 'r') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_3 == 'b') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_4 == 'a') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_5 == 'F') \
+&& (TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_6 == 'S') \
+) && !defined(TC_DEF_TC_CORBA_sequence_CorbaFS_dirent)
+#define TC_DEF_TC_CORBA_sequence_CorbaFS_dirent 1
+static const CORBA_TypeCode anon_subtypes_array15[] =
+   { (CORBA_TypeCode) & TC_CorbaFS_dirent_struct };
+const struct CORBA_TypeCode_struct TC_CORBA_sequence_CorbaFS_dirent_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_sequence, NULL, NULL,
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array15,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CorbaFS_DirEntSeq_0 == 'C') \
+&& (TC_IMPL_TC_CorbaFS_DirEntSeq_1 == 'o') \
+&& (TC_IMPL_TC_CorbaFS_DirEntSeq_2 == 'r') \
+&& (TC_IMPL_TC_CorbaFS_DirEntSeq_3 == 'b') \
+&& (TC_IMPL_TC_CorbaFS_DirEntSeq_4 == 'a') \
+&& (TC_IMPL_TC_CorbaFS_DirEntSeq_5 == 'F') \
+&& (TC_IMPL_TC_CorbaFS_DirEntSeq_6 == 'S') \
+) && !defined(TC_DEF_TC_CorbaFS_DirEntSeq)
+#define TC_DEF_TC_CorbaFS_DirEntSeq 1
+static const CORBA_TypeCode anon_subtypes_array19[] =
+   { (CORBA_TypeCode) & TC_CORBA_sequence_CorbaFS_dirent_struct };
+const struct CORBA_TypeCode_struct TC_CorbaFS_DirEntSeq_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_alias, "DirEntSeq", "IDL:CorbaFS/DirEntSeq:1.0",
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array19,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CORBA_sequence_CORBA_octet_0 == 'C') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_1 == 'o') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_2 == 'r') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_3 == 'b') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_4 == 'a') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_5 == 'F') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_6 == 'S') \
+) && !defined(TC_DEF_TC_CORBA_sequence_CORBA_octet)
+#define TC_DEF_TC_CORBA_sequence_CORBA_octet 1
+static const CORBA_TypeCode anon_subtypes_array23[] =
+   { (CORBA_TypeCode) & TC_CORBA_octet_struct };
+const struct CORBA_TypeCode_struct TC_CORBA_sequence_CORBA_octet_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_sequence, NULL, NULL,
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array23,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CORBA_sequence_CORBA_octet_0 == 'C') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_1 == 'o') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_2 == 'r') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_3 == 'b') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_4 == 'a') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_5 == 'F') \
+&& (TC_IMPL_TC_CORBA_sequence_CORBA_octet_6 == 'S') \
+) && !defined(TC_DEF_TC_CORBA_sequence_CORBA_octet)
+#define TC_DEF_TC_CORBA_sequence_CORBA_octet 1
+static const CORBA_TypeCode anon_subtypes_array32[] =
+   { (CORBA_TypeCode) & TC_CORBA_octet_struct };
+const struct CORBA_TypeCode_struct TC_CORBA_sequence_CORBA_octet_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_sequence, NULL, NULL,
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array32,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CorbaFS_Buffer_0 == 'C') \
+&& (TC_IMPL_TC_CorbaFS_Buffer_1 == 'o') \
+&& (TC_IMPL_TC_CorbaFS_Buffer_2 == 'r') \
+&& (TC_IMPL_TC_CorbaFS_Buffer_3 == 'b') \
+&& (TC_IMPL_TC_CorbaFS_Buffer_4 == 'a') \
+&& (TC_IMPL_TC_CorbaFS_Buffer_5 == 'F') \
+&& (TC_IMPL_TC_CorbaFS_Buffer_6 == 'S') \
+) && !defined(TC_DEF_TC_CorbaFS_Buffer)
+#define TC_DEF_TC_CorbaFS_Buffer 1
+static const CORBA_TypeCode anon_subtypes_array36[] =
+   { (CORBA_TypeCode) & TC_CORBA_sequence_CORBA_octet_struct };
+const struct CORBA_TypeCode_struct TC_CorbaFS_Buffer_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_alias, "Buffer", "IDL:CorbaFS/Buffer:1.0",
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array36,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CorbaFS_Inode_0 == 'C') \
+&& (TC_IMPL_TC_CorbaFS_Inode_1 == 'o') \
+&& (TC_IMPL_TC_CorbaFS_Inode_2 == 'r') \
+&& (TC_IMPL_TC_CorbaFS_Inode_3 == 'b') \
+&& (TC_IMPL_TC_CorbaFS_Inode_4 == 'a') \
+&& (TC_IMPL_TC_CorbaFS_Inode_5 == 'F') \
+&& (TC_IMPL_TC_CorbaFS_Inode_6 == 'S') \
+) && !defined(TC_DEF_TC_CorbaFS_Inode)
+#define TC_DEF_TC_CorbaFS_Inode 1
+const struct CORBA_TypeCode_struct TC_CorbaFS_Inode_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_objref, "Inode", "IDL:CorbaFS/Inode:1.0",
+   0, 0,
+   NULL,
+   NULL,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+#if ( (TC_IMPL_TC_CorbaFS_FileSystem_0 == 'C') \
+&& (TC_IMPL_TC_CorbaFS_FileSystem_1 == 'o') \
+&& (TC_IMPL_TC_CorbaFS_FileSystem_2 == 'r') \
+&& (TC_IMPL_TC_CorbaFS_FileSystem_3 == 'b') \
+&& (TC_IMPL_TC_CorbaFS_FileSystem_4 == 'a') \
+&& (TC_IMPL_TC_CorbaFS_FileSystem_5 == 'F') \
+&& (TC_IMPL_TC_CorbaFS_FileSystem_6 == 'S') \
+) && !defined(TC_DEF_TC_CorbaFS_FileSystem)
+#define TC_DEF_TC_CorbaFS_FileSystem 1
+const struct CORBA_TypeCode_struct TC_CorbaFS_FileSystem_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_objref, "FileSystem", "IDL:CorbaFS/FileSystem:1.0",
+   0, 0,
+   NULL,
+   NULL,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+gpointer
+CorbaFS_dirent__free(gpointer mem, gpointer dat, CORBA_boolean free_strings)
+{
+   CorbaFS_dirent *var = mem;
+
+   if (free_strings) {
+      CORBA_string__free(&(var->name), NULL, free_strings);
+   }
+   return (gpointer) (var + 1);
+}
+
+CorbaFS_dirent *
+CorbaFS_dirent__alloc(void)
+{
+   CorbaFS_dirent *retval;
+
+   retval =
+      ORBit_alloc(sizeof(CorbaFS_dirent),
+		  (ORBit_free_childvals) CorbaFS_dirent__free,
+		  GUINT_TO_POINTER(1));
+   memset(&(retval->name), '\0', sizeof(retval->name));
+   return retval;
+}
+
+#if ( (ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_0 == 'C') \
+&& (ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_1 == 'o') \
+&& (ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_2 == 'r') \
+&& (ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_3 == 'b') \
+&& (ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_4 == 'a') \
+&& (ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_5 == 'F') \
+&& (ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_6 == 'S') \
+) && !defined(ORBIT_DEF_CORBA_sequence_CorbaFS_dirent)
+#define ORBIT_DEF_CORBA_sequence_CorbaFS_dirent 1
+
+gpointer
+CORBA_sequence_CorbaFS_dirent__free(gpointer mem, gpointer dat,
+				    CORBA_boolean free_strings)
+{
+   CORBA_sequence_CorbaFS_dirent *val = mem;
+
+   if (val->_release)
+      ORBit_free(val->_buffer, free_strings);
+   return (gpointer) (val + 1);
+}
+
+CORBA_sequence_CorbaFS_dirent *
+CORBA_sequence_CorbaFS_dirent__alloc(void)
+{
+   CORBA_sequence_CorbaFS_dirent *retval;
+
+   retval =
+      ORBit_alloc(sizeof(CORBA_sequence_CorbaFS_dirent),
+		  (ORBit_free_childvals) CORBA_sequence_CorbaFS_dirent__free,
+		  GUINT_TO_POINTER(1));
+   retval->_maximum = 0;
+   retval->_length = 0;
+   retval->_buffer = NULL;
+   retval->_release = CORBA_FALSE;
+   return retval;
+}
+
+CorbaFS_dirent *
+CORBA_sequence_CorbaFS_dirent_allocbuf(CORBA_unsigned_long len)
+{
+   CorbaFS_dirent *retval =
+      ORBit_alloc(sizeof(CorbaFS_dirent) * len,
+		  (ORBit_free_childvals) CorbaFS_dirent__free,
+		  GUINT_TO_POINTER(len));
+
+   memset(retval, '\0', sizeof(CorbaFS_dirent) * len);
+   return retval;
+}
+#endif
+
+gpointer
+CorbaFS_DirEntSeq__free(gpointer mem, gpointer dat,
+			CORBA_boolean free_strings)
+{
+   return CORBA_sequence_CorbaFS_dirent__free(mem, dat, free_strings);
+}
+
+CorbaFS_DirEntSeq *
+CorbaFS_DirEntSeq__alloc(void)
+{
+   return CORBA_sequence_CorbaFS_dirent__alloc();
+}
+
+#if ( (ORBIT_IMPL_CORBA_sequence_CORBA_octet_0 == 'C') \
+&& (ORBIT_IMPL_CORBA_sequence_CORBA_octet_1 == 'o') \
+&& (ORBIT_IMPL_CORBA_sequence_CORBA_octet_2 == 'r') \
+&& (ORBIT_IMPL_CORBA_sequence_CORBA_octet_3 == 'b') \
+&& (ORBIT_IMPL_CORBA_sequence_CORBA_octet_4 == 'a') \
+&& (ORBIT_IMPL_CORBA_sequence_CORBA_octet_5 == 'F') \
+&& (ORBIT_IMPL_CORBA_sequence_CORBA_octet_6 == 'S') \
+) && !defined(ORBIT_DEF_CORBA_sequence_CORBA_octet)
+#define ORBIT_DEF_CORBA_sequence_CORBA_octet 1
+
+gpointer
+CORBA_sequence_CORBA_octet__free(gpointer mem, gpointer dat,
+				 CORBA_boolean free_strings)
+{
+   CORBA_sequence_CORBA_octet *val = mem;
+
+   if (val->_release)
+      ORBit_free(val->_buffer, free_strings);
+   return (gpointer) (val + 1);
+}
+
+CORBA_sequence_CORBA_octet *
+CORBA_sequence_CORBA_octet__alloc(void)
+{
+   CORBA_sequence_CORBA_octet *retval;
+
+   retval =
+      ORBit_alloc(sizeof(CORBA_sequence_CORBA_octet),
+		  (ORBit_free_childvals) CORBA_sequence_CORBA_octet__free,
+		  GUINT_TO_POINTER(1));
+   retval->_maximum = 0;
+   retval->_length = 0;
+   retval->_buffer = NULL;
+   retval->_release = CORBA_FALSE;
+   return retval;
+}
+
+CORBA_octet *
+CORBA_sequence_CORBA_octet_allocbuf(CORBA_unsigned_long len)
+{
+   CORBA_octet *retval =
+      ORBit_alloc(sizeof(CORBA_octet) * len, (ORBit_free_childvals) NULL,
+		  GUINT_TO_POINTER(len));
+
+   return retval;
+}
+#endif
+
+gpointer
+CorbaFS_Buffer__free(gpointer mem, gpointer dat, CORBA_boolean free_strings)
+{
+   return CORBA_sequence_CORBA_octet__free(mem, dat, free_strings);
+}
+
+CorbaFS_Buffer *
+CorbaFS_Buffer__alloc(void)
+{
+   return CORBA_sequence_CORBA_octet__alloc();
+}
+
+CORBA_unsigned_long CorbaFS_Inode__classid = 0;
+CORBA_unsigned_long CorbaFS_FileSystem__classid = 0;
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-stubs.c linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-stubs.c
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-stubs.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-stubs.c	Thu Feb  1 16:36:08 2001
@@ -0,0 +1,791 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <string.h>
+#include "CorbaFS.h"
+
+void
+CorbaFS_Inode_getStatus(CorbaFS_Inode _obj, CORBA_unsigned_short * mode,
+			CORBA_unsigned_long * uid, CORBA_unsigned_long * gid,
+			CORBA_unsigned_long * size,
+			CORBA_unsigned_long * inodeNum,
+			CORBA_unsigned_short * numLinks, CORBA_long * atime,
+			CORBA_long * mtime, CORBA_long * ctime,
+			CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+
+   if (_obj->servant && _obj->vepv && CorbaFS_Inode__classid) {
+      
+	 ((POA_CorbaFS_Inode__epv *) _obj->vepv[CorbaFS_Inode__classid])->
+	 getStatus(_obj->servant, mode, uid, gid, size, inodeNum, numLinks,
+		   atime, mtime, ctime, ev);
+      return;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[10];
+      }
+      _ORBIT_operation_name_data =
+      {
+      10, "getStatus"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 14 };
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
+	 
+	    (*((guint16 *) & ((*mode)))) =
+	    GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 2;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & ((*uid)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	 (*((guint32 *) & ((*gid)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	 (*((guint32 *) & ((*size)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	 (*((guint32 *) & ((*inodeNum)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	 (*((guint16 *) & ((*numLinks)))) =
+	    GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 2;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & ((*atime)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	 (*((guint32 *) & ((*mtime)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	 (*((guint32 *) & ((*ctime)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));} else {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
+	 (*mode) = *((CORBA_unsigned_short *) _ORBIT_curptr);
+	 _ORBIT_curptr += 2;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 (*uid) = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 (*gid) = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 (*size) = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 (*inodeNum) = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 (*numLinks) = *((CORBA_unsigned_short *) _ORBIT_curptr);
+	 _ORBIT_curptr += 2;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 (*atime) = *((CORBA_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 (*mtime) = *((CORBA_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 (*ctime) = *((CORBA_long *) _ORBIT_curptr);
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return;
+      }
+   }
+}
+void
+CorbaFS_Inode_readpage(CorbaFS_Inode _obj, CorbaFS_Buffer ** buffer,
+		       const CORBA_long size, const CORBA_long offset,
+		       CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+   register CORBA_unsigned_long _ORBIT_tmpvar_1;
+
+   if (_obj->servant && _obj->vepv && CorbaFS_Inode__classid) {
+      
+	 ((POA_CorbaFS_Inode__epv *) _obj->vepv[CorbaFS_Inode__classid])->
+	 readpage(_obj->servant, buffer, size, offset, ev);
+      return;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[9];
+      }
+      _ORBIT_operation_name_data =
+      {
+      9, "readpage"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 13 };
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
+				       (_ORBIT_send_buffer), 4);
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
+				     &(size), sizeof(size));
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
+				     &(offset), sizeof(offset));
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      *buffer = CorbaFS_Buffer__alloc();
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & (((**buffer))._length))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	 _ORBIT_curptr += 4;
+	 
+	    ((**buffer))._buffer =
+	    CORBA_sequence_CORBA_octet_allocbuf(((**buffer))._length);
+	 ((**buffer))._release = CORBA_TRUE;
+	 memcpy(((**buffer))._buffer, _ORBIT_curptr,
+		sizeof(((**buffer))._buffer[_ORBIT_tmpvar_1]) *
+		((**buffer))._length);
+	 _ORBIT_curptr +=
+	    sizeof(((**buffer))._buffer[_ORBIT_tmpvar_1]) *
+	    ((**buffer))._length;
+      } else {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 ((**buffer))._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 
+	    ((**buffer))._buffer =
+	    CORBA_sequence_CORBA_octet_allocbuf(((**buffer))._length);
+	 ((**buffer))._release = CORBA_TRUE;
+	 memcpy(((**buffer))._buffer, _ORBIT_curptr,
+		sizeof(((**buffer))._buffer[_ORBIT_tmpvar_1]) *
+		((**buffer))._length);
+	 _ORBIT_curptr +=
+	    sizeof(((**buffer))._buffer[_ORBIT_tmpvar_1]) *
+	    ((**buffer))._length;
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return;
+      }
+   }
+}
+void
+CorbaFS_Inode_release(CorbaFS_Inode _obj, CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+
+   if (_obj->servant && _obj->vepv && CorbaFS_Inode__classid) {
+      
+	 ((POA_CorbaFS_Inode__epv *) _obj->vepv[CorbaFS_Inode__classid])->
+	 release(_obj->servant, ev);
+      return;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[8];
+      }
+      _ORBIT_operation_name_data =
+      {
+      8, "release"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 12 };
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+      } else {
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return;
+      }
+   }
+}
+CorbaFS_Inode
+CorbaFS_FileSystem_getInode(CorbaFS_FileSystem _obj, const CORBA_char * path,
+			    CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+   CorbaFS_Inode _ORBIT_retval;
+
+   if (_obj->servant && _obj->vepv && CorbaFS_FileSystem__classid) {
+      _ORBIT_retval =
+	 ((POA_CorbaFS_FileSystem__epv *) _obj->
+	  vepv[CorbaFS_FileSystem__classid])->getInode(_obj->servant, path,
+						       ev);
+      return _ORBIT_retval;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[9];
+      }
+      _ORBIT_operation_name_data =
+      {
+      9, "getInode"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 13 };
+      register CORBA_unsigned_long _ORBIT_tmpvar_0;
+      CORBA_unsigned_long _ORBIT_tmpvar_1;
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_tmpvar_1 = strlen(path) + 1;
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
+				       (_ORBIT_send_buffer), 4);
+      {
+	 guchar *_ORBIT_t;
+
+	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
+	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
+	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
+					(_ORBIT_send_buffer), (_ORBIT_t),
+					sizeof(_ORBIT_tmpvar_1));
+      }
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
+				     (path),
+				     sizeof(path[_ORBIT_tmpvar_0]) *
+				     _ORBIT_tmpvar_1);
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
+	 _ORBIT_retval =
+	    ORBit_demarshal_object(_ORBIT_recv_buffer,
+				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
+				   connection->orb_data);
+	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      } else {
+	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
+	 _ORBIT_retval =
+	    ORBit_demarshal_object(_ORBIT_recv_buffer,
+				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
+				   connection->orb_data);
+	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return _ORBIT_retval;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return _ORBIT_retval;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return _ORBIT_retval;
+      }
+   }
+}
+CorbaFS_DirEntSeq *
+CorbaFS_FileSystem_readdir(CorbaFS_FileSystem _obj, const CORBA_char * path,
+			   CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+   CorbaFS_DirEntSeq *_ORBIT_retval;
+   register CORBA_unsigned_long _ORBIT_tmpvar_5;
+   register CORBA_unsigned_long _ORBIT_tmpvar_6;
+   CORBA_unsigned_long _ORBIT_tmpvar_7;
+
+   if (_obj->servant && _obj->vepv && CorbaFS_FileSystem__classid) {
+      _ORBIT_retval =
+	 ((POA_CorbaFS_FileSystem__epv *) _obj->
+	  vepv[CorbaFS_FileSystem__classid])->readdir(_obj->servant, path,
+						      ev);
+      return _ORBIT_retval;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[8];
+      }
+      _ORBIT_operation_name_data =
+      {
+      8, "readdir"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 12 };
+      register CORBA_unsigned_long _ORBIT_tmpvar_0;
+      CORBA_unsigned_long _ORBIT_tmpvar_1;
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_tmpvar_1 = strlen(path) + 1;
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
+				       (_ORBIT_send_buffer), 4);
+      {
+	 guchar *_ORBIT_t;
+
+	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
+	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
+	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
+					(_ORBIT_send_buffer), (_ORBIT_t),
+					sizeof(_ORBIT_tmpvar_1));
+      }
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
+				     (path),
+				     sizeof(path[_ORBIT_tmpvar_0]) *
+				     _ORBIT_tmpvar_1);
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      _ORBIT_retval = CorbaFS_DirEntSeq__alloc();
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & ((*_ORBIT_retval)._length))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	 _ORBIT_curptr += 4;
+	 
+	    (*_ORBIT_retval)._buffer =
+	    CORBA_sequence_CorbaFS_dirent_allocbuf((*_ORBIT_retval)._length);
+	 (*_ORBIT_retval)._release = CORBA_TRUE;
+	 for (_ORBIT_tmpvar_5 = 0; _ORBIT_tmpvar_5 < (*_ORBIT_retval)._length;
+	      _ORBIT_tmpvar_5++) {
+	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	    
+	       (*
+	     ((guint32 *) &
+	   ((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].inode))) =
+GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	    
+	       (*((guint32 *) & (_ORBIT_tmpvar_7))) =
+	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	    _ORBIT_curptr += 4;
+	    
+	       (*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].name =
+	       CORBA_string_alloc(_ORBIT_tmpvar_7);
+	    memcpy((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].name,
+		   _ORBIT_curptr,
+		   sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].
+			  name[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7);
+	    _ORBIT_curptr +=
+	       sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].
+		      name[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7;
+	 }
+
+      } else {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 (*_ORBIT_retval)._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 
+	    (*_ORBIT_retval)._buffer =
+	    CORBA_sequence_CorbaFS_dirent_allocbuf((*_ORBIT_retval)._length);
+	 (*_ORBIT_retval)._release = CORBA_TRUE;
+	 for (_ORBIT_tmpvar_5 = 0; _ORBIT_tmpvar_5 < (*_ORBIT_retval)._length;
+	      _ORBIT_tmpvar_5++) {
+	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	    (*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].inode = *((CORBA_long *) _ORBIT_curptr);
+	    _ORBIT_curptr += 4;
+	    _ORBIT_tmpvar_7 = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	    _ORBIT_curptr += 4;
+	    
+	       (*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].name =
+	       CORBA_string_alloc(_ORBIT_tmpvar_7);
+	    memcpy((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].name,
+		   _ORBIT_curptr,
+		   sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].
+			  name[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7);
+	    _ORBIT_curptr +=
+	       sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_5].
+		      name[_ORBIT_tmpvar_6]) * _ORBIT_tmpvar_7;
+	 }
+
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return _ORBIT_retval;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return _ORBIT_retval;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return _ORBIT_retval;
+      }
+   }
+}
+CORBA_char *
+CorbaFS_FileSystem_readlink(CorbaFS_FileSystem _obj,
+			    const CORBA_char * filename,
+			    CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+   CORBA_char *_ORBIT_retval;
+   register CORBA_unsigned_long _ORBIT_tmpvar_4;
+   CORBA_unsigned_long _ORBIT_tmpvar_5;
+
+   if (_obj->servant && _obj->vepv && CorbaFS_FileSystem__classid) {
+      _ORBIT_retval =
+	 ((POA_CorbaFS_FileSystem__epv *) _obj->
+	  vepv[CorbaFS_FileSystem__classid])->readlink(_obj->servant,
+						       filename, ev);
+      return _ORBIT_retval;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[9];
+      }
+      _ORBIT_operation_name_data =
+      {
+      9, "readlink"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 13 };
+      register CORBA_unsigned_long _ORBIT_tmpvar_0;
+      CORBA_unsigned_long _ORBIT_tmpvar_1;
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_tmpvar_1 = strlen(filename) + 1;
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
+				       (_ORBIT_send_buffer), 4);
+      {
+	 guchar *_ORBIT_t;
+
+	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
+	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
+	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
+					(_ORBIT_send_buffer), (_ORBIT_t),
+					sizeof(_ORBIT_tmpvar_1));
+      }
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
+				     (filename),
+				     sizeof(filename[_ORBIT_tmpvar_0]) *
+				     _ORBIT_tmpvar_1);
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & (_ORBIT_tmpvar_5))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	 _ORBIT_curptr += 4;
+	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_5);
+	 memcpy(_ORBIT_retval, _ORBIT_curptr,
+		sizeof(_ORBIT_retval[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5);
+	 _ORBIT_curptr +=
+	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5;
+      } else {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 _ORBIT_tmpvar_5 = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_5);
+	 memcpy(_ORBIT_retval, _ORBIT_curptr,
+		sizeof(_ORBIT_retval[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5);
+	 _ORBIT_curptr +=
+	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5;
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return _ORBIT_retval;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return _ORBIT_retval;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return _ORBIT_retval;
+      }
+   }
+}
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-user-client.c linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-user-client.c
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS-user-client.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS-user-client.c	Thu Feb  1 11:47:03 2001
@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <orb/orbit.h>
+
+#include "CorbaFS.h"
+
+CorbaFS_FileSystem fs;
+
+int
+main (int argc, char *argv[])
+{
+    CORBA_Environment ev;
+    CORBA_ORB orb;
+    CorbaFS_Inode inode;
+    CorbaFS_Buffer *buffer;
+    CorbaFS_DirEntSeq *dirents;
+    CorbaFS_dirent *dirent;
+    
+    CORBA_unsigned_short mode;
+    CORBA_unsigned_long uid;
+    CORBA_unsigned_long gid;
+    CORBA_unsigned_long size;
+    CORBA_unsigned_long inodeNum;
+    CORBA_unsigned_short numLinks;
+    CORBA_long atime;
+    CORBA_long mtime;
+    CORBA_long ctime;
+    
+    int i;
+    
+    int niters = 10;
+
+    CORBA_exception_init(&ev);
+    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);
+
+    if(argc < 2)
+      {
+	printf("Need a binding ID thing as argv[1]\n");
+	return 1;
+      }
+
+
+    fs = CORBA_ORB_string_to_object(orb, argv[1], &ev);
+    if (!fs) {
+	printf("Cannot bind to %s\n", argv[1]);
+	return 1;
+    }
+    
+    if (argc >= 3)
+            inode = CorbaFS_FileSystem_getInode(fs, argv[2], &ev);
+    else
+            inode = CorbaFS_FileSystem_getInode(fs, "/proc/cpuinfo", &ev);
+    
+    if (!inode)
+    {
+            printf("Cannot get inode\n");
+    }
+
+    CorbaFS_Inode_getStatus(inode, 
+                            &mode,
+                            &uid,
+                            &gid,
+                            &size,
+                            &inodeNum,
+                            &numLinks,
+                            &atime,
+                            &mtime,
+                            &ctime,
+                            &ev);
+    
+    printf("inode = %x\n", inode);
+    CorbaFS_Inode_readpage(inode, &buffer, 1000, 100, &ev);
+    printf("readpage got %d bytes\n", buffer->_length);
+    printf("readpage returned : %s\n", buffer->_buffer);
+
+    if (argc >= 3)
+            dirents = CorbaFS_FileSystem_readdir(fs, argv[2], &ev);
+    else
+            dirents = CorbaFS_FileSystem_readdir(fs, "/", &ev);
+
+    dirent = dirents->_buffer;
+    for (i = 0; i < dirents->_length; i++)
+    {
+            printf("%d = %s\n", dirent->inode, dirent->name);
+            dirent++;
+    }
+    
+    CORBA_Object_release(fs, &ev);
+    CORBA_Object_release((CORBA_Object)orb, &ev);
+
+    return 0;
+}
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS.h linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS.h
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/CorbaFS.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/CorbaFS.h	Thu Feb  1 16:36:08 2001
@@ -0,0 +1,349 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <glib.h>
+#define ORBIT_IDL_SERIAL 9
+#include <orb/orbit.h>
+
+#ifndef CorbaFS_H
+#define CorbaFS_H 1
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/** typedefs **/
+#if !defined(_CorbaFS_dirent_defined)
+#define _CorbaFS_dirent_defined 1
+   typedef struct
+   {
+      CORBA_long inode;
+      CORBA_char *name;
+   }
+   CorbaFS_dirent;
+
+#if !defined(TC_IMPL_TC_CorbaFS_dirent_0)
+#define TC_IMPL_TC_CorbaFS_dirent_0 'C'
+#define TC_IMPL_TC_CorbaFS_dirent_1 'o'
+#define TC_IMPL_TC_CorbaFS_dirent_2 'r'
+#define TC_IMPL_TC_CorbaFS_dirent_3 'b'
+#define TC_IMPL_TC_CorbaFS_dirent_4 'a'
+#define TC_IMPL_TC_CorbaFS_dirent_5 'F'
+#define TC_IMPL_TC_CorbaFS_dirent_6 'S'
+   extern const struct CORBA_TypeCode_struct TC_CorbaFS_dirent_struct;
+#define TC_CorbaFS_dirent ((CORBA_TypeCode)&TC_CorbaFS_dirent_struct)
+#endif
+   extern CorbaFS_dirent *CorbaFS_dirent__alloc(void);
+   extern gpointer CorbaFS_dirent__free(gpointer mem, gpointer dat,
+					CORBA_boolean free_strings);	/* ORBit internal use */
+#endif
+#if !defined(ORBIT_DECL_CORBA_sequence_CorbaFS_dirent) && !defined(_CORBA_sequence_CorbaFS_dirent_defined)
+#define ORBIT_DECL_CORBA_sequence_CorbaFS_dirent 1
+#define _CORBA_sequence_CorbaFS_dirent_defined 1
+#define ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_0 'C'
+#define ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_1 'o'
+#define ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_2 'r'
+#define ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_3 'b'
+#define ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_4 'a'
+#define ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_5 'F'
+#define ORBIT_IMPL_CORBA_sequence_CorbaFS_dirent_6 'S'
+   typedef struct
+   {
+      CORBA_unsigned_long _maximum,
+       _length;
+      CorbaFS_dirent *_buffer;
+      CORBA_boolean _release;
+   }
+   CORBA_sequence_CorbaFS_dirent;
+#if !defined(TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_0)
+#define TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_0 'C'
+#define TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_1 'o'
+#define TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_2 'r'
+#define TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_3 'b'
+#define TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_4 'a'
+#define TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_5 'F'
+#define TC_IMPL_TC_CORBA_sequence_CorbaFS_dirent_6 'S'
+   extern const struct CORBA_TypeCode_struct
+      TC_CORBA_sequence_CorbaFS_dirent_struct;
+#define TC_CORBA_sequence_CorbaFS_dirent ((CORBA_TypeCode)&TC_CORBA_sequence_CorbaFS_dirent_struct)
+#endif
+   extern CORBA_sequence_CorbaFS_dirent
+      *CORBA_sequence_CorbaFS_dirent__alloc(void);
+   extern gpointer CORBA_sequence_CorbaFS_dirent__free(gpointer mem,
+						       gpointer dat,
+						       CORBA_boolean free_strings);	/* ORBit internal use */
+   CorbaFS_dirent *CORBA_sequence_CorbaFS_dirent_allocbuf(CORBA_unsigned_long
+							  len);
+#endif
+#if !defined(_CorbaFS_DirEntSeq_defined)
+#define _CorbaFS_DirEntSeq_defined 1
+   typedef CORBA_sequence_CorbaFS_dirent CorbaFS_DirEntSeq;
+#if !defined(TC_IMPL_TC_CorbaFS_DirEntSeq_0)
+#define TC_IMPL_TC_CorbaFS_DirEntSeq_0 'C'
+#define TC_IMPL_TC_CorbaFS_DirEntSeq_1 'o'
+#define TC_IMPL_TC_CorbaFS_DirEntSeq_2 'r'
+#define TC_IMPL_TC_CorbaFS_DirEntSeq_3 'b'
+#define TC_IMPL_TC_CorbaFS_DirEntSeq_4 'a'
+#define TC_IMPL_TC_CorbaFS_DirEntSeq_5 'F'
+#define TC_IMPL_TC_CorbaFS_DirEntSeq_6 'S'
+   extern const struct CORBA_TypeCode_struct TC_CorbaFS_DirEntSeq_struct;
+#define TC_CorbaFS_DirEntSeq ((CORBA_TypeCode)&TC_CorbaFS_DirEntSeq_struct)
+#endif
+   extern CorbaFS_DirEntSeq *CorbaFS_DirEntSeq__alloc(void);
+   extern gpointer CorbaFS_DirEntSeq__free(gpointer mem, gpointer dat,
+					   CORBA_boolean free_strings);	/* ORBit internal use */
+#endif
+#if !defined(ORBIT_DECL_CORBA_sequence_CORBA_octet) && !defined(_CORBA_sequence_CORBA_octet_defined)
+#define ORBIT_DECL_CORBA_sequence_CORBA_octet 1
+#define _CORBA_sequence_CORBA_octet_defined 1
+#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_0 'C'
+#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_1 'o'
+#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_2 'r'
+#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_3 'b'
+#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_4 'a'
+#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_5 'F'
+#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_6 'S'
+   typedef struct
+   {
+      CORBA_unsigned_long _maximum,
+       _length;
+      CORBA_octet *_buffer;
+      CORBA_boolean _release;
+   }
+   CORBA_sequence_CORBA_octet;
+#if !defined(TC_IMPL_TC_CORBA_sequence_CORBA_octet_0)
+#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_0 'C'
+#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_1 'o'
+#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_2 'r'
+#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_3 'b'
+#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_4 'a'
+#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_5 'F'
+#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_6 'S'
+   extern const struct CORBA_TypeCode_struct
+      TC_CORBA_sequence_CORBA_octet_struct;
+#define TC_CORBA_sequence_CORBA_octet ((CORBA_TypeCode)&TC_CORBA_sequence_CORBA_octet_struct)
+#endif
+   extern CORBA_sequence_CORBA_octet *CORBA_sequence_CORBA_octet__alloc(void);
+   extern gpointer CORBA_sequence_CORBA_octet__free(gpointer mem,
+						    gpointer dat,
+						    CORBA_boolean free_strings);	/* ORBit internal use */
+   CORBA_octet *CORBA_sequence_CORBA_octet_allocbuf(CORBA_unsigned_long len);
+#endif
+#if !defined(_CorbaFS_Buffer_defined)
+#define _CorbaFS_Buffer_defined 1
+   typedef CORBA_sequence_CORBA_octet CorbaFS_Buffer;
+#if !defined(TC_IMPL_TC_CorbaFS_Buffer_0)
+#define TC_IMPL_TC_CorbaFS_Buffer_0 'C'
+#define TC_IMPL_TC_CorbaFS_Buffer_1 'o'
+#define TC_IMPL_TC_CorbaFS_Buffer_2 'r'
+#define TC_IMPL_TC_CorbaFS_Buffer_3 'b'
+#define TC_IMPL_TC_CorbaFS_Buffer_4 'a'
+#define TC_IMPL_TC_CorbaFS_Buffer_5 'F'
+#define TC_IMPL_TC_CorbaFS_Buffer_6 'S'
+   extern const struct CORBA_TypeCode_struct TC_CorbaFS_Buffer_struct;
+#define TC_CorbaFS_Buffer ((CORBA_TypeCode)&TC_CorbaFS_Buffer_struct)
+#endif
+   extern CorbaFS_Buffer *CorbaFS_Buffer__alloc(void);
+   extern gpointer CorbaFS_Buffer__free(gpointer mem, gpointer dat,
+					CORBA_boolean free_strings);	/* ORBit internal use */
+#endif
+#if !defined(ORBIT_DECL_CorbaFS_Inode) && !defined(_CorbaFS_Inode_defined)
+#define ORBIT_DECL_CorbaFS_Inode 1
+#define _CorbaFS_Inode_defined 1
+#define CorbaFS_Inode__free CORBA_Object__free
+   typedef CORBA_Object CorbaFS_Inode;
+   extern CORBA_unsigned_long CorbaFS_Inode__classid;
+#if !defined(TC_IMPL_TC_CorbaFS_Inode_0)
+#define TC_IMPL_TC_CorbaFS_Inode_0 'C'
+#define TC_IMPL_TC_CorbaFS_Inode_1 'o'
+#define TC_IMPL_TC_CorbaFS_Inode_2 'r'
+#define TC_IMPL_TC_CorbaFS_Inode_3 'b'
+#define TC_IMPL_TC_CorbaFS_Inode_4 'a'
+#define TC_IMPL_TC_CorbaFS_Inode_5 'F'
+#define TC_IMPL_TC_CorbaFS_Inode_6 'S'
+   extern const struct CORBA_TypeCode_struct TC_CorbaFS_Inode_struct;
+#define TC_CorbaFS_Inode ((CORBA_TypeCode)&TC_CorbaFS_Inode_struct)
+#endif
+#endif
+#if !defined(ORBIT_DECL_CorbaFS_FileSystem) && !defined(_CorbaFS_FileSystem_defined)
+#define ORBIT_DECL_CorbaFS_FileSystem 1
+#define _CorbaFS_FileSystem_defined 1
+#define CorbaFS_FileSystem__free CORBA_Object__free
+   typedef CORBA_Object CorbaFS_FileSystem;
+   extern CORBA_unsigned_long CorbaFS_FileSystem__classid;
+#if !defined(TC_IMPL_TC_CorbaFS_FileSystem_0)
+#define TC_IMPL_TC_CorbaFS_FileSystem_0 'C'
+#define TC_IMPL_TC_CorbaFS_FileSystem_1 'o'
+#define TC_IMPL_TC_CorbaFS_FileSystem_2 'r'
+#define TC_IMPL_TC_CorbaFS_FileSystem_3 'b'
+#define TC_IMPL_TC_CorbaFS_FileSystem_4 'a'
+#define TC_IMPL_TC_CorbaFS_FileSystem_5 'F'
+#define TC_IMPL_TC_CorbaFS_FileSystem_6 'S'
+   extern const struct CORBA_TypeCode_struct TC_CorbaFS_FileSystem_struct;
+#define TC_CorbaFS_FileSystem ((CORBA_TypeCode)&TC_CorbaFS_FileSystem_struct)
+#endif
+#endif
+
+/** POA structures **/
+   typedef struct
+   {
+      void *_private;
+      void (*getStatus) (PortableServer_Servant _servant,
+			 CORBA_unsigned_short * mode,
+			 CORBA_unsigned_long * uid, CORBA_unsigned_long * gid,
+			 CORBA_unsigned_long * size,
+			 CORBA_unsigned_long * inodeNum,
+			 CORBA_unsigned_short * numLinks, CORBA_long * atime,
+			 CORBA_long * mtime, CORBA_long * ctime,
+			 CORBA_Environment * ev);
+      void (*readpage) (PortableServer_Servant _servant,
+			CorbaFS_Buffer ** buffer, const CORBA_long size,
+			const CORBA_long offset, CORBA_Environment * ev);
+      void (*release) (PortableServer_Servant _servant,
+		       CORBA_Environment * ev);
+   }
+   POA_CorbaFS_Inode__epv;
+   typedef struct
+   {
+      PortableServer_ServantBase__epv *_base_epv;
+      POA_CorbaFS_Inode__epv *CorbaFS_Inode_epv;
+   }
+   POA_CorbaFS_Inode__vepv;
+   typedef struct
+   {
+      void *_private;
+      POA_CorbaFS_Inode__vepv *vepv;
+   }
+   POA_CorbaFS_Inode;
+   extern void POA_CorbaFS_Inode__init(PortableServer_Servant servant,
+				       CORBA_Environment * ev);
+   extern void POA_CorbaFS_Inode__fini(PortableServer_Servant servant,
+				       CORBA_Environment * ev);
+   typedef struct
+   {
+      void *_private;
+      
+	 CorbaFS_Inode(*getInode) (PortableServer_Servant _servant,
+				   const CORBA_char * path,
+				   CORBA_Environment * ev);
+      CorbaFS_DirEntSeq *(*readdir) (PortableServer_Servant _servant,
+				     const CORBA_char * path,
+				     CORBA_Environment * ev);
+      CORBA_char *(*readlink) (PortableServer_Servant _servant,
+			       const CORBA_char * filename,
+			       CORBA_Environment * ev);
+   }
+   POA_CorbaFS_FileSystem__epv;
+   typedef struct
+   {
+      PortableServer_ServantBase__epv *_base_epv;
+      POA_CorbaFS_FileSystem__epv *CorbaFS_FileSystem_epv;
+   }
+   POA_CorbaFS_FileSystem__vepv;
+   typedef struct
+   {
+      void *_private;
+      POA_CorbaFS_FileSystem__vepv *vepv;
+   }
+   POA_CorbaFS_FileSystem;
+   extern void POA_CorbaFS_FileSystem__init(PortableServer_Servant servant,
+					    CORBA_Environment * ev);
+   extern void POA_CorbaFS_FileSystem__fini(PortableServer_Servant servant,
+					    CORBA_Environment * ev);
+
+/** prototypes **/
+   void CorbaFS_Inode_getStatus(CorbaFS_Inode _obj,
+				CORBA_unsigned_short * mode,
+				CORBA_unsigned_long * uid,
+				CORBA_unsigned_long * gid,
+				CORBA_unsigned_long * size,
+				CORBA_unsigned_long * inodeNum,
+				CORBA_unsigned_short * numLinks,
+				CORBA_long * atime, CORBA_long * mtime,
+				CORBA_long * ctime, CORBA_Environment * ev);
+   void CorbaFS_Inode_readpage(CorbaFS_Inode _obj, CorbaFS_Buffer ** buffer,
+			       const CORBA_long size, const CORBA_long offset,
+			       CORBA_Environment * ev);
+   void CorbaFS_Inode_release(CorbaFS_Inode _obj, CORBA_Environment * ev);
+   CorbaFS_Inode CorbaFS_FileSystem_getInode(CorbaFS_FileSystem _obj,
+					     const CORBA_char * path,
+					     CORBA_Environment * ev);
+   CorbaFS_DirEntSeq *CorbaFS_FileSystem_readdir(CorbaFS_FileSystem _obj,
+						 const CORBA_char * path,
+						 CORBA_Environment * ev);
+   CORBA_char *CorbaFS_FileSystem_readlink(CorbaFS_FileSystem _obj,
+					   const CORBA_char * filename,
+					   CORBA_Environment * ev);
+
+   void _ORBIT_skel_CorbaFS_Inode_getStatus(POA_CorbaFS_Inode *
+					    _ORBIT_servant,
+					    GIOPRecvBuffer *
+					    _ORBIT_recv_buffer,
+					    CORBA_Environment * ev,
+					    void (*_impl_getStatus)
+					    (PortableServer_Servant _servant,
+					     CORBA_unsigned_short * mode,
+					     CORBA_unsigned_long * uid,
+					     CORBA_unsigned_long * gid,
+					     CORBA_unsigned_long * size,
+					     CORBA_unsigned_long * inodeNum,
+					     CORBA_unsigned_short * numLinks,
+					     CORBA_long * atime,
+					     CORBA_long * mtime,
+					     CORBA_long * ctime,
+					     CORBA_Environment * ev));
+   void _ORBIT_skel_CorbaFS_Inode_readpage(POA_CorbaFS_Inode * _ORBIT_servant,
+					   GIOPRecvBuffer *
+					   _ORBIT_recv_buffer,
+					   CORBA_Environment * ev,
+					   void (*_impl_readpage)
+					   (PortableServer_Servant _servant,
+					    CorbaFS_Buffer ** buffer,
+					    const CORBA_long size,
+					    const CORBA_long offset,
+					    CORBA_Environment * ev));
+   void _ORBIT_skel_CorbaFS_Inode_release(POA_CorbaFS_Inode * _ORBIT_servant,
+					  GIOPRecvBuffer * _ORBIT_recv_buffer,
+					  CORBA_Environment * ev,
+					  void (*_impl_release)
+					  (PortableServer_Servant _servant,
+					   CORBA_Environment * ev));
+   void _ORBIT_skel_CorbaFS_FileSystem_getInode(POA_CorbaFS_FileSystem *
+						_ORBIT_servant,
+						GIOPRecvBuffer *
+						_ORBIT_recv_buffer,
+						CORBA_Environment * ev,
+						CorbaFS_Inode(*_impl_getInode)
+						(PortableServer_Servant
+						 _servant,
+						 const CORBA_char * path,
+						 CORBA_Environment * ev));
+   void _ORBIT_skel_CorbaFS_FileSystem_readdir(POA_CorbaFS_FileSystem *
+					       _ORBIT_servant,
+					       GIOPRecvBuffer *
+					       _ORBIT_recv_buffer,
+					       CORBA_Environment * ev,
+					       CorbaFS_DirEntSeq *
+					       (*_impl_readdir)
+					       (PortableServer_Servant
+						_servant,
+						const CORBA_char * path,
+						CORBA_Environment * ev));
+   void _ORBIT_skel_CorbaFS_FileSystem_readlink(POA_CorbaFS_FileSystem *
+						_ORBIT_servant,
+						GIOPRecvBuffer *
+						_ORBIT_recv_buffer,
+						CORBA_Environment * ev,
+						CORBA_char *
+						(*_impl_readlink)
+						(PortableServer_Servant
+						 _servant,
+						 const CORBA_char * filename,
+						 CORBA_Environment * ev));
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif
+#undef ORBIT_IDL_SERIAL
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/Makefile linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/Makefile
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/Makefile	Thu Feb  1 11:47:03 2001
@@ -0,0 +1,20 @@
+#
+# Makefile for KORBit CorbaFS client
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := corba-corbafs-client.o
+
+obj-y := CorbaFS-common.o CorbaFS-stubs.o CorbaFS-client.o
+obj-m := $(O_TARGET)
+
+include ../../Makefile.module
+
+CorbaFS-client.c: CorbaFS.h
+
+CorbaFS.h CorbaFS-common.c CorbaFS-stubs.c: ../CorbaFS.idl
+	$(ORBIT_IDL) --noskels ../CorbaFS.idl
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/Makefile.user linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/Makefile.user
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/Makefile.user	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/Makefile.user	Thu Feb  1 11:47:03 2001
@@ -0,0 +1,32 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+PROJECT = CorbaFS
+
+CFLAGS = -Wall `orbit-config --cflags client` -I../../..
+LDFLAGS = `orbit-config --libs client`
+OBJS = $(PROJECT)-common.o $(PROJECT)-stubs.o $(PROJECT)-user-client.o 
+ORBIT-IDL = orbit-idl
+
+$(PROJECT)-user-client: $(OBJS)
+	gcc -o $(PROJECT)-user-client $(OBJS) $(LDFLAGS)
+
+$(PROJECT)-user-client.o: $(PROJECT).h
+
+$(PROJECT).h $(PROJECT)-common.c $(PROJECT)-stubs.c: ../$(PROJECT).idl
+	$(ORBIT-IDL) --noskels ../$(PROJECT).idl
+
+clean:
+	rm -f $(OBJS) $(PROJECT)-user-client
+
+realclean: clean
+	rm -f $(PROJECT).h
+	rm -f $(PROJECT)-common.c
+	rm -f $(PROJECT)-skels.c
+	rm -f *~
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/client/README linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/README
--- linux-2.4.1/net/korbit/modules/CorbaFS/client/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/client/README	Thu Feb  1 11:47:03 2001
@@ -0,0 +1,4 @@
+This module implements the kernel VFS->kORBit interface.  This is called a 'client'
+because it actually USES a CORBA object that is exported from someplace else.
+
+ORB: kORBit
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CVS/Entries	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,6 @@
+/CorbaFS-server.c/1.8/Thu Feb  1 09:47:03 2001//
+/CorbaFS-skelimpl.c/1.10/Thu Feb  1 09:47:04 2001//
+/Makefile/1.5/Thu Feb  1 09:47:04 2001//
+/README/1.2/Thu Feb  1 09:47:04 2001//
+/RunServer.sh/1.1/Thu Feb  1 09:47:04 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CVS/Repository	Thu Feb  1 11:47:03 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CorbaFS/server
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CVS/Root
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CVS/Root	Thu Feb  1 11:47:03 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/CorbaFS-server.c linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CorbaFS-server.c
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/CorbaFS-server.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CorbaFS-server.c	Thu Feb  1 11:47:03 2001
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include "CorbaFS-skelimpl.c"
+
+CORBA_ORB               orb;
+PortableServer_POA      poa;
+CORBA_Environment       *ev;
+PortableServer_ObjectId *objid;
+
+int main(int argc, char *argv[]) {
+        CorbaFS_FileSystem          fs;
+        impl_POA_CorbaFS_FileSystem *fs_impl;
+        
+        PortableServer_POAManager pm;
+        ev = g_new0(CORBA_Environment,1);
+        
+        CORBA_exception_init(ev);
+	printf("Make sure you use TCP/IP and not Unix sockets!\n");
+        
+        orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", ev);
+        poa = (PortableServer_POA)
+                CORBA_ORB_resolve_initial_references(orb,
+                                                     "RootPOA", 
+                                                     ev);
+        fs = impl_CorbaFS_FileSystem__create(poa, ev);
+
+        pm = PortableServer_POA__get_the_POAManager(poa, ev);
+        PortableServer_POAManager_activate(pm, ev);
+
+        fs_impl = PortableServer_POA_reference_to_servant( poa, fs, ev );
+        objid = PortableServer_POA_servant_to_id( poa, fs_impl, ev );
+
+        printf("CorbaFS-server:\n%s\n", CORBA_ORB_object_to_string(orb, fs, ev));
+
+        CORBA_ORB_run(orb, ev);
+
+        return 0;
+}
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/CorbaFS-skelimpl.c linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CorbaFS-skelimpl.c
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/CorbaFS-skelimpl.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/CorbaFS-skelimpl.c	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,353 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#include "CorbaFS.h"
+
+/*** App-specific servant structures ***/
+
+#define printf(fmt, args...) fprintf(stderr, fmt, ##args);
+
+typedef struct
+{
+   POA_CorbaFS_Inode servant;
+   PortableServer_POA poa;
+
+        CORBA_char *path;
+#if 0
+        CORBA_unsigned_short mode;
+        CORBA_unsigned_long uid;
+        CORBA_unsigned_long gid;
+        CORBA_unsigned_long size;
+        CORBA_unsigned_long inodeNum;
+        CORBA_unsigned_short numLinks;
+        CORBA_long atime;
+        CORBA_long mtime;
+        CORBA_long ctime;
+#endif
+}
+impl_POA_CorbaFS_Inode;
+
+typedef struct
+{
+   POA_CorbaFS_FileSystem servant;
+   PortableServer_POA poa;
+
+}
+impl_POA_CorbaFS_FileSystem;
+
+/*** Implementation stub prototypes ***/
+
+static void impl_CorbaFS_Inode__destroy(impl_POA_CorbaFS_Inode * servant,
+					CORBA_Environment * ev);
+static void
+impl_CorbaFS_Inode_getStatus(impl_POA_CorbaFS_Inode * servant,
+			     CORBA_unsigned_short * mode,
+			     CORBA_unsigned_long * uid,
+			     CORBA_unsigned_long * gid,
+			     CORBA_unsigned_long * size,
+			     CORBA_unsigned_long * inodeNum,
+			     CORBA_unsigned_short * numLinks,
+			     CORBA_long * atime,
+			     CORBA_long * mtime,
+			     CORBA_long * ctime, CORBA_Environment * ev);
+
+static void
+impl_CorbaFS_Inode_readpage(impl_POA_CorbaFS_Inode * servant,
+			    CorbaFS_Buffer ** buffer,
+			    CORBA_long size,
+			    CORBA_long offset, CORBA_Environment * ev);
+
+static void
+impl_CorbaFS_Inode_release(impl_POA_CorbaFS_Inode * servant,
+			   CORBA_Environment * ev);
+
+static void impl_CorbaFS_FileSystem__destroy(impl_POA_CorbaFS_FileSystem *
+					     servant, CORBA_Environment * ev);
+static CorbaFS_Inode
+impl_CorbaFS_FileSystem_getInode(impl_POA_CorbaFS_FileSystem * servant,
+				 CORBA_char * path, CORBA_Environment * ev);
+
+static CorbaFS_DirEntSeq
+   *impl_CorbaFS_FileSystem_readdir(impl_POA_CorbaFS_FileSystem * servant,
+				    CORBA_char * path,
+
+				    CORBA_Environment * ev);
+
+static CORBA_char
+   *impl_CorbaFS_FileSystem_readlink(impl_POA_CorbaFS_FileSystem * servant,
+				     CORBA_char * filename,
+				     CORBA_Environment * ev);
+
+/*** epv structures ***/
+
+static PortableServer_ServantBase__epv impl_CorbaFS_Inode_base_epv = {
+   NULL,			/* _private data */
+   NULL,			/* finalize routine */
+   NULL,			/* default_POA routine */
+};
+static POA_CorbaFS_Inode__epv impl_CorbaFS_Inode_epv = {
+   NULL,			/* _private */
+   (gpointer) & impl_CorbaFS_Inode_getStatus,
+
+   (gpointer) & impl_CorbaFS_Inode_readpage,
+
+   (gpointer) & impl_CorbaFS_Inode_release,
+
+};
+static PortableServer_ServantBase__epv impl_CorbaFS_FileSystem_base_epv = {
+   NULL,			/* _private data */
+   NULL,			/* finalize routine */
+   NULL,			/* default_POA routine */
+};
+static POA_CorbaFS_FileSystem__epv impl_CorbaFS_FileSystem_epv = {
+   NULL,			/* _private */
+   (gpointer) & impl_CorbaFS_FileSystem_getInode,
+
+   (gpointer) & impl_CorbaFS_FileSystem_readdir,
+
+   (gpointer) & impl_CorbaFS_FileSystem_readlink,
+
+};
+
+/*** vepv structures ***/
+
+static POA_CorbaFS_Inode__vepv impl_CorbaFS_Inode_vepv = {
+   &impl_CorbaFS_Inode_base_epv,
+   &impl_CorbaFS_Inode_epv,
+};
+static POA_CorbaFS_FileSystem__vepv impl_CorbaFS_FileSystem_vepv = {
+   &impl_CorbaFS_FileSystem_base_epv,
+   &impl_CorbaFS_FileSystem_epv,
+};
+
+/*** Stub implementations ***/
+
+static CorbaFS_Inode
+impl_CorbaFS_Inode__create(PortableServer_POA poa, CORBA_Environment * ev)
+{
+   CorbaFS_Inode retval;
+   impl_POA_CorbaFS_Inode *newservant;
+   PortableServer_ObjectId *objid;
+
+   newservant = g_new0(impl_POA_CorbaFS_Inode, 1);
+   newservant->servant.vepv = &impl_CorbaFS_Inode_vepv;
+   newservant->poa = poa;
+   POA_CorbaFS_Inode__init((PortableServer_Servant) newservant, ev);
+   objid = PortableServer_POA_activate_object(poa, newservant, ev);
+   CORBA_free(objid);
+   retval = PortableServer_POA_servant_to_reference(poa, newservant, ev);
+
+   return retval;
+}
+
+static void
+impl_CorbaFS_Inode__destroy(impl_POA_CorbaFS_Inode * servant,
+			    CORBA_Environment * ev)
+{
+   PortableServer_ObjectId *objid;
+
+   objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev);
+   PortableServer_POA_deactivate_object(servant->poa, objid, ev);
+   CORBA_free(objid);
+
+   POA_CorbaFS_Inode__fini((PortableServer_Servant) servant, ev);
+   g_free(servant);
+}
+
+static void
+impl_CorbaFS_Inode_getStatus(impl_POA_CorbaFS_Inode * servant,
+			     CORBA_unsigned_short * mode,
+			     CORBA_unsigned_long * uid,
+			     CORBA_unsigned_long * gid,
+			     CORBA_unsigned_long * size,
+			     CORBA_unsigned_long * inodeNum,
+			     CORBA_unsigned_short * numLinks,
+			     CORBA_long * atime,
+			     CORBA_long * mtime,
+			     CORBA_long * ctime, CORBA_Environment * ev)
+{
+        struct stat buf;
+
+        printf("Inode_getStatus()\n");
+        printf("Inode path = %s\n", servant->path);
+        lstat(servant->path, &buf);
+        
+        *mode = buf.st_mode;
+        *uid = buf.st_uid;
+        *gid = buf.st_gid;
+        *size = buf.st_size;
+        *inodeNum = buf.st_ino;
+        *numLinks = buf.st_nlink;
+        *atime = buf.st_atime;
+        *mtime = buf.st_mtime;
+        *ctime = buf.st_ctime;
+}
+
+static void
+impl_CorbaFS_Inode_readpage(impl_POA_CorbaFS_Inode * servant,
+			    CorbaFS_Buffer ** buffer,
+			    CORBA_long size,
+			    CORBA_long offset, CORBA_Environment * ev)
+{
+        int fd = -1, c = 0;
+        
+        printf("Inode_readpage(buffer, %d, %d)\n", size, offset);
+        printf("Inode_readpage : path = %s\n", servant->path);
+
+        *buffer = CorbaFS_Buffer__alloc();
+        (*buffer)->_maximum = size;
+        (*buffer)->_buffer = CORBA_octet_allocbuf(size);
+        
+        memset((*buffer)->_buffer, size, 0);
+
+        fd = open(servant->path, O_RDONLY);
+        printf("Inode_readpage : fd = %d\n", fd);
+        lseek(fd, offset, SEEK_SET);
+        c = read(fd, (*buffer)->_buffer, size);
+        printf("Inode_readpage : read %d bytes\n", c);
+        (*buffer)->_length = c;
+        close(fd);
+}
+
+static void
+impl_CorbaFS_Inode_release(impl_POA_CorbaFS_Inode * servant,
+			   CORBA_Environment * ev)
+{
+        printf("Inode_release()\n");
+}
+
+static CorbaFS_FileSystem
+impl_CorbaFS_FileSystem__create(PortableServer_POA poa,
+				CORBA_Environment * ev)
+{
+   CorbaFS_FileSystem retval;
+   impl_POA_CorbaFS_FileSystem *newservant;
+   PortableServer_ObjectId *objid;
+
+   newservant = g_new0(impl_POA_CorbaFS_FileSystem, 1);
+   newservant->servant.vepv = &impl_CorbaFS_FileSystem_vepv;
+   newservant->poa = poa;
+   POA_CorbaFS_FileSystem__init((PortableServer_Servant) newservant, ev);
+   objid = PortableServer_POA_activate_object(poa, newservant, ev);
+   CORBA_free(objid);
+   retval = PortableServer_POA_servant_to_reference(poa, newservant, ev);
+
+   return retval;
+}
+
+static void
+impl_CorbaFS_FileSystem__destroy(impl_POA_CorbaFS_FileSystem * servant,
+				 CORBA_Environment * ev)
+{
+   PortableServer_ObjectId *objid;
+
+   objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev);
+   PortableServer_POA_deactivate_object(servant->poa, objid, ev);
+   CORBA_free(objid);
+
+   POA_CorbaFS_FileSystem__fini((PortableServer_Servant) servant, ev);
+   g_free(servant);
+}
+
+static CorbaFS_Inode
+impl_CorbaFS_FileSystem_getInode(impl_POA_CorbaFS_FileSystem * servant,
+				 CORBA_char * path, CORBA_Environment * ev)
+{
+   CorbaFS_Inode retval;
+   impl_POA_CorbaFS_Inode *inode;
+   
+   printf("FileSystem_getInode(%s)\n", path);
+
+   retval = impl_CorbaFS_Inode__create(servant->poa, ev);
+
+   inode = PortableServer_POA_reference_to_servant( servant->poa, retval, ev );
+   inode->path = CORBA_string_dup(path);
+#if 0
+   inode->mode = 0040777; /* world-readable directory */
+   inode->uid = 0;
+   inode->gid = 0;
+   inode->size = 4096;
+   inode->inodeNum = inodeNum++;
+   inode->numLinks = 1;
+   inode->atime = 0;
+   inode->mtime = 100;
+   inode->ctime = 10000;
+#endif
+
+   return retval;
+}
+
+static CorbaFS_DirEntSeq *
+impl_CorbaFS_FileSystem_readdir(impl_POA_CorbaFS_FileSystem * servant,
+				CORBA_char * path, CORBA_Environment * ev)
+{
+   CorbaFS_DirEntSeq *retval;
+   CorbaFS_dirent *dirent;
+
+   DIR *dir;
+   struct dirent *dirp;
+   int c;
+   
+   printf("FileSystem_readdir(%s)\n", path);
+
+   retval = CorbaFS_DirEntSeq__alloc();
+   retval->_maximum = 0;
+   retval->_length = 0;
+
+   dir = opendir(path);
+   if (dir == NULL)
+           return retval;
+   
+   c = 0;
+   while ((dirp = readdir(dir)))
+           c++;
+   
+   rewinddir(dir);
+   
+   printf("%d directories\n", c);
+   
+   retval->_buffer = CORBA_sequence_CorbaFS_dirent_allocbuf(c);
+   retval->_maximum = c;
+   dirent = retval->_buffer;
+   
+   c = 0;
+   while ((dirp = readdir(dir)) && (c < retval->_maximum)) 
+   {
+           printf("Adding directory %d : %s (%d)\n", c, dirp->d_name, dirp->d_ino);
+           
+           dirent[c].inode = dirp->d_ino;
+           dirent[c].name = CORBA_string_dup(dirp->d_name);
+           c++;
+   }
+   retval->_length = c;
+
+   closedir(dir);
+   
+   return retval;
+}
+
+static CORBA_char *
+impl_CorbaFS_FileSystem_readlink(impl_POA_CorbaFS_FileSystem * servant,
+				 CORBA_char * filename,
+				 CORBA_Environment * ev)
+{
+   CORBA_char *retval = CORBA_OBJECT_NIL;
+   char tmp[MAXPATHLEN + 1];
+   int len;
+   
+   printf("FileSystem_readlink(%s) = ", filename);
+   len = readlink(filename, tmp, MAXPATHLEN);
+   if (len != -1)
+   {
+           tmp[len] = '\0';
+           retval = CORBA_string_dup(tmp);
+   }
+
+   printf("%s\n", retval);
+   
+   return retval;
+}
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/Makefile linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/Makefile
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/Makefile	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,32 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+PROJECT = CorbaFS
+
+CFLAGS = -Wall `orbit-config --cflags server` -I../../..
+LDFLAGS = `orbit-config --libs server`
+OBJS = $(PROJECT)-common.o $(PROJECT)-skels.o $(PROJECT)-server.o 
+ORBIT-IDL = orbit-idl
+
+$(PROJECT)-server: $(OBJS)
+	gcc -o $(PROJECT)-server $(OBJS) $(LDFLAGS)
+
+$(PROJECT)-server.o: $(PROJECT).h $(PROJECT)-skelimpl.c
+
+$(PROJECT).h $(PROJECT)-common.c $(PROJECT)-skels.c: ../$(PROJECT).idl
+	$(ORBIT-IDL) --nostubs ../$(PROJECT).idl
+
+clean:
+	rm -f $(OBJS) $(PROJECT)-server
+
+realclean: clean
+	rm -f $(PROJECT).h
+	rm -f $(PROJECT)-common.c
+	rm -f $(PROJECT)-skels.c
+	rm -f *~
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/README linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/README
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/README	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,8 @@
+This server provides an NFS like capability of exporting an existing filesystem.
+
+ORB: ORBit
+Status: Working! (for readonly fs's)
+
+NOTE!!!!:  When starting this server make sure you pass ORBit the options to
+           have it use ipv4 sockets and not unix domain sockets, or else bad
+           things will happen.  You can use the included RunServer script.
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server/RunServer.sh linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/RunServer.sh
--- linux-2.4.1/net/korbit/modules/CorbaFS/server/RunServer.sh	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server/RunServer.sh	Thu Feb  1 11:47:04 2001
@@ -0,0 +1 @@
+./CorbaFS-server -ORBIIOPUSock=0 -ORBIIOPIPv4=1
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/CVS/Entries
--- linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/CVS/Entries	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,3 @@
+/PerlServer/1.2/Thu Feb  1 09:47:04 2001//
+/README/1.1/Thu Feb  1 09:47:04 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/CVS/Repository
--- linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/CVS/Repository	Thu Feb  1 11:47:04 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/CorbaFS/server-perl
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/CVS/Root linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/CVS/Root
--- linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/CVS/Root	Thu Feb  1 11:47:04 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/PerlServer linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/PerlServer
--- linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/PerlServer	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/PerlServer	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,67 @@
+#!/usr/bin/perl -w
+use CORBA::ORBit idl => [ qw(../CorbaFS.idl) ];
+use Error qw(:try);
+use strict;
+
+
+package MyFSInode;
+@MyFSInode::ISA = qw(POA_CorbaFS::Inode);
+
+sub new {
+  my $self = bless { name => shift };
+  print "INODE CREATED: $self->{name}!\n";
+}
+
+sub getStatus {
+  my ($self) = @_;
+  print "$self->getStatus()\n";
+}
+
+sub readpage {
+  return "";
+}
+
+sub release {
+}
+
+
+package MyFileSystem;
+@MyFileSystem::ISA = qw(POA_CorbaFS::FileSystem);
+
+sub new {
+  my $self = bless { root => '/home' };
+}
+
+sub getInode {
+  my $path = shift;
+  print "getInode($path)\n";
+  return new MyFSInode($path);
+}
+
+sub readdir {
+  my $path = shift;
+  print "readdir($path)\n";
+  return [ { inode => 1, name => '...' } ];
+}
+
+sub readlink {
+  my $path = shift;
+  print "readlink($path)\n";
+  return "fredrik";
+}
+
+
+package Main;
+
+my $orb = CORBA::ORB_init("orbit-local-orb");
+my $poa = $orb->resolve_initial_references("RootPOA");
+
+my $Server = new MyFileSystem();
+my $id = $poa->activate_object($Server);
+my $ref = $orb->object_to_string($poa->id_to_reference($id));
+
+print "$ref\n";
+
+print "Running orb:\n";
+$orb->run();
+exit(0);
diff -urN linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/README linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/README
--- linux-2.4.1/net/korbit/modules/CorbaFS/server-perl/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/CorbaFS/server-perl/README	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,4 @@
+Test filesystem implementation in Perl.
+
+ORB: ORBit/Perl
+Status: horribly broken
diff -urN linux-2.4.1/net/korbit/modules/Echo/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Echo/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Entries	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,4 @@
+/Makefile/1.3/Thu Feb  1 09:47:04 2001//
+/README/1.1/Thu Feb  1 09:47:05 2001//
+/echo.idl/1.1/Thu Feb  1 09:47:05 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Echo/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Entries.Log
--- linux-2.4.1/net/korbit/modules/Echo/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Entries.Log	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,3 @@
+A D/client////
+A D/client-perl////
+A D/server////
diff -urN linux-2.4.1/net/korbit/modules/Echo/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Echo/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Repository	Thu Feb  1 11:47:04 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Echo
diff -urN linux-2.4.1/net/korbit/modules/Echo/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Root
--- linux-2.4.1/net/korbit/modules/Echo/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/CVS/Root	Thu Feb  1 11:47:04 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Echo/Makefile linux-2.4.1-korbit/net/korbit/modules/Echo/Makefile
--- linux-2.4.1/net/korbit/modules/Echo/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/Makefile	Thu Feb  1 11:47:04 2001
@@ -0,0 +1,11 @@
+#
+# Makefile for KORBit/modules/Console
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+
+subdir-$(CONFIG_CORBA_ECHO) := client server
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/modules/Echo/README linux-2.4.1-korbit/net/korbit/modules/Echo/README
--- linux-2.4.1/net/korbit/modules/Echo/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/README	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,2 @@
+The Echo test is very similar to the console test, but it also "returns" a 
+"random" number.  The random number, in our case, is simply a constant.
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Echo/client/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Echo/client/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/CVS/Entries	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,6 @@
+/Makefile/1.4/Thu Feb  1 09:47:05 2001//
+/Makefile.user/1.1/Thu Feb  1 09:47:05 2001//
+/README/1.1/Thu Feb  1 09:47:05 2001//
+/RunClient.sh/1.1/Thu Feb  1 09:47:05 2001//
+/echo-client.c/1.6/Thu Feb  1 09:47:05 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Echo/client/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Echo/client/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/CVS/Repository	Thu Feb  1 11:47:05 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Echo/client
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Echo/client/CVS/Root
--- linux-2.4.1/net/korbit/modules/Echo/client/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/CVS/Root	Thu Feb  1 11:47:05 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/Makefile linux-2.4.1-korbit/net/korbit/modules/Echo/client/Makefile
--- linux-2.4.1/net/korbit/modules/Echo/client/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/Makefile	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,20 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := corba-echo-client.o
+
+obj-y := echo-common.o echo-stubs.o echo-client.o
+obj-m := $(O_TARGET)
+
+include ../../Makefile.module
+
+echo-client.c: echo.h
+
+echo.h echo-common.c echo-stubs.c: ../echo.idl
+	$(ORBIT_IDL) --noskels ../echo.idl
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/Makefile.user linux-2.4.1-korbit/net/korbit/modules/Echo/client/Makefile.user
--- linux-2.4.1/net/korbit/modules/Echo/client/Makefile.user	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/Makefile.user	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,32 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+PROJECT = echo
+
+CFLAGS = -Wall `orbit-config --cflags client` -I../../..
+LDFLAGS = `orbit-config --libs client`
+OBJS = $(PROJECT)-common.o $(PROJECT)-stubs.o $(PROJECT)-client.o 
+ORBIT-IDL = orbit-idl
+
+$(PROJECT)-client: $(OBJS)
+	gcc -o $(PROJECT)-client $(OBJS) $(LDFLAGS)
+
+$(PROJECT)-client.c: $(PROJECT).h
+
+$(PROJECT).h $(PROJECT)-common.c $(PROJECT)-stubs.c: ../$(PROJECT).idl
+	$(ORBIT-IDL) --noskels ../$(PROJECT).idl
+
+clean:
+	rm -f $(OBJS) $(PROJECT)-client
+
+realclean: clean
+	rm -f $(PROJECT).h
+	rm -f $(PROJECT)-common.c
+	rm -f $(PROJECT)-stubs.c
+	rm -f *~
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/README linux-2.4.1-korbit/net/korbit/modules/Echo/client/README
--- linux-2.4.1/net/korbit/modules/Echo/client/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/README	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,4 @@
+This simply tests the Echo service.
+
+ORB: ORBit
+Status: working
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/RunClient.sh linux-2.4.1-korbit/net/korbit/modules/Echo/client/RunClient.sh
--- linux-2.4.1/net/korbit/modules/Echo/client/RunClient.sh	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/RunClient.sh	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,3 @@
+#!/bin/sh
+date
+./echo-client `cat /proc/corba/echo-server` 5
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/echo-client.c linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo-client.c
--- linux-2.4.1/net/korbit/modules/Echo/client/echo-client.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo-client.c	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,119 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <orb/orbit.h>
+
+#ifdef __KERNEL__
+#include <linux/init.h>
+#include <linux/module.h>
+#include "korbit.h"
+#endif
+#include "echo.h"
+
+Echo echo_client, bec;
+
+#define BATCH_SIZE 1
+
+
+#ifndef __KERNEL__
+int main (int argc, char *argv[]) {
+#else
+int __init corba_echo_init(void) {
+    int argc = 1; char *argv[] = { "echo-client", 0, 0 };
+#endif
+    CORBA_Environment ev;
+    CORBA_ORB orb;
+    CORBA_long rv;
+    char buf[30];
+    int i, j;
+
+    int niters = 5;
+
+#ifndef __KERNEL__    
+    struct timeval start, end;
+    long diff, diffsum = 0;
+#endif
+
+    CORBA_exception_init(&ev);
+    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);
+
+#ifdef __KERNEL__
+    {
+            int c, fd = open("/tmp/echo-ior", O_RDONLY, 0);
+            if (fd == -1) 
+                    return -1;
+            printf("Reading IOR from /tmp/echo-ior\n");
+            argv[1] = malloc(501);
+            c = read(fd, argv[1], 500);
+            argv[1][c] = '\0';
+            printf("Reading %d bytes: %s\n", c, argv[1]);
+    }
+#else
+    if(argc < 2)
+      {
+	printf("Need an IOR as argv[1]\n");
+	return 1;
+      }
+
+    if(argc == 3)
+	niters = atoi(argv[2]);
+#endif
+
+    echo_client = CORBA_ORB_string_to_object(orb, argv[1], &ev);
+    if (!echo_client) {
+	printf("Cannot bind to %s\n", argv[1]);
+	return 1;
+    }
+
+    for(i = 0; i < niters; i++) {
+	    g_snprintf(buf, sizeof(buf), "Hello, world [%d]", i);
+#ifdef __KERNEL__
+	    bec = Echo_echoString(echo_client, buf, &rv, &ev);
+#else
+            gettimeofday(&start, NULL);
+            for (j = BATCH_SIZE; j > 0; j--) {
+	      bec = Echo_echoString(echo_client, buf, &rv, &ev);
+	      if (j != 1) CORBA_Object_release(bec, &ev);
+            }
+            gettimeofday(&end, NULL);
+            diff = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec);
+            diff /= BATCH_SIZE;
+            diffsum += diff;
+            
+            printf("duration = %d usec\t", diff);
+#endif
+            
+	    if(ev._major != CORBA_NO_EXCEPTION) {
+	      printf("\nWe got exception %d from echoString!\n", ev._major);
+	      return 1;
+	    }
+
+	    CORBA_Object_release(echo_client, &ev);
+	    if(ev._major != CORBA_NO_EXCEPTION) {
+	      printf("we got exception %d from release!\n", ev._major);
+	      return 1;
+	    } 
+
+	    printf("[client] %d\n", rv);
+
+	    echo_client = bec; bec = CORBA_OBJECT_NIL;
+    }
+
+#ifndef __KERNEL__
+    printf("duration average = %d usec\n", diffsum / niters);
+    CORBA_Object_release(echo_client, &ev);
+    CORBA_Object_release((CORBA_Object)orb, &ev);
+#endif
+
+    return 0;
+}
+
+
+#ifdef __KERNEL__
+void corba_echo_exit(void) { 
+}
+
+module_init(corba_echo_init)
+module_exit(corba_echo_exit)
+#endif
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/echo-common.c linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo-common.c
--- linux-2.4.1/net/korbit/modules/Echo/client/echo-common.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo-common.c	Thu Feb  1 16:36:36 2001
@@ -0,0 +1,27 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <string.h>
+#include "echo.h"
+
+#if ( (TC_IMPL_TC_Echo_0 == 'e') \
+&& (TC_IMPL_TC_Echo_1 == 'c') \
+&& (TC_IMPL_TC_Echo_2 == 'h') \
+&& (TC_IMPL_TC_Echo_3 == 'o') \
+) && !defined(TC_DEF_TC_Echo)
+#define TC_DEF_TC_Echo 1
+const struct CORBA_TypeCode_struct TC_Echo_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_objref, "Echo", "IDL:Echo:1.0",
+   0, 0,
+   NULL,
+   NULL,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+CORBA_unsigned_long Echo__classid = 0;
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/echo-stubs.c linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo-stubs.c
--- linux-2.4.1/net/korbit/modules/Echo/client/echo-stubs.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo-stubs.c	Thu Feb  1 16:36:36 2001
@@ -0,0 +1,134 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <string.h>
+#include "echo.h"
+
+Echo
+Echo_echoString(Echo _obj, const CORBA_char * astring, CORBA_long * anum,
+		CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+   Echo _ORBIT_retval;
+
+   if (_obj->servant && _obj->vepv && Echo__classid) {
+      _ORBIT_retval =
+	 ((POA_Echo__epv *) _obj->vepv[Echo__classid])->echoString(_obj->
+								   servant,
+								   astring,
+								   anum, ev);
+      return _ORBIT_retval;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[11];
+      }
+      _ORBIT_operation_name_data =
+      {
+      11, "echoString"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 15 };
+      register CORBA_unsigned_long _ORBIT_tmpvar_0;
+      CORBA_unsigned_long _ORBIT_tmpvar_1;
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_tmpvar_1 = strlen(astring) + 1;
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
+				       (_ORBIT_send_buffer), 4);
+      {
+	 guchar *_ORBIT_t;
+
+	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
+	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
+	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
+					(_ORBIT_send_buffer), (_ORBIT_t),
+					sizeof(_ORBIT_tmpvar_1));
+      }
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
+				     (astring),
+				     sizeof(astring[_ORBIT_tmpvar_0]) *
+				     _ORBIT_tmpvar_1);
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
+	 _ORBIT_retval =
+	    ORBit_demarshal_object(_ORBIT_recv_buffer,
+				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
+				   connection->orb_data);
+	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & ((*anum)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));} else {
+	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
+	 _ORBIT_retval =
+	    ORBit_demarshal_object(_ORBIT_recv_buffer,
+				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
+				   connection->orb_data);
+	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 (*anum) = *((CORBA_long *) _ORBIT_curptr);
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return _ORBIT_retval;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return _ORBIT_retval;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return _ORBIT_retval;
+      }
+   }
+}
diff -urN linux-2.4.1/net/korbit/modules/Echo/client/echo.h linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo.h
--- linux-2.4.1/net/korbit/modules/Echo/client/echo.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client/echo.h	Thu Feb  1 16:36:36 2001
@@ -0,0 +1,77 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <glib.h>
+#define ORBIT_IDL_SERIAL 9
+#include <orb/orbit.h>
+
+#ifndef echo_H
+#define echo_H 1
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/** typedefs **/
+#if !defined(ORBIT_DECL_Echo) && !defined(_Echo_defined)
+#define ORBIT_DECL_Echo 1
+#define _Echo_defined 1
+#define Echo__free CORBA_Object__free
+   typedef CORBA_Object Echo;
+   extern CORBA_unsigned_long Echo__classid;
+#if !defined(TC_IMPL_TC_Echo_0)
+#define TC_IMPL_TC_Echo_0 'e'
+#define TC_IMPL_TC_Echo_1 'c'
+#define TC_IMPL_TC_Echo_2 'h'
+#define TC_IMPL_TC_Echo_3 'o'
+   extern const struct CORBA_TypeCode_struct TC_Echo_struct;
+#define TC_Echo ((CORBA_TypeCode)&TC_Echo_struct)
+#endif
+#endif
+
+/** POA structures **/
+   typedef struct
+   {
+      void *_private;
+      
+	 Echo(*echoString) (PortableServer_Servant _servant,
+			    const CORBA_char * astring, CORBA_long * anum,
+			    CORBA_Environment * ev);
+   }
+   POA_Echo__epv;
+   typedef struct
+   {
+      PortableServer_ServantBase__epv *_base_epv;
+      POA_Echo__epv *Echo_epv;
+   }
+   POA_Echo__vepv;
+   typedef struct
+   {
+      void *_private;
+      POA_Echo__vepv *vepv;
+   }
+   POA_Echo;
+   extern void POA_Echo__init(PortableServer_Servant servant,
+			      CORBA_Environment * ev);
+   extern void POA_Echo__fini(PortableServer_Servant servant,
+			      CORBA_Environment * ev);
+
+/** prototypes **/
+   Echo Echo_echoString(Echo _obj, const CORBA_char * astring,
+			CORBA_long * anum, CORBA_Environment * ev);
+
+   void _ORBIT_skel_Echo_echoString(POA_Echo * _ORBIT_servant,
+				    GIOPRecvBuffer * _ORBIT_recv_buffer,
+				    CORBA_Environment * ev,
+				    Echo(*_impl_echoString)
+				    (PortableServer_Servant _servant,
+				     const CORBA_char * astring,
+				     CORBA_long * anum,
+				     CORBA_Environment * ev));
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif
+#undef ORBIT_IDL_SERIAL
diff -urN linux-2.4.1/net/korbit/modules/Echo/client-perl/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Echo/client-perl/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/CVS/Entries	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,3 @@
+/PerlTest/1.2/Thu Feb  1 09:47:06 2001//
+/README/1.1/Thu Feb  1 09:47:06 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Echo/client-perl/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Echo/client-perl/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/CVS/Repository	Thu Feb  1 11:47:06 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Echo/client-perl
diff -urN linux-2.4.1/net/korbit/modules/Echo/client-perl/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/CVS/Root
--- linux-2.4.1/net/korbit/modules/Echo/client-perl/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/CVS/Root	Thu Feb  1 11:47:06 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Echo/client-perl/PerlTest linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/PerlTest
--- linux-2.4.1/net/korbit/modules/Echo/client-perl/PerlTest	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/PerlTest	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,17 @@
+#!/usr/bin/perl -w
+
+use CORBA::ORBit idl => [ qw(../echo.idl) ];
+use Error qw(:try);
+use strict;
+
+my $orb = CORBA::ORB_init("orbit-local-orb");
+open IOR, "/proc/corba/echo-server" or die "no console server found!";
+my $ior = <IOR>;
+close IOR;
+chomp($ior);  # Kill fredrik's newline...
+
+my $echo = $orb->string_to_object($ior);
+# Echo echoString(in string astring, out long anum);
+my ($echo2, $num) = $echo->echoString("Echo Strange World");
+
+print "Return Echo = $echo2\nnum = $num\n";
diff -urN linux-2.4.1/net/korbit/modules/Echo/client-perl/README linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/README
--- linux-2.4.1/net/korbit/modules/Echo/client-perl/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/client-perl/README	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,4 @@
+Another test of the echo server.
+
+ORB: ORBit/Perl
+Status: Working fine
diff -urN linux-2.4.1/net/korbit/modules/Echo/echo.idl linux-2.4.1-korbit/net/korbit/modules/Echo/echo.idl
--- linux-2.4.1/net/korbit/modules/Echo/echo.idl	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/echo.idl	Thu Feb  1 11:47:05 2001
@@ -0,0 +1,3 @@
+interface Echo {
+	Echo echoString(in string astring, out long anum);
+};
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/Echo/server/CVS/Entries
--- linux-2.4.1/net/korbit/modules/Echo/server/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/CVS/Entries	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,6 @@
+/Makefile/1.2/Thu Feb  1 09:47:06 2001//
+/Makefile.user/1.3/Thu Feb  1 09:47:06 2001//
+/README/1.1/Thu Feb  1 09:47:06 2001//
+/RunServer.sh/1.1/Thu Feb  1 09:47:06 2001//
+/echo-server.c/1.8/Thu Feb  1 09:47:06 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/Echo/server/CVS/Repository
--- linux-2.4.1/net/korbit/modules/Echo/server/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/CVS/Repository	Thu Feb  1 11:47:06 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/Echo/server
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/CVS/Root linux-2.4.1-korbit/net/korbit/modules/Echo/server/CVS/Root
--- linux-2.4.1/net/korbit/modules/Echo/server/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/CVS/Root	Thu Feb  1 11:47:06 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/Makefile linux-2.4.1-korbit/net/korbit/modules/Echo/server/Makefile
--- linux-2.4.1/net/korbit/modules/Echo/server/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/Makefile	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,21 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := corba-echo-server.o
+
+obj-y := echo-server.o echo-skels.o echo-common.o
+obj-m := $(O_TARGET)
+
+include ../../Makefile.module
+
+echo-server.c: echo.h echo-skels.c
+
+
+echo.h echo-common.c echo-skels.c: ../echo.idl
+	$(ORBIT_IDL) ../echo.idl
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/Makefile.user linux-2.4.1-korbit/net/korbit/modules/Echo/server/Makefile.user
--- linux-2.4.1/net/korbit/modules/Echo/server/Makefile.user	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/Makefile.user	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,27 @@
+#
+# Makefile for user level server
+#
+
+PROJECT = echo
+
+CFLAGS = -Wall `orbit-config --cflags server` -I../../..
+LDFLAGS = `orbit-config --libs server`
+OBJS = $(PROJECT)-common.o $(PROJECT)-skels.o $(PROJECT)-server.o 
+ORBIT-IDL = orbit-idl
+
+$(PROJECT)-server: $(OBJS)
+	gcc -o $(PROJECT)-server $(OBJS) $(LDFLAGS)
+
+$(PROJECT)-server.c: $(PROJECT).h
+
+$(PROJECT).h $(PROJECT)-common.c $(PROJECT)-skels.c: ../$(PROJECT).idl
+	$(ORBIT-IDL) --nostubs ../$(PROJECT).idl
+
+clean:
+	rm -f $(OBJS) $(PROJECT)-server
+
+realclean: clean
+	rm -f $(PROJECT).h
+	rm -f $(PROJECT)-common.c
+	rm -f $(PROJECT)-skels.c
+	rm -f *~
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/README linux-2.4.1-korbit/net/korbit/modules/Echo/server/README
--- linux-2.4.1/net/korbit/modules/Echo/server/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/README	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,5 @@
+This server implements the kernel side interface in terms of printk.
+
+This server also builds in user space with ORBit.  Build with 
+  make -f Makefile.user
+
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/RunServer.sh linux-2.4.1-korbit/net/korbit/modules/Echo/server/RunServer.sh
--- linux-2.4.1/net/korbit/modules/Echo/server/RunServer.sh	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/RunServer.sh	Thu Feb  1 11:47:06 2001
@@ -0,0 +1 @@
+./echo-server -ORBIIOPUSock=0 -ORBIIOPIPv4=1
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/echo-common.c linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-common.c
--- linux-2.4.1/net/korbit/modules/Echo/server/echo-common.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-common.c	Thu Feb  1 16:36:57 2001
@@ -0,0 +1,27 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <string.h>
+#include "echo.h"
+
+#if ( (TC_IMPL_TC_Echo_0 == 'e') \
+&& (TC_IMPL_TC_Echo_1 == 'c') \
+&& (TC_IMPL_TC_Echo_2 == 'h') \
+&& (TC_IMPL_TC_Echo_3 == 'o') \
+) && !defined(TC_DEF_TC_Echo)
+#define TC_DEF_TC_Echo 1
+const struct CORBA_TypeCode_struct TC_Echo_struct = {
+   
+      {{(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1},
+    ORBIT_PSEUDO_TYPECODE},
+
+   CORBA_tk_objref, "Echo", "IDL:Echo:1.0",
+   0, 0,
+   NULL,
+   NULL,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+CORBA_unsigned_long Echo__classid = 0;
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/echo-server.c linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-server.c
--- linux-2.4.1/net/korbit/modules/Echo/server/echo-server.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-server.c	Thu Feb  1 11:47:06 2001
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <orb/orbit.h>
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include "echo.h"
+#include "glib.h"
+#include "korbit.h"
+
+Echo echo_client = CORBA_OBJECT_NIL;
+
+static CORBA_Object
+do_echoString(PortableServer_Servant servant,
+	      CORBA_char *astring,
+	      CORBA_long *outnum,
+	      CORBA_Environment *ev);
+
+PortableServer_ServantBase__epv base_epv = {
+  NULL,
+  NULL,
+  NULL
+};
+POA_Echo__epv echo_epv = { NULL, do_echoString };
+POA_Echo__vepv poa_echo_vepv = { &base_epv, &echo_epv };
+POA_Echo poa_echo_servant = { NULL, &poa_echo_vepv };
+
+PortableServer_ObjectId objid = {0, sizeof("myEchoString"), "myEchoString"};
+PortableServer_POA poa;
+CORBA_Environment *ev; 
+
+#ifdef __KERNEL__
+int __init corba_echo_init(void) 
+#else
+int main(int argc, char *argv[])
+#endif
+{
+#ifdef __KERNEL__
+    int argc = 1; char *argv[] = { "server", 0 };
+#endif
+    CORBA_ORB orb;
+    ev = g_new0(CORBA_Environment, 1);
+    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", ev);
+    if (!orb) {
+        printf("Error getting ORB!\n");
+        return 1;
+    }
+
+    poa = (PortableServer_POA)
+          CORBA_ORB_resolve_initial_references(orb, "RootPOA", ev);
+    if (!poa) {
+        printf("Error getting POA!\n");
+        return 1;
+    }
+
+    PortableServer_POAManager_activate(
+          PortableServer_POA__get_the_POAManager(poa, ev), ev);
+
+
+    POA_Echo__init(&poa_echo_servant, ev);
+    PortableServer_POA_activate_object_with_id(poa,
+					       &objid, &poa_echo_servant, ev);
+
+    echo_client = PortableServer_POA_servant_to_reference(poa,
+							  &poa_echo_servant,
+							  ev);
+    if (!echo_client) {
+	printf("Cannot get objref\n");
+	return 1;
+    }
+
+    korbit_register_ior("echo-server", echo_client, orb, ev);
+
+    CORBA_ORB_run(orb, ev);
+    return 0;
+}
+
+#ifdef __KERNEL__
+void corba_echo_exit(void) { 
+  PortableServer_POA_deactivate_object(poa, &objid, ev);
+  remove_proc_entry("corba/echo-server", 0);
+}
+
+module_init(corba_echo_init)
+module_exit(corba_echo_exit)
+#endif
+
+static CORBA_Object
+do_echoString(PortableServer_Servant servant,
+	      CORBA_char *astring,
+	      CORBA_long *outnum,
+	      CORBA_Environment *ev)
+{
+  *outnum = 12345678;
+
+#if 1
+  g_message("[server] %s -> %d", astring, *outnum);
+#endif
+
+  return CORBA_Object_duplicate(echo_client, ev);
+}
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/echo-skels.c linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-skels.c
--- linux-2.4.1/net/korbit/modules/Echo/server/echo-skels.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-skels.c	Thu Feb  1 16:36:57 2001
@@ -0,0 +1,115 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <string.h>
+#include "echo.h"
+
+void
+_ORBIT_skel_Echo_echoString(POA_Echo * _ORBIT_servant,
+			    GIOPRecvBuffer * _ORBIT_recv_buffer,
+			    CORBA_Environment * ev,
+			    Echo(*_impl_echoString) (PortableServer_Servant
+						     _servant,
+						     const CORBA_char *
+						     astring,
+						     CORBA_long * anum,
+						     CORBA_Environment * ev))
+{
+   Echo _ORBIT_retval;
+   CORBA_char *astring;
+   CORBA_long anum;
+
+   {				/* demarshalling */
+      guchar *_ORBIT_curptr;
+      register CORBA_unsigned_long _ORBIT_tmpvar_2;
+      CORBA_unsigned_long _ORBIT_tmpvar_3;
+
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & (_ORBIT_tmpvar_3))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
+	 _ORBIT_curptr += 4;
+	 astring = (void *) _ORBIT_curptr;
+	 _ORBIT_curptr += sizeof(astring[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
+      } else {
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
+	 _ORBIT_curptr += 4;
+	 astring = (void *) _ORBIT_curptr;
+	 _ORBIT_curptr += sizeof(astring[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
+      }
+   }
+   _ORBIT_retval = _impl_echoString(_ORBIT_servant, astring, &(anum), ev);
+   {				/* marshalling */
+      register GIOPSendBuffer *_ORBIT_send_buffer;
+
+      _ORBIT_send_buffer =
+	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
+				    connection, NULL,
+				    _ORBIT_recv_buffer->message.u.request.
+				    request_id, ev->_major);
+      if (_ORBIT_send_buffer) {
+	 if (ev->_major == CORBA_NO_EXCEPTION) {
+	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
+	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
+					     (_ORBIT_send_buffer), 4);
+	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
+					   (_ORBIT_send_buffer), &(anum),
+					   sizeof(anum));
+	 } else
+	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
+	 giop_send_buffer_write(_ORBIT_send_buffer);
+	 giop_send_buffer_unuse(_ORBIT_send_buffer);
+      }
+      if (ev->_major == CORBA_NO_EXCEPTION)
+	 CORBA_Object_release(_ORBIT_retval, ev);
+   }
+}
+static ORBitSkeleton
+get_skel_Echo(POA_Echo * servant,
+	      GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
+{
+   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;
+
+   switch (opname[0]) {
+     case 'e':
+	if (strcmp((opname + 1), "choString"))
+	   break;
+	*impl = (gpointer) servant->vepv->Echo_epv->echoString;
+	return (ORBitSkeleton) _ORBIT_skel_Echo_echoString;
+	break;
+     default:
+	break;
+   }
+   return NULL;
+}
+
+static void
+init_local_objref_Echo(CORBA_Object obj, POA_Echo * servant)
+{
+   obj->vepv[Echo__classid] = servant->vepv->Echo_epv;
+}
+
+void
+POA_Echo__init(PortableServer_Servant servant, CORBA_Environment * env)
+{
+   static const PortableServer_ClassInfo class_info =
+      { (ORBit_impl_finder) & get_skel_Echo, "IDL:Echo:1.0",
+	 (ORBit_local_objref_init) & init_local_objref_Echo };
+
+   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
+				    env);
+   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
+      class_info = (PortableServer_ClassInfo *) & class_info;
+   if (!Echo__classid)
+      Echo__classid = ORBit_register_class(&class_info);
+}
+
+void
+POA_Echo__fini(PortableServer_Servant servant, CORBA_Environment * env)
+{
+   PortableServer_ServantBase__fini(servant, env);
+}
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/echo-stubs.c linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-stubs.c
--- linux-2.4.1/net/korbit/modules/Echo/server/echo-stubs.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo-stubs.c	Thu Feb  1 16:36:57 2001
@@ -0,0 +1,134 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <string.h>
+#include "echo.h"
+
+Echo
+Echo_echoString(Echo _obj, const CORBA_char * astring, CORBA_long * anum,
+		CORBA_Environment * ev)
+{
+   register GIOP_unsigned_long _ORBIT_request_id,
+    _ORBIT_system_exception_minor;
+   register CORBA_completion_status _ORBIT_completion_status;
+   register GIOPSendBuffer *_ORBIT_send_buffer;
+   register GIOPRecvBuffer *_ORBIT_recv_buffer;
+   register GIOPConnection *_cnx;
+   Echo _ORBIT_retval;
+
+   if (_obj->servant && _obj->vepv && Echo__classid) {
+      _ORBIT_retval =
+	 ((POA_Echo__epv *) _obj->vepv[Echo__classid])->echoString(_obj->
+								   servant,
+								   astring,
+								   anum, ev);
+      return _ORBIT_retval;
+   }
+   _cnx = ORBit_object_get_connection(_obj);
+ _ORBIT_retry_request:
+   _ORBIT_send_buffer = NULL;
+   _ORBIT_recv_buffer = NULL;
+   _ORBIT_completion_status = CORBA_COMPLETED_NO;
+   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
+   {				/* marshalling */
+      static const struct
+      {
+	 CORBA_unsigned_long len;
+	 char opname[11];
+      }
+      _ORBIT_operation_name_data =
+      {
+      11, "echoString"};
+      static const struct iovec _ORBIT_operation_vec =
+	 { (gpointer) & _ORBIT_operation_name_data, 15 };
+      register CORBA_unsigned_long _ORBIT_tmpvar_0;
+      CORBA_unsigned_long _ORBIT_tmpvar_1;
+
+      _ORBIT_send_buffer =
+	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
+				      CORBA_TRUE,
+				      &(_obj->active_profile->object_key_vec),
+				      &_ORBIT_operation_vec,
+				      &ORBit_default_principal_iovec);
+
+      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+      if (!_ORBIT_send_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_tmpvar_1 = strlen(astring) + 1;
+      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
+				       (_ORBIT_send_buffer), 4);
+      {
+	 guchar *_ORBIT_t;
+
+	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
+	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
+	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
+					(_ORBIT_send_buffer), (_ORBIT_t),
+					sizeof(_ORBIT_tmpvar_1));
+      }
+      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
+				     (astring),
+				     sizeof(astring[_ORBIT_tmpvar_0]) *
+				     _ORBIT_tmpvar_1);
+      giop_send_buffer_write(_ORBIT_send_buffer);
+      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      _ORBIT_send_buffer = NULL;
+   }
+   {				/* demarshalling */
+      register guchar *_ORBIT_curptr;
+
+      _ORBIT_recv_buffer =
+	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+      if (!_ORBIT_recv_buffer)
+	 goto _ORBIT_system_exception;
+      _ORBIT_completion_status = CORBA_COMPLETED_YES;
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
+	  GIOP_NO_EXCEPTION) goto _ORBIT_msg_exception;
+      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
+	 _ORBIT_retval =
+	    ORBit_demarshal_object(_ORBIT_recv_buffer,
+				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
+				   connection->orb_data);
+	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 
+	    (*((guint32 *) & ((*anum)))) =
+	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));} else {
+	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
+	 _ORBIT_retval =
+	    ORBit_demarshal_object(_ORBIT_recv_buffer,
+				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
+				   connection->orb_data);
+	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
+	 (*anum) = *((CORBA_long *) _ORBIT_curptr);
+      }
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      return _ORBIT_retval;
+    _ORBIT_system_exception:
+      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
+				 _ORBIT_completion_status);
+      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+      giop_send_buffer_unuse(_ORBIT_send_buffer);
+      return _ORBIT_retval;
+    _ORBIT_msg_exception:
+      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
+	  GIOP_LOCATION_FORWARD) {
+	 if (_obj->forward_locations != NULL)
+	    ORBit_delete_profiles(_obj->forward_locations);
+	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+	 _cnx = ORBit_object_get_forwarded_connection(_obj);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+	 goto _ORBIT_retry_request;
+      } else {
+	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
+	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+	 return _ORBIT_retval;
+      }
+   }
+}
diff -urN linux-2.4.1/net/korbit/modules/Echo/server/echo.h linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo.h
--- linux-2.4.1/net/korbit/modules/Echo/server/echo.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Echo/server/echo.h	Thu Feb  1 16:36:57 2001
@@ -0,0 +1,77 @@
+/*
+ * This file was generated by orbit-idl - DO NOT EDIT!
+ */
+
+#include <glib.h>
+#define ORBIT_IDL_SERIAL 9
+#include <orb/orbit.h>
+
+#ifndef echo_H
+#define echo_H 1
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/** typedefs **/
+#if !defined(ORBIT_DECL_Echo) && !defined(_Echo_defined)
+#define ORBIT_DECL_Echo 1
+#define _Echo_defined 1
+#define Echo__free CORBA_Object__free
+   typedef CORBA_Object Echo;
+   extern CORBA_unsigned_long Echo__classid;
+#if !defined(TC_IMPL_TC_Echo_0)
+#define TC_IMPL_TC_Echo_0 'e'
+#define TC_IMPL_TC_Echo_1 'c'
+#define TC_IMPL_TC_Echo_2 'h'
+#define TC_IMPL_TC_Echo_3 'o'
+   extern const struct CORBA_TypeCode_struct TC_Echo_struct;
+#define TC_Echo ((CORBA_TypeCode)&TC_Echo_struct)
+#endif
+#endif
+
+/** POA structures **/
+   typedef struct
+   {
+      void *_private;
+      
+	 Echo(*echoString) (PortableServer_Servant _servant,
+			    const CORBA_char * astring, CORBA_long * anum,
+			    CORBA_Environment * ev);
+   }
+   POA_Echo__epv;
+   typedef struct
+   {
+      PortableServer_ServantBase__epv *_base_epv;
+      POA_Echo__epv *Echo_epv;
+   }
+   POA_Echo__vepv;
+   typedef struct
+   {
+      void *_private;
+      POA_Echo__vepv *vepv;
+   }
+   POA_Echo;
+   extern void POA_Echo__init(PortableServer_Servant servant,
+			      CORBA_Environment * ev);
+   extern void POA_Echo__fini(PortableServer_Servant servant,
+			      CORBA_Environment * ev);
+
+/** prototypes **/
+   Echo Echo_echoString(Echo _obj, const CORBA_char * astring,
+			CORBA_long * anum, CORBA_Environment * ev);
+
+   void _ORBIT_skel_Echo_echoString(POA_Echo * _ORBIT_servant,
+				    GIOPRecvBuffer * _ORBIT_recv_buffer,
+				    CORBA_Environment * ev,
+				    Echo(*_impl_echoString)
+				    (PortableServer_Servant _servant,
+				     const CORBA_char * astring,
+				     CORBA_long * anum,
+				     CORBA_Environment * ev));
+#ifdef __cplusplus
+}
+#endif				/* __cplusplus */
+
+#endif
+#undef ORBIT_IDL_SERIAL
diff -urN linux-2.4.1/net/korbit/modules/FileServer/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Entries
--- linux-2.4.1/net/korbit/modules/FileServer/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Entries	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,4 @@
+/FileServer.idl/1.3/Thu Feb  1 09:47:07 2001//
+/Makefile/1.2/Thu Feb  1 09:47:07 2001//
+/README/1.1/Thu Feb  1 09:47:07 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/FileServer/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Entries.Log
--- linux-2.4.1/net/korbit/modules/FileServer/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Entries.Log	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,4 @@
+A D/client////
+A D/server////
+A D/server-user////
+A D/wrapper////
diff -urN linux-2.4.1/net/korbit/modules/FileServer/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Repository
--- linux-2.4.1/net/korbit/modules/FileServer/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Repository	Thu Feb  1 11:47:07 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/FileServer
diff -urN linux-2.4.1/net/korbit/modules/FileServer/CVS/Root linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Root
--- linux-2.4.1/net/korbit/modules/FileServer/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/CVS/Root	Thu Feb  1 11:47:07 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/FileServer/FileServer.idl linux-2.4.1-korbit/net/korbit/modules/FileServer/FileServer.idl
--- linux-2.4.1/net/korbit/modules/FileServer/FileServer.idl	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/FileServer.idl	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,158 @@
+// -----------------------------------------------------------------------------
+// FileServer.idl
+// -----------------------------------------------------------------------------
+//
+// This file is used to define the Kernel CORBA API for accessing the filesystem
+// on a machine.  This defines mappings both to access the files in the kernel
+// and to implement a filesystem for the kernel.  This should probably be split
+// into two files eventually.
+//
+// Currently unimplemented: KernelAccessAPI::FileSystem::ReadDirectory
+//                          KernelAccessAPI::FileSystem::Select
+//                          KernelImplementationAPI::SuperBlock::getDiskQuotaOps
+//
+// -----------------------------------------------------------------------------
+
+
+// These are the exceptions that may be thrown and what they map to in the 
+// Linux kernel.  This interface is extended by other interfaces so that the
+// names don't have to be typedef'd into each interface that wants to use these
+// errors.
+//
+interface Errors {
+    exception IsDirectory {};              // EISDIR
+    exception PermissionDenied {};         // EACCES
+    exception FileExists {};               // EEXIST
+    exception FileNotFound {};             // ENOENT
+    exception IsNotDirectory {};           // ENOTDIR
+    exception ReadOnlyFile {};             // EROFS, ETXTBSY
+    exception RecursiveSymlink {};         // ELOOP
+    exception IsBusy {};                   // EBUSY
+    exception OtherError{};                // Misc other ones...
+};
+
+
+// -----------------------------------------------------------------------------
+// KernelAccessAPI Module - Allow user level programs to call into the kernel
+// -----------------------------------------------------------------------------
+
+module FileServer {
+  struct FileStatus {           // Corba equilivant of struct stat
+    long  DeviceNum;            // st_dev
+    long  InodeNum;             // st_ino
+    short Mode;                 // st_mode
+    short NumLinks;             // st_nlink
+    long  UserID;               // st_uid
+    long  GroupID;              // st_gid
+    long  DeviceType;           // st_rdev
+    unsigned long Size;         // st_size
+    unsigned long BlockSize;    // st_blksize
+    unsigned long NumBlocks;    // st_blocks;
+    unsigned long AccessTime;   // st_blocks;
+    unsigned long ModifiedTime; // st_blocks;
+    unsigned long ChangeTime;   // st_blocks;
+  };
+
+        typedef sequence<octet> buffer;
+        
+  // ---------------------------------------------------------------------------
+  // FileSystem Interface - Access to filesystem and File object factory
+  // ---------------------------------------------------------------------------
+  
+  interface File : Errors {
+    void Read(in long count, out buffer buf) 
+      raises (IsDirectory, OtherError);
+    void Write(in buffer buf) 
+      raises (OtherError);
+    void Close();
+
+    long FileControl(in long command) raises (OtherError);
+
+    FileStatus GetStatus() raises (OtherError);
+
+    void ChangeDirectoryTo()    // This implements fchdir...
+      raises (IsNotDirectory, PermissionDenied, OtherError);
+
+    enum SeekDirection { FromStart, FromCurrent, FromEnd };
+    long Seek(in long Offset, in SeekDirection Direction) raises (OtherError);
+
+    File Duplicate() raises (OtherError);
+  };
+
+
+
+  // ---------------------------------------------------------------------------
+  // FileSystem Interface - Access to filesystem and File object factory
+  // ---------------------------------------------------------------------------
+
+  interface FileSystem : Errors {
+
+    // -------------------------------------------------------------------------
+    // File Manipulation Routines
+    // -------------------------------------------------------------------------
+
+    File Open(in string Filename, in long openFlags, in short mode) 
+      raises (FileExists, IsDirectory, PermissionDenied, FileNotFound, 
+	      IsNotDirectory, ReadOnlyFile, RecursiveSymlink, OtherError);
+	      
+    File Create(in string Filename, in short mode)
+      raises (FileExists, IsDirectory, PermissionDenied, FileNotFound, 
+	      IsNotDirectory, ReadOnlyFile, RecursiveSymlink, OtherError);
+
+    void Link(in string FromPath, in string ToPath) 
+      raises (PermissionDenied, IsNotDirectory, RecursiveSymlink, FileExists);
+
+    void Unlink(in string Filename) 
+      raises (PermissionDenied, FileNotFound, IsNotDirectory, IsDirectory);
+
+    void Rename(in string OldName, in string NewName) 
+      raises (IsDirectory, FileExists, IsBusy, IsNotDirectory, PermissionDenied,
+	      RecursiveSymlink);
+
+    void ReadLink(in string Linkname, out string LinkValue) 
+      raises (FileNotFound, PermissionDenied, RecursiveSymlink, OtherError);
+
+
+    FileStatus GetStatus(in string Filename) 
+      raises (FileNotFound, PermissionDenied, RecursiveSymlink, IsNotDirectory, 
+	      OtherError);
+
+    FileStatus GetLinkStatus(in string Filename) 
+      raises (FileNotFound, PermissionDenied, RecursiveSymlink, IsNotDirectory, 
+	      OtherError);
+
+
+    // -------------------------------------------------------------------------
+    // Directory Manipulation Routines
+    // -------------------------------------------------------------------------
+
+    void MakeDirectory(in string PathName, in short mode)
+      raises (FileExists, PermissionDenied, FileNotFound, IsNotDirectory, 
+	      ReadOnlyFile, RecursiveSymlink, OtherError);
+
+    void RemoveDirectory(in string PathName)
+      raises (PermissionDenied, FileNotFound, IsNotDirectory);
+
+    // ChangeDirectory returns CWD so that you can implement getcwd as
+    //  { return ChangeDirectory("."); }
+    string ChangeDirectory(in string PathName) 
+      raises (IsNotDirectory, PermissionDenied, FileNotFound, RecursiveSymlink);
+
+
+    // -------------------------------------------------------------------------
+    // Special Purpose Routines...
+    // -------------------------------------------------------------------------
+
+    void MakeNode(in string FileName, in short Mode, in long DeviceNum)
+      raises (PermissionDenied, FileExists, FileNotFound, IsNotDirectory, 
+	      RecursiveSymlink);
+    
+    void Mount(in string DeviceFile, in string Location, in string FSType,
+	       in long Flags)
+      raises (PermissionDenied, FileNotFound, IsBusy, IsNotDirectory);
+
+    void Unmount(in string Filename)
+      raises (PermissionDenied, FileNotFound, IsBusy);
+  };
+
+};
diff -urN linux-2.4.1/net/korbit/modules/FileServer/Makefile linux-2.4.1-korbit/net/korbit/modules/FileServer/Makefile
--- linux-2.4.1/net/korbit/modules/FileServer/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/Makefile	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,11 @@
+#
+# Makefile for KORBit/modules/CorbaFS
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+
+subdir-$(CONFIG_CORBA_FILESERVER) := server
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/modules/FileServer/README linux-2.4.1-korbit/net/korbit/modules/FileServer/README
--- linux-2.4.1/net/korbit/modules/FileServer/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/README	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,8 @@
+This interface lets you export file related syscalls through CORBA.  This is
+genuinely useful, however, when you use the 'wrapper' library, that can be 
+LD_PRELOADED before you run your application.  This allows you to forward 
+filesystem calls through CORBA without having to modify your application.
+
+Being able to forward filesystem calls though CORBA, of course, means that 
+you can attach to any remote machine you want.  :)
+
diff -urN linux-2.4.1/net/korbit/modules/FileServer/client/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/FileServer/client/CVS/Entries
--- linux-2.4.1/net/korbit/modules/FileServer/client/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/client/CVS/Entries	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,4 @@
+/FileServer-client.cpp/1.1/Thu Feb  1 09:47:07 2001//
+/Makefile/1.1/Thu Feb  1 09:47:07 2001//
+/README/1.1/Thu Feb  1 09:47:07 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/FileServer/client/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/FileServer/client/CVS/Repository
--- linux-2.4.1/net/korbit/modules/FileServer/client/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/client/CVS/Repository	Thu Feb  1 11:47:07 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/FileServer/client
diff -urN linux-2.4.1/net/korbit/modules/FileServer/client/CVS/Root linux-2.4.1-korbit/net/korbit/modules/FileServer/client/CVS/Root
--- linux-2.4.1/net/korbit/modules/FileServer/client/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/client/CVS/Root	Thu Feb  1 11:47:07 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/FileServer/client/FileServer-client.cpp linux-2.4.1-korbit/net/korbit/modules/FileServer/client/FileServer-client.cpp
--- linux-2.4.1/net/korbit/modules/FileServer/client/FileServer-client.cpp	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/client/FileServer-client.cpp	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,78 @@
+#include <OB/CORBA.h>
+#include <OB/Util.h>
+#include <OB/CosNaming.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "FileServer.h"
+
+int main(int argc, char* argv[])
+{
+    if (argc < 3)
+    {
+        cout << "Usage : " << argv[0] << " ior filename" << endl;
+        exit(1);
+    }
+    
+    cout << "FileServer client initializing" << endl;
+
+    CORBA_ORB_var orb = CORBA_ORB_init(argc, argv);
+    cout << "ORB initialized" << endl;
+
+    try 
+    {
+        CORBA_Object_var obj = orb->string_to_object( argv[1] );
+        assert(!CORBA_is_nil(obj));
+        cout << "got object... " << orb->object_to_string(obj) << endl;
+        
+        FileServer_FileSystem_var fs = FileServer_FileSystem::_narrow(obj);
+        assert(!CORBA_is_nil(fs));
+        cout << "it's a FileServer!" << endl;
+        
+        obj = fs->Open(argv[2], O_RDONLY, 0);
+        assert(!CORBA_is_nil(obj));
+        cout << "got object... " << orb->object_to_string(obj) << endl;
+        
+        FileServer_File_var file = FileServer_File::_narrow(obj);
+        assert(!CORBA_is_nil(file));
+        cout << "it's a FileServer_File!" << endl;
+        
+        FileServer_buffer *buf = new FileServer_buffer;
+        cout << "reading 1000 bytes" << endl;
+        file->Read(1000, buf);
+        
+        cout << "got " << buf->length() << " bytes" << endl;
+        cout << buf->data() << endl;
+    
+        file->Close();
+        
+        delete buf;
+    }
+    catch (const CORBA_SystemException& ex) {
+        OBPrintException(ex);
+        return 1;
+    }
+    catch (const Errors::FileNotFound& ex) {
+        cout << "ERROR : File not found" << endl;
+        return 1;
+    }
+    catch (const Errors::PermissionDenied& ex) {
+        cout << "ERROR : Permission denied" << endl;
+        return 1;
+    }
+    catch (const Errors::IsDirectory& ex) {
+        cout << "ERROR : Is directory" << endl;
+        return 1;
+    }
+    catch (const Errors::OtherError& ex) {
+        cout << "ERROR : Other error" << endl;
+        return 1;
+    }
+    catch (const CORBA_UserException& ex)
+    {
+        cout << "ERROR : Uncaught exception" << endl;
+        return 1;
+    }
+}
diff -urN linux-2.4.1/net/korbit/modules/FileServer/client/Makefile linux-2.4.1-korbit/net/korbit/modules/FileServer/client/Makefile
--- linux-2.4.1/net/korbit/modules/FileServer/client/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/client/Makefile	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,32 @@
+CC = CC -mt -pta
+OBDIR = /home/class/cs423/local
+IDL = $(OBDIR)/bin/idl
+CPPFLAGS = -I. -I$(OBDIR)/include
+LDFLAGS = -L$(OBDIR)/lib 
+LIBS = -lCosNaming -lOB -lJTC -lsocket -lnsl -lposix4
+
+all: FileServer-client
+
+FileServer-client: FileServer.o FileServer-client.o
+	$(CC) $(LDFLAGS) -o FileServer-client FileServer-client.o FileServer.o $(LIBS)
+
+nameserv:
+	nameserv -i -OAport 10000
+
+FileServer.h FileServer.cpp: ../FileServer.idl
+	rm -f FileServer.cpp FileServer.h
+	rm -f FileServer_skel.h FileServer_skel.cpp
+	$(IDL) ../FileServer.idl
+
+FileServer_skel.cpp FileServer_skel.h: FileServer.cpp
+
+%.o: %.cpp
+	$(CC) $(CPPFLAGS) -c $<
+
+clean:
+	rm -f FileServer-client *.o *~
+
+realclean: clean
+	rm -f FileServer.h FileServer.cpp
+	rm -f FileServer_skel.h FileServer_skel.cpp
+	rm -rf SunWS_cache
diff -urN linux-2.4.1/net/korbit/modules/FileServer/client/README linux-2.4.1-korbit/net/korbit/modules/FileServer/client/README
--- linux-2.4.1/net/korbit/modules/FileServer/client/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/client/README	Thu Feb  1 11:47:07 2001
@@ -0,0 +1,4 @@
+Very minimal test of the FileServer capability.
+
+ORB: Orbacus
+
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/FileServer/server/CVS/Entries
--- linux-2.4.1/net/korbit/modules/FileServer/server/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/CVS/Entries	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,6 @@
+/FileServer-server.c/1.2/Thu Feb  1 09:47:08 2001//
+/FileServer-skelimpl.c/1.8/Thu Feb  1 09:47:08 2001//
+/Makefile/1.3/Thu Feb  1 09:47:08 2001//
+/Makefile.user/1.4/Thu Feb  1 09:47:08 2001//
+/README/1.1/Thu Feb  1 09:47:08 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/FileServer/server/CVS/Repository
--- linux-2.4.1/net/korbit/modules/FileServer/server/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/CVS/Repository	Thu Feb  1 11:47:08 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/FileServer/server
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/CVS/Root linux-2.4.1-korbit/net/korbit/modules/FileServer/server/CVS/Root
--- linux-2.4.1/net/korbit/modules/FileServer/server/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/CVS/Root	Thu Feb  1 11:47:08 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/FileServer-server.c linux-2.4.1-korbit/net/korbit/modules/FileServer/server/FileServer-server.c
--- linux-2.4.1/net/korbit/modules/FileServer/server/FileServer-server.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/FileServer-server.c	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include "FileServer-skelimpl.c"
+#include "korbit.h"
+
+CORBA_ORB               orb;
+PortableServer_POA      poa;
+CORBA_Environment       *ev;
+PortableServer_ObjectId *objid;
+
+#ifdef __KERNEL__
+int __init FileServer_init(void) {
+#else
+int main(int argc, char *argv[]) {
+#endif
+        FileServer_FileSystem        fs;
+        impl_POA_FileServer_FileSystem *fs_impl;
+        
+        PortableServer_POAManager pm;
+#ifdef __KERNEL__        
+	int argc = 1; 
+        char *argv[] = { "server", 0 };
+#endif
+        ev = g_new0(CORBA_Environment,1);
+        
+        CORBA_exception_init(ev);
+        
+        orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", ev);
+        poa = (PortableServer_POA)
+                CORBA_ORB_resolve_initial_references(orb,
+                                                     "RootPOA", 
+                                                     ev);
+        fs = impl_FileServer_FileSystem__create(poa, ev);
+
+        pm = PortableServer_POA__get_the_POAManager(poa, ev);
+        PortableServer_POAManager_activate(pm, ev);
+
+        fs_impl = PortableServer_POA_reference_to_servant( poa, fs, ev );
+        objid = PortableServer_POA_servant_to_id( poa, fs_impl, ev );
+
+        korbit_register_ior("FileServer-server", fs, orb, ev);
+
+        CORBA_ORB_run(orb, ev);
+
+        return 0;
+}
+
+#ifdef __KERNEL__
+void FileServer_exit(void) 
+{ 
+        PortableServer_POA_deactivate_object(poa, objid, ev);
+        remove_proc_entry("corba/FileServer-server", 0);
+        printf("FileServer_exit()\n"); 
+}
+
+module_init(FileServer_init)
+module_exit(FileServer_exit)
+#endif
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/FileServer-skelimpl.c linux-2.4.1-korbit/net/korbit/modules/FileServer/server/FileServer-skelimpl.c
--- linux-2.4.1/net/korbit/modules/FileServer/server/FileServer-skelimpl.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/FileServer-skelimpl.c	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,804 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "FileServer.h"
+
+static void set_exception(int errno, CORBA_Environment *ev)
+{
+        switch (errno)
+        { 
+        case ENOENT:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_FileNotFound,
+                                    Errors_FileNotFound__alloc());
+                break;
+        case EEXIST:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_FileExists,
+                                    Errors_FileExists__alloc());
+                break;
+        case EACCES:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_PermissionDenied,
+                                    Errors_PermissionDenied__alloc());
+                break;
+        case EISDIR:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_IsDirectory,
+                                    Errors_IsDirectory__alloc());
+                break;
+        case ENOTDIR:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_IsNotDirectory,
+                                    Errors_IsNotDirectory__alloc());
+                break;
+        case EROFS:
+        case ETXTBSY:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_ReadOnlyFile,
+                                    Errors_ReadOnlyFile__alloc());
+                break;
+        case ELOOP:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_RecursiveSymlink,
+                                    Errors_RecursiveSymlink__alloc());
+                break;
+        case EBUSY:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_IsBusy,
+                                    Errors_IsBusy__alloc());
+                break;
+        default:
+                CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+                                    ex_Errors_OtherError,
+                                    Errors_OtherError__alloc());
+                break;
+        }
+}
+
+
+/*** App-specific servant structures ***/
+typedef struct
+{
+   POA_Errors servant;
+   PortableServer_POA poa;
+
+}
+impl_POA_Errors;
+
+typedef struct
+{
+   POA_FileServer_File servant;
+   PortableServer_POA poa;
+
+   int fd;
+}
+impl_POA_FileServer_File;
+
+typedef struct
+{
+   POA_FileServer_FileSystem servant;
+   PortableServer_POA poa;
+
+}
+impl_POA_FileServer_FileSystem;
+
+/*** Implementation stub prototypes ***/
+static void impl_Errors__destroy(impl_POA_Errors * servant,
+				 CORBA_Environment * ev);
+
+static void impl_FileServer_File__destroy(impl_POA_FileServer_File * servant,
+					  CORBA_Environment * ev);
+static void
+impl_FileServer_File_Read(impl_POA_FileServer_File * servant,
+			  CORBA_long count,
+			  FileServer_buffer ** buf, CORBA_Environment * ev);
+
+static void
+impl_FileServer_File_Write(impl_POA_FileServer_File * servant,
+			   FileServer_buffer * buf, CORBA_Environment * ev);
+
+static void
+impl_FileServer_File_Close(impl_POA_FileServer_File * servant,
+			   CORBA_Environment * ev);
+
+static CORBA_long
+impl_FileServer_File_FileControl(impl_POA_FileServer_File * servant,
+				 CORBA_long command, CORBA_Environment * ev);
+
+static FileServer_FileStatus
+impl_FileServer_File_GetStatus(impl_POA_FileServer_File * servant,
+			       CORBA_Environment * ev);
+
+static void
+impl_FileServer_File_ChangeDirectoryTo(impl_POA_FileServer_File * servant,
+				       CORBA_Environment * ev);
+
+static CORBA_long
+impl_FileServer_File_Seek(impl_POA_FileServer_File * servant,
+			  CORBA_long Offset,
+			  FileServer_File_SeekDirection Direction,
+			  CORBA_Environment * ev);
+
+static FileServer_File
+impl_FileServer_File_Duplicate(impl_POA_FileServer_File * servant,
+			       CORBA_Environment * ev);
+
+static void impl_FileServer_FileSystem__destroy(impl_POA_FileServer_FileSystem
+						* servant,
+
+						CORBA_Environment * ev);
+static FileServer_File
+impl_FileServer_FileSystem_Open(impl_POA_FileServer_FileSystem * servant,
+				CORBA_char * Filename, CORBA_long openFlags,
+				CORBA_short mode, CORBA_Environment * ev);
+
+static FileServer_File
+impl_FileServer_FileSystem_Create(impl_POA_FileServer_FileSystem * servant,
+				  CORBA_char * Filename,
+				  CORBA_short mode, CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_Link(impl_POA_FileServer_FileSystem * servant,
+				CORBA_char * FromPath,
+				CORBA_char * ToPath, CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_Unlink(impl_POA_FileServer_FileSystem * servant,
+				  CORBA_char * Filename,
+
+				  CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_Rename(impl_POA_FileServer_FileSystem * servant,
+				  CORBA_char * OldName,
+				  CORBA_char * NewName,
+
+				  CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_ReadLink(impl_POA_FileServer_FileSystem * servant,
+				    CORBA_char * Linkname,
+				    CORBA_char ** LinkValue,
+				    CORBA_Environment * ev);
+
+static FileServer_FileStatus
+impl_FileServer_FileSystem_GetStatus(impl_POA_FileServer_FileSystem * servant,
+				     CORBA_char * Filename,
+				     CORBA_Environment * ev);
+
+static FileServer_FileStatus
+impl_FileServer_FileSystem_GetLinkStatus(impl_POA_FileServer_FileSystem *
+					 servant, CORBA_char * Filename,
+					 CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_MakeDirectory(impl_POA_FileServer_FileSystem *
+					 servant, CORBA_char * PathName,
+                                         CORBA_short mode,
+					 CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_RemoveDirectory(impl_POA_FileServer_FileSystem *
+					   servant, CORBA_char * PathName,
+					   CORBA_Environment * ev);
+
+static CORBA_char
+   *impl_FileServer_FileSystem_ChangeDirectory(impl_POA_FileServer_FileSystem
+					       * servant,
+					       CORBA_char * PathName,
+					       CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_MakeNode(impl_POA_FileServer_FileSystem * servant,
+				    CORBA_char * FileName,
+				    CORBA_short Mode,
+				    CORBA_long DeviceNum,
+
+				    CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_Mount(impl_POA_FileServer_FileSystem * servant,
+				 CORBA_char * DeviceFile,
+				 CORBA_char * Location,
+				 CORBA_char * FSType,
+				 CORBA_long Flags, CORBA_Environment * ev);
+
+static void
+impl_FileServer_FileSystem_Unmount(impl_POA_FileServer_FileSystem * servant,
+				   CORBA_char * Filename,
+
+				   CORBA_Environment * ev);
+
+/*** epv structures ***/
+static PortableServer_ServantBase__epv impl_Errors_base_epv = {
+   NULL,			/* _private data */
+   NULL,			/* finalize routine */
+   NULL,			/* default_POA routine */
+};
+static POA_Errors__epv impl_Errors_epv = {
+   NULL,			/* _private */
+
+};
+
+static PortableServer_ServantBase__epv impl_FileServer_File_base_epv = {
+   NULL,			/* _private data */
+   NULL,			/* finalize routine */
+   NULL,			/* default_POA routine */
+};
+static POA_FileServer_File__epv impl_FileServer_File_epv = {
+   NULL,			/* _private */
+   (gpointer) & impl_FileServer_File_Read,
+
+   (gpointer) & impl_FileServer_File_Write,
+
+   (gpointer) & impl_FileServer_File_Close,
+
+   (gpointer) & impl_FileServer_File_FileControl,
+
+   (gpointer) & impl_FileServer_File_GetStatus,
+
+   (gpointer) & impl_FileServer_File_ChangeDirectoryTo,
+
+   (gpointer) & impl_FileServer_File_Seek,
+
+   (gpointer) & impl_FileServer_File_Duplicate,
+
+};
+static POA_Errors__epv impl_FileServer_File_Errors_epv = {
+   NULL,			/* _private */
+};
+static PortableServer_ServantBase__epv impl_FileServer_FileSystem_base_epv = {
+   NULL,			/* _private data */
+   NULL,			/* finalize routine */
+   NULL,			/* default_POA routine */
+};
+static POA_FileServer_FileSystem__epv impl_FileServer_FileSystem_epv = {
+   NULL,			/* _private */
+   (gpointer) & impl_FileServer_FileSystem_Open,
+
+   (gpointer) & impl_FileServer_FileSystem_Create,
+
+   (gpointer) & impl_FileServer_FileSystem_Link,
+
+   (gpointer) & impl_FileServer_FileSystem_Unlink,
+
+   (gpointer) & impl_FileServer_FileSystem_Rename,
+
+   (gpointer) & impl_FileServer_FileSystem_ReadLink,
+
+   (gpointer) & impl_FileServer_FileSystem_GetStatus,
+
+   (gpointer) & impl_FileServer_FileSystem_GetLinkStatus,
+
+   (gpointer) & impl_FileServer_FileSystem_MakeDirectory,
+
+   (gpointer) & impl_FileServer_FileSystem_RemoveDirectory,
+
+   (gpointer) & impl_FileServer_FileSystem_ChangeDirectory,
+
+   (gpointer) & impl_FileServer_FileSystem_MakeNode,
+
+   (gpointer) & impl_FileServer_FileSystem_Mount,
+
+   (gpointer) & impl_FileServer_FileSystem_Unmount,
+
+};
+static POA_Errors__epv impl_FileServer_FileSystem_Errors_epv = {
+   NULL,			/* _private */
+};
+
+/*** vepv structures ***/
+static POA_Errors__vepv impl_Errors_vepv = {
+   &impl_Errors_base_epv,
+   &impl_Errors_epv,
+};
+
+static POA_FileServer_File__vepv impl_FileServer_File_vepv = {
+   &impl_FileServer_File_base_epv,
+   &impl_FileServer_File_Errors_epv,
+   &impl_FileServer_File_epv,
+};
+static POA_FileServer_FileSystem__vepv impl_FileServer_FileSystem_vepv = {
+   &impl_FileServer_FileSystem_base_epv,
+   &impl_FileServer_FileSystem_Errors_epv,
+   &impl_FileServer_FileSystem_epv,
+};
+
+/*** Stub implementations ***/
+static Errors
+impl_Errors__create(PortableServer_POA poa, CORBA_Environment * ev)
+{
+   Errors retval;
+   impl_POA_Errors *newservant;
+   PortableServer_ObjectId *objid;
+
+   newservant = g_new0(impl_POA_Errors, 1);
+   newservant->servant.vepv = &impl_Errors_vepv;
+   newservant->poa = poa;
+   POA_Errors__init((PortableServer_Servant) newservant, ev);
+   objid = PortableServer_POA_activate_object(poa, newservant, ev);
+   CORBA_free(objid);
+   retval = PortableServer_POA_servant_to_reference(poa, newservant, ev);
+
+   return retval;
+}
+
+static void
+impl_Errors__destroy(impl_POA_Errors * servant, CORBA_Environment * ev)
+{
+   PortableServer_ObjectId *objid;
+
+   objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev);
+   PortableServer_POA_deactivate_object(servant->poa, objid, ev);
+   CORBA_free(objid);
+
+   POA_Errors__fini((PortableServer_Servant) servant, ev);
+   g_free(servant);
+}
+
+static FileServer_File
+impl_FileServer_File__create(PortableServer_POA poa, CORBA_Environment * ev)
+{
+   FileServer_File retval;
+   impl_POA_FileServer_File *newservant;
+   PortableServer_ObjectId *objid;
+
+   newservant = g_new0(impl_POA_FileServer_File, 1);
+   newservant->servant.vepv = &impl_FileServer_File_vepv;
+   newservant->poa = poa;
+   newservant->fd = -1;
+   
+   POA_FileServer_File__init((PortableServer_Servant) newservant, ev);
+   objid = PortableServer_POA_activate_object(poa, newservant, ev);
+   CORBA_free(objid);
+   retval = PortableServer_POA_servant_to_reference(poa, newservant, ev);
+
+   return retval;
+}
+
+static void
+impl_FileServer_File__destroy(impl_POA_FileServer_File * servant,
+			      CORBA_Environment * ev)
+{
+   PortableServer_ObjectId *objid;
+
+   objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev);
+   PortableServer_POA_deactivate_object(servant->poa, objid, ev);
+   CORBA_free(objid);
+
+   POA_FileServer_File__fini((PortableServer_Servant) servant, ev);
+   g_free(servant);
+}
+
+static void
+impl_FileServer_File_Read(impl_POA_FileServer_File * servant,
+			  CORBA_long count,
+			  FileServer_buffer ** buf, CORBA_Environment * ev)
+{
+        size_t num_read;
+
+        *buf = FileServer_buffer__alloc();
+        (*buf)->_maximum = count;
+        (*buf)->_buffer = CORBA_octet_allocbuf(count);
+        (*buf)->_length = 0;
+        
+        printf("File->Read(%d, char *buf)\n", count);
+
+        if (servant->fd == -1) /* Trying to read from a closed file */
+        {
+                printf("File->Read ERROR : fd == -1\n");
+                set_exception(EBADF, ev);
+                return;
+        }
+
+        num_read = read(servant->fd, (*buf)->_buffer, count);
+        if (num_read == -1)
+        {
+                printf("File->Read ERROR : %d\n", errno);
+                set_exception(errno, ev);
+                return;
+        } 
+
+        (*buf)->_length = num_read;
+}
+
+static void
+impl_FileServer_File_Write(impl_POA_FileServer_File * servant,
+			   FileServer_buffer * buf, CORBA_Environment * ev)
+{
+	printf("UNIMP: FileServer::File::Write called and unimplemented\n");
+}
+
+static void
+impl_FileServer_File_Close(impl_POA_FileServer_File * servant,
+			   CORBA_Environment * ev)
+{
+        printf("File->Close()\n");
+
+        if (servant->fd == -1) /* This should never happen !?! */
+        {
+                printf("File->Close ERROR : fd == -1\n");
+                set_exception(EBADF, ev);
+                return;
+        }
+        
+        close(servant->fd);
+        servant->fd = 0;
+        impl_FileServer_File__destroy(servant, ev);
+}
+
+static CORBA_long
+impl_FileServer_File_FileControl(impl_POA_FileServer_File * servant,
+				 CORBA_long command, CORBA_Environment * ev)
+{
+   CORBA_long retval;
+
+   if (servant->fd == -1)
+   {
+           printf("File->FileControl ERROR : fd == -1\n");
+           set_exception(EBADF, ev);
+           return -1;
+   }
+   
+   retval = fcntl(servant->fd, command, 0); /* FIXME arg? */
+   if (retval == -1)
+   {
+           printf("File->FileControl ERROR : %d\n", errno);
+           set_exception(errno, ev);
+   }
+
+   return retval;
+}
+
+
+FileServer_FileStatus
+stat2FileStatus(struct stat buf) 
+{
+        FileServer_FileStatus retval;
+        
+        retval.DeviceNum    = buf.st_dev;
+        retval.InodeNum     = buf.st_ino;
+        retval.Mode         = buf.st_mode;
+        retval.NumLinks     = buf.st_nlink;
+        retval.UserID       = buf.st_uid;
+        retval.GroupID      = buf.st_gid;
+        retval.DeviceType   = buf.st_rdev;
+        retval.Size         = buf.st_size;
+        retval.BlockSize    = buf.st_blksize;
+        retval.NumBlocks    = buf.st_blocks;
+        retval.AccessTime   = buf.st_atime;
+        retval.ModifiedTime = buf.st_mtime;
+        retval.ChangeTime   = buf.st_ctime;
+
+        return retval;
+}
+
+
+static FileServer_FileStatus
+impl_FileServer_File_GetStatus(impl_POA_FileServer_File * servant,
+			       CORBA_Environment * ev)
+{
+   FileServer_FileStatus retval;
+
+   struct stat buf;
+   int res;
+   
+   if (servant->fd == -1)
+   {
+           printf("File->GetStatus ERROR : fd == -1\n");
+           set_exception(EBADF, ev);
+           return retval;
+   }
+   
+   res = fstat(servant->fd, &buf);
+   if (res == -1)
+   {
+           printf("File->GetStatus ERROR : %d\n", errno);
+           set_exception(errno, ev);
+           return retval;
+   }
+
+   retval = stat2FileStatus(buf);
+
+   return retval;
+}
+
+static void
+impl_FileServer_File_ChangeDirectoryTo(impl_POA_FileServer_File * servant,
+				       CORBA_Environment * ev)
+{
+  printf("UNIMP: impl_FileServer_File_ChangeDirectoryTo\n");
+}
+
+static CORBA_long
+impl_FileServer_File_Seek(impl_POA_FileServer_File * servant,
+			  CORBA_long Offset,
+			  FileServer_File_SeekDirection Direction,
+			  CORBA_Environment * ev)
+{
+   CORBA_long retval = -1;
+   int whence;
+   
+   if (servant->fd == -1)
+   {
+           printf("File->Seek ERROR : fd == -1\n");
+           set_exception(EBADF, ev);
+           return retval;
+   }
+   
+   switch (Direction)
+   {
+   case FileServer_File_FromStart :
+           whence = SEEK_SET;
+           break;
+   case FileServer_File_FromCurrent :
+           whence = SEEK_CUR;
+           break;
+   case FileServer_File_FromEnd :
+           whence = SEEK_END;
+           break;
+   default :
+           set_exception(EINVAL, ev);
+           return retval;
+   }
+   
+   retval = lseek(servant->fd, Offset, whence);
+   if (retval == -1)
+   {
+           printf("File->Seek ERROR : %d\n", errno);
+           set_exception(errno, ev);
+   }
+   
+   return retval;
+}
+
+static FileServer_File
+impl_FileServer_File_Duplicate(impl_POA_FileServer_File * servant,
+			       CORBA_Environment * ev)
+{
+   FileServer_File retval;
+   printf("UNIMP: impl_FileServer_File_Duplicate\n");
+   return retval;
+}
+
+static FileServer_FileSystem
+impl_FileServer_FileSystem__create(PortableServer_POA poa,
+				   CORBA_Environment * ev)
+{
+   FileServer_FileSystem retval;
+   impl_POA_FileServer_FileSystem *newservant;
+   PortableServer_ObjectId *objid;
+
+   newservant = g_new0(impl_POA_FileServer_FileSystem, 1);
+   newservant->servant.vepv = &impl_FileServer_FileSystem_vepv;
+   newservant->poa = poa;
+   POA_FileServer_FileSystem__init((PortableServer_Servant) newservant, ev);
+   objid = PortableServer_POA_activate_object(poa, newservant, ev);
+   CORBA_free(objid);
+   retval = PortableServer_POA_servant_to_reference(poa, newservant, ev);
+
+   return retval;
+}
+
+static void
+impl_FileServer_FileSystem__destroy(impl_POA_FileServer_FileSystem * servant,
+				    CORBA_Environment * ev)
+{
+   PortableServer_ObjectId *objid;
+
+   objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev);
+   PortableServer_POA_deactivate_object(servant->poa, objid, ev);
+   CORBA_free(objid);
+
+   POA_FileServer_FileSystem__fini((PortableServer_Servant) servant, ev);
+   g_free(servant);
+}
+
+static FileServer_File
+impl_FileServer_FileSystem_Open(impl_POA_FileServer_FileSystem * servant,
+				CORBA_char * Filename,
+				CORBA_long openFlags,
+				CORBA_short mode, CORBA_Environment * ev)
+{
+   FileServer_File retval = CORBA_OBJECT_NIL;
+
+   impl_POA_FileServer_File *file;
+
+   printf("FileSystem->Open(%s,%x)\n", Filename, openFlags);
+   
+   retval = impl_FileServer_File__create(servant->poa, ev);
+
+   file = PortableServer_POA_reference_to_servant( servant->poa, retval, ev );
+   file->fd = open(Filename, openFlags, mode);
+
+   if (file->fd == -1) {
+           printf("FileSystem->Open ERROR : %d\n", errno);
+           set_exception(errno, ev);
+   }
+
+   return retval;
+}
+
+static FileServer_File
+impl_FileServer_FileSystem_Create(impl_POA_FileServer_FileSystem * servant,
+				  CORBA_char * Filename,
+				  CORBA_short mode, CORBA_Environment * ev)
+{
+   FileServer_File retval = CORBA_OBJECT_NIL;
+
+   impl_POA_FileServer_File *file;
+
+   printf("FileSystem->Create(%s,%x)\n", Filename, mode);
+   
+   retval = impl_FileServer_File__create(servant->poa, ev);
+
+   file = PortableServer_POA_reference_to_servant( servant->poa, retval, ev );
+   file->fd = creat(Filename, mode);
+
+   if (file->fd == -1) {
+           printf("FileSystem->Create ERROR : %d\n", errno);
+           set_exception(errno, ev);
+   }
+
+   return retval;
+}
+
+static void
+impl_FileServer_FileSystem_Link(impl_POA_FileServer_FileSystem * servant,
+				CORBA_char * FromPath,
+				CORBA_char * ToPath, CORBA_Environment * ev)
+{
+   printf("UNIMP: impl_FileServer_FileSystem_Link\n");
+}
+
+static void
+impl_FileServer_FileSystem_Unlink(impl_POA_FileServer_FileSystem * servant,
+				  CORBA_char * Filename,
+				  CORBA_Environment * ev)
+{
+   printf("UNIMP: impl_FileServer_FileSystem_Unlink\n");
+}
+
+static void
+impl_FileServer_FileSystem_Rename(impl_POA_FileServer_FileSystem * servant,
+				  CORBA_char * OldName,
+				  CORBA_char * NewName,
+				  CORBA_Environment * ev)
+{
+   printf("UNIMP: impl_FileServer_FileSystem_Rename\n");
+}
+
+static void
+impl_FileServer_FileSystem_ReadLink(impl_POA_FileServer_FileSystem * servant,
+				    CORBA_char * Linkname,
+				    CORBA_char ** LinkValue,
+				    CORBA_Environment * ev)
+{
+        char tmp[PATH_MAX + 1];
+        int res, len;
+        
+        printf("FileSystem->ReadLink(%s, value)\n", Linkname);
+        
+        res = readlink(Linkname, tmp, PATH_MAX);
+        if (res == -1)
+        {
+                set_exception(errno, ev);
+                return;
+        }
+        
+        len = strlen(tmp);
+        *LinkValue = (char *)malloc(len * sizeof(char));
+        memcpy(*LinkValue, tmp, len);
+        (*LinkValue)[len] = '\0';
+}
+
+static FileServer_FileStatus
+impl_FileServer_FileSystem_GetStatus(impl_POA_FileServer_FileSystem * servant,
+				     CORBA_char * Filename,
+				     CORBA_Environment * ev)
+{
+   FileServer_FileStatus retval;
+   struct stat buf;
+   int res;
+
+   printf("FileSystem->GetStatus(%s)\n", Filename);
+
+   res = stat(Filename, &buf);
+
+   if (res == -1)
+   {
+           printf("FileSystem->GetStatus(%s)\n", Filename);
+           set_exception(errno, ev);
+           return retval;
+   }
+
+   retval = stat2FileStatus(buf);
+
+   return retval;
+}
+
+static FileServer_FileStatus
+impl_FileServer_FileSystem_GetLinkStatus(impl_POA_FileServer_FileSystem *
+					 servant, CORBA_char * Filename,
+					 CORBA_Environment * ev)
+{
+   FileServer_FileStatus retval;
+   struct stat buf;
+   int res;
+
+   printf("FileSystem->GetLinkStatus(%s)\n", Filename);
+
+   res = lstat(Filename, &buf);
+
+   if (res == -1)
+   {
+           printf("FileSystem->GetLinkStatus(%s)\n", Filename);
+           set_exception(errno, ev);
+           return retval;
+   }
+   
+   retval = stat2FileStatus(buf);
+
+   return retval;
+}
+
+static void
+impl_FileServer_FileSystem_MakeDirectory(impl_POA_FileServer_FileSystem *
+					 servant, CORBA_char * PathName,
+                                         CORBA_short mode,
+					 CORBA_Environment * ev)
+{
+  printf("UNIMP: impl_FileServer_FileSystem_MakeDirectory\n");
+}
+
+static void
+impl_FileServer_FileSystem_RemoveDirectory(impl_POA_FileServer_FileSystem *
+					   servant, CORBA_char * PathName,
+					   CORBA_Environment * ev)
+{
+  printf("UNIMP: impl_FileServer_FileSystem_RemoveDirectory\n");
+}
+
+static CORBA_char *
+impl_FileServer_FileSystem_ChangeDirectory(impl_POA_FileServer_FileSystem *
+					   servant, CORBA_char * PathName,
+					   CORBA_Environment * ev)
+{
+   CORBA_char *retval;
+   printf("UNIMP: impl_FileServer_FileSystem_ChangeDirectory\n");
+   return retval;
+}
+
+static void
+impl_FileServer_FileSystem_MakeNode(impl_POA_FileServer_FileSystem * servant,
+				    CORBA_char * FileName,
+				    CORBA_short Mode,
+				    CORBA_long DeviceNum,
+				    CORBA_Environment * ev)
+{
+  printf("UNIMP: impl_FileServer_FileSystem_MakeNode\n");
+}
+
+static void
+impl_FileServer_FileSystem_Mount(impl_POA_FileServer_FileSystem * servant,
+				 CORBA_char * DeviceFile,
+				 CORBA_char * Location,
+				 CORBA_char * FSType,
+				 CORBA_long Flags, CORBA_Environment * ev)
+{
+  printf("UNIMP: impl_FileServer_FileSystem_Mount: ARE YOU CRAZY!?!?\n");
+}
+
+static void
+impl_FileServer_FileSystem_Unmount(impl_POA_FileServer_FileSystem * servant,
+				   CORBA_char * Filename,
+				   CORBA_Environment * ev)
+{
+  printf("UNIMP: impl_FileServer_FileSystem_Unmount: Ha ha ha funny guy!\n");
+}
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/Makefile linux-2.4.1-korbit/net/korbit/modules/FileServer/server/Makefile
--- linux-2.4.1/net/korbit/modules/FileServer/server/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/Makefile	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,20 @@
+#
+# Makefile for KORBit / FileServer
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := corba-fileserver-server.o
+
+obj-y := FileServer-common.o FileServer-skels.o FileServer-server.o
+obj-m := $(O_TARGET)
+
+include ../../Makefile.module
+
+FileServer-server.c: FileServer.h FileServer-common.c FileServer-skels.c FileServer-skelimpl.c
+
+FileServer.h FileServer-skels.c FileServer-common.c: ../FileServer.idl
+	$(ORBIT_IDL) ../FileServer.idl
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/Makefile.user linux-2.4.1-korbit/net/korbit/modules/FileServer/server/Makefile.user
--- linux-2.4.1/net/korbit/modules/FileServer/server/Makefile.user	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/Makefile.user	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,32 @@
+#
+# Makefile for KORBit
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+PROJECT = FileServer
+
+CFLAGS = -Wall `orbit-config --cflags server` -I../../..
+LDFLAGS = `orbit-config --libs server`
+OBJS = $(PROJECT)-common.o $(PROJECT)-skels.o $(PROJECT)-server.o 
+ORBIT-IDL = orbit-idl
+
+$(PROJECT)-server: $(OBJS)
+	gcc -o $(PROJECT)-server $(OBJS) $(LDFLAGS)
+
+$(PROJECT)-server.c: $(PROJECT).h $(PROJECT)-skelimpl.c
+
+$(PROJECT).h $(PROJECT)-common.c $(PROJECT)-skels.c $(PROJECT)-skelimpl.c: ../$(PROJECT).idl
+	$(ORBIT-IDL) --nostubs ../$(PROJECT).idl
+
+clean:
+	rm -f $(OBJS) $(PROJECT)-server
+
+realclean: clean
+	rm -f $(PROJECT).h
+	rm -f $(PROJECT)-common.c
+	rm -f $(PROJECT)-skels.c
+	rm -f *~
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server/README linux-2.4.1-korbit/net/korbit/modules/FileServer/server/README
--- linux-2.4.1/net/korbit/modules/FileServer/server/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server/README	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,4 @@
+Kernel side implementation of the file server functionality.
+
+ORB: kORBit
+Status: Mostly unimplemented.
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server-user/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/CVS/Entries
--- linux-2.4.1/net/korbit/modules/FileServer/server-user/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/CVS/Entries	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,4 @@
+/FileServer-server.c/1.1/Thu Feb  1 09:47:08 2001//
+/Makefile/1.1/Thu Feb  1 09:47:08 2001//
+/README/1.1/Thu Feb  1 09:47:08 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server-user/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/CVS/Repository
--- linux-2.4.1/net/korbit/modules/FileServer/server-user/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/CVS/Repository	Thu Feb  1 11:47:08 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/FileServer/server-user
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server-user/CVS/Root linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/CVS/Root
--- linux-2.4.1/net/korbit/modules/FileServer/server-user/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/CVS/Root	Thu Feb  1 11:47:08 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server-user/FileServer-server.c linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/FileServer-server.c
--- linux-2.4.1/net/korbit/modules/FileServer/server-user/FileServer-server.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/FileServer-server.c	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,234 @@
+#include <OB/CORBA.h>
+#include <OB/Util.h>
+#include <OB/CosNaming.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "FileServer_skel.h"
+
+static void ThrowErr() {
+  switch (errno) {
+  case 0: return;
+  case EISDIR:
+    throw Errors::IsDirectory();
+  case EPERM:
+    throw Errors::PermissionDenied();
+  case EEXIST:
+    throw Errors::FileExists();
+  case ENOENT:
+    throw Errors::FileNotFound();
+  case ENOTDIR:
+    throw Errors::IsNotDirectory();
+  case EROFS:
+  case ETXTBSY:
+    throw Errors::ReadOnlyFile();
+  case ELOOP:
+    throw Errors::RecursiveSymlink();
+  case EBUSY:
+    throw Errors::IsBusy();
+  default:
+    throw Errors::OtherError();
+  }
+}
+
+
+class FileServer_File_impl : public FileServer_File_skel {
+  int FD;
+ public:
+  FileServer_File_impl(int fd) { FD = fd; }
+
+  virtual void Read(CORBA_Long count, FileServer_buffer*& buf) {
+    errno = 0;
+    cout << "Read\n"; 
+    buf = new FileServer_buffer();
+    ThrowErr();
+  }
+
+  virtual void Write(const FileServer_buffer& buf) {
+    errno = 0;
+    cout << "Write\n";
+    ThrowErr();
+  }
+
+  virtual void Close() {
+    errno = 0;
+    close(FD);
+    cout << "Close()\n";
+    ThrowErr();
+  }
+
+  virtual CORBA_Long FileControl(CORBA_Long command) {
+    errno = 0;
+    cout << "filecontrol\n";
+    ThrowErr();
+    return 0;
+  }
+
+  virtual FileServer_FileStatus GetStatus() {
+    errno = 0;
+    cout << "stat\n";
+    FileServer_FileStatus Stat;
+    ThrowErr();
+    return Stat;
+  }
+
+  virtual void ChangeDirectoryTo() {
+    errno = 0;
+    cout << "ChangeDirectoryTo()\n";
+    ThrowErr();
+  }
+
+  virtual CORBA_Long Seek(CORBA_Long Offset, SeekDirection Direction) {
+    errno = 0;
+    cout << "Seek(" << Offset << ")\n";
+    ThrowErr();
+    return -1;
+  }
+
+  virtual FileServer_File_ptr Duplicate() {
+    errno = 0;
+    cout << "Duplicate!\n";
+    ThrowErr();
+    return 0;
+  }
+};
+
+
+class FileServer_impl : public FileServer_FileSystem_skel {
+  public :
+    virtual FileServer_File_ptr Open(const char* Filename,
+                                     CORBA_Long openFlags,
+                                     CORBA_Short mode) {
+    errno = 0;
+    int fd = open(Filename, openFlags, mode);
+    if (fd != -1) return new FileServer_File_impl(fd);
+    cout << "open\n";
+    ThrowErr();
+    return 0;
+  }
+
+  virtual FileServer_File_ptr Create(const char* Filename,
+				     CORBA_Short mode) {
+    errno = 0;
+    cout << "create\n";
+    ThrowErr();
+    return 0;
+  }
+
+
+  virtual void Link(const char* FromPath,
+		    const char* ToPath) {
+    errno = 0;
+    cout << "link\n";
+    ThrowErr();
+  }
+
+  virtual void Unlink(const char* Filename) {
+    errno = 0;
+    cout << "unlink\n";
+    ThrowErr();
+  }
+    
+  virtual void Rename(const char* OldName,
+		      const char* NewName) {
+    errno = 0;
+    cout << "rename\n";
+    ThrowErr();
+  }
+
+
+  virtual void ReadLink(const char* Linkname,
+			char*& LinkValue) {
+    errno = 0;
+    cout << "readlink\n";
+    ThrowErr();
+  }
+
+  virtual FileServer_FileStatus GetStatus(const char* Filename) {
+    errno = 0;
+    cout << "stat\n";
+    FileServer_FileStatus Stat;
+    ThrowErr();
+    return Stat;
+  }
+
+
+  virtual FileServer_FileStatus GetLinkStatus(const char* Filename) {
+    errno = 0;
+    cout << "lstat\n";
+    FileServer_FileStatus Stat;
+    ThrowErr();
+    return Stat;
+  }
+
+
+  virtual void MakeDirectory(const char* PathName,
+			     CORBA_Short mode) {
+    errno = 0;
+    cout << "mkdir\n";
+    ThrowErr();
+  }
+
+  virtual void RemoveDirectory(const char* PathName) {
+    errno = 0;
+    cout << "rmdir\n";
+    ThrowErr();
+  }
+
+
+  virtual char* ChangeDirectory(const char* PathName) {
+    errno = 0;
+    cout << "chdir\n";
+    ThrowErr();
+    return CORBA_string_dup("hello");
+  }
+
+  virtual void MakeNode(const char* FileName,
+			CORBA_Short Mode,
+			CORBA_Long DeviceNum) {
+    errno = 0;
+    cout << "mknod\n";
+    ThrowErr();
+  }
+
+
+  virtual void Mount(const char* DeviceFile,
+		     const char* Location,
+		     const char* FSType,
+		     CORBA_Long Flags) {
+    errno = 0;
+    cout << "Mount\n";
+    ThrowErr();
+  }
+
+  virtual void Unmount(const char* Filename) {
+    errno = 0;
+    cout << "Unmount\n";
+    ThrowErr();
+  }
+};
+
+
+int main(int argc, char* argv[]) {
+    cout << "FileServer UserSpace Server initializing" << endl;
+
+    try {
+      CORBA_ORB_var orb = CORBA_ORB_init(argc, argv);
+      CORBA_BOA_var boa = orb->BOA_init(argc, argv);
+      
+      FileServer_FileSystem_var FS = new FileServer_impl();
+
+      cout << orb->object_to_string(FS) << endl;
+
+      //
+      // Run implementation
+      //
+      boa -> impl_is_ready(CORBA_ImplementationDef::_nil());
+    } catch(CORBA_SystemException& ex) {
+        OBPrintException(ex);
+        return 1;
+    }
+}
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server-user/Makefile linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/Makefile
--- linux-2.4.1/net/korbit/modules/FileServer/server-user/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/Makefile	Thu Feb  1 11:47:08 2001
@@ -0,0 +1,29 @@
+CC = CC -mt -pta
+OBDIR = /home/class/cs423/local
+IDL = $(OBDIR)/bin/idl
+CPPFLAGS = -I. -I$(OBDIR)/include
+LDFLAGS = -L$(OBDIR)/lib 
+LIBS = -lCosNaming -lOB -lJTC -lsocket -lnsl -lposix4
+
+all: FileServer
+
+FileServer: FileServer.o FileServer-server.o FileServer_skel.o
+	$(CC) $(LDFLAGS) -o FileServer FileServer-server.o FileServer.o FileServer_skel.o $(LIBS)
+
+FileServer.h FileServer.cpp: ../FileServer.idl
+	rm -f FileServer.cpp FileServer.h
+	rm -f FileServer_skel.h FileServer_skel.cpp
+	$(IDL) ../FileServer.idl
+
+FileServer_skel.cpp FileServer_skel.h: FileServer.cpp
+
+%.o: %.cpp
+	$(CC) $(CPPFLAGS) -c $<
+
+clean:
+	rm -f FileServer *.o *~
+
+realclean: clean
+	rm -f FileServer.h FileServer.cpp
+	rm -f FileServer_skel.h FileServer_skel.cpp
+	rm -rf SunWS_cache
diff -urN linux-2.4.1/net/korbit/modules/FileServer/server-user/README linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/README
--- linux-2.4.1/net/korbit/modules/FileServer/server-user/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/server-user/README	Thu Feb  1 11:47:08 2001
@@ -0,0 +1 @@
+This is a user space implementation of the FileServer interface.
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/CVS/Entries
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/CVS/Entries	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,6 @@
+/FileServer_wrapper.cpp/1.2/Thu Feb  1 09:47:09 2001//
+/FileServer_wrapper.h/1.2/Thu Feb  1 09:47:09 2001//
+/Makefile/1.1/Thu Feb  1 09:47:09 2001//
+/README/1.1/Thu Feb  1 09:47:09 2001//
+/test.c/1.2/Thu Feb  1 09:47:09 2001//
+D
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/CVS/Repository
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/CVS/Repository	Thu Feb  1 11:47:09 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/FileServer/wrapper
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/CVS/Root linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/CVS/Root
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/CVS/Root	Thu Feb  1 11:47:09 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.cpp linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.cpp
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.cpp	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.cpp	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,135 @@
+/*
+ * FileServer_wrapper.cpp
+ *
+ * We want to intercept *all* file I/O, so that once the LD_PRELOAD
+ * variable is set, everything you see is on the remote side.
+ *
+ * Needed environment variables:
+ *	LD_PRELOAD - duh (what's the lib name?)
+ *	KORBIT_IOR - IOR of the file servin' ORB to connect to.
+ *	
+ */
+
+#include <stdio.h>
+#include <dlfcn.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <errno.h>
+
+#include "OB/CORBA.h"
+//#include "OB/Util.h" 
+//#include "OB/CosNaming.h"
+
+#include "FileServer.h"
+#include "FileServer_wrapper.h"
+
+#define DEBUG
+
+#ifdef DEBUG
+#define debugOut(X) cerr << X << flush;
+#else
+#define debugOut(X)
+#endif
+
+
+FileSystemState::FileSystemState() {
+  char *argv[] = { (char*)"/usr/bin/mkdir", 0 };
+  int argc = 1;
+
+  debugOut ("FS_wrapper: InitializeOrb(): start.\n");
+  
+  /* Set 'PerformingInitialization = true'? */
+  
+  orb = CORBA_ORB_init(argc, argv);
+  if (CORBA_is_nil(orb)) {
+    cerr << "Error initializing ORB!\n";
+    exit(1);
+  }
+  debugOut ("\tORB initialized successfully.\n");
+  
+  const char *env = getenv("KORBIT_IOR");
+  if (!env) {
+    // This should check /proc/corba/FileServer-server also!
+    cerr << "InitializeOrb Error: KORBIT_IOR not found in environment!\n";
+    exit(1);
+  }
+
+  cout << "IOR = " << env << endl;
+
+  // WHY DO I HANG IN string_to_object??
+  CORBA_Object_var obj = orb->string_to_object(env);
+  debugOut("\tORB initialized successfully.\n");
+  
+  if (CORBA_is_nil(obj)) {
+    cerr << "InitializeOrb Error: IOR is invalid: " << env << endl;
+    exit (1);
+  }
+
+  debugOut ("\tORB initialized successfully.\n");
+  try {
+    FS = FileServer_FileSystem::_narrow(obj);
+  } catch (...) {
+    cerr << "InitializeOrb Error: Got an exception from _narrow().\n";
+    exit (1);
+  }
+  
+  /* Initialize my data structure 'o file descriptors. */
+
+  // Set up mapping for stdin, stdout, stderr.  Set up a new fd, #4 for 
+  // console/debug output
+
+  // stderr can go to console for now.
+
+  debugOut ("FS_wrapper: InitializeOrb(): finished successfully.\n");
+} /* End InitializeOrb(). */
+
+
+FileSystemState::~FileSystemState() (void) {
+} /* End CleanupOrb(). */
+
+
+void HandleException(CORBA_UserException &Exception) {
+  try {
+    throw Exception;  // get the type back...
+  } catch (Errors::FileExists &) {
+    errno = EEXIST;
+  } catch (Errors::PermissionDenied &) {
+    errno = EACCES;
+  } catch (Errors::FileNotFound &) {
+    errno = ENOENT;
+  } catch (Errors::IsNotDirectory &) {
+    errno = ENOTDIR;
+  } catch (Errors::ReadOnlyFile &) {
+    errno = EROFS;
+  } catch (Errors::RecursiveSymlink &) {
+    errno = ELOOP;
+  } catch (Errors::OtherError &) {
+    errno = EIO; /* I/O error */
+  } catch (CORBA_UserException &Exception) {
+    cerr << "unknown exception occurred! \n";
+  }
+}
+
+//int open(const char *path, int oflag, mode_t mode) {
+
+
+//  return -1;
+//}
+
+int mkdir(const char *pathname, mode_t mode) {
+  debugOut("FS_wrapper: mkdir(" << pathname << "): start.\n");
+
+  try {
+    FileSystemState::get().getFS()->MakeDirectory(pathname, mode);
+  } catch (CORBA_UserException &ex) {
+    HandleException(ex);
+    return -1;
+  }
+
+  // Success! 
+  debugOut("FS wrapper: mkdir(): finish successfully.\n");
+  return 0;	
+} // End mkdir()
+
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.h linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.h
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/FileServer_wrapper.h	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,81 @@
+// The KORBit FileServer wrapper, which is a shared library that gets
+// hit with the LD_PRELOAD action, so as to redirect all FS calls
+// out the CORBA hole.
+//
+// Note that most of these functions have the side effect of modifying errno.
+//
+#ifndef FILESERVER_WRAPPER_H
+#define FILESERVER_WRAPPER_H
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+// This class contains all the global variables for this file.  It is very 
+// important that we use this mechanism so that our library is initialized as 
+// early as possible, but no earlier.  In particular this means that we cannot
+// be initialized before iostreams are, which we use for debugging.  This scheme
+// the only way to that we are constructed and descructed on demand.
+//
+class FileSystemState {
+private:
+  FileSystemState();  // private ctor/dtor.  The only way to get one of these is 
+  ~FileSystemState(); // to call FileSystemState::get()
+
+  FileSystemState(const FileSystemState &);            // do not implement
+  FileSystemState &operator=(const FileSystemState &); // do not implement
+
+
+  CORBA_ORB_var orb;	          // Global reference to the orb.
+  FileServer_FileSystem_var FS;   // Global reference to FS object...
+public:
+  static FileSystemState &get() {
+    // Static objects like this are intialized the first time they are used, and
+    // destroyed when the project shuts down.  This is exactly the semantics we 
+    // want.
+    static FileSystemState FSS;
+    return FSS;
+  }
+
+  CORBA_ORB_var getORB() { return orb; }
+  FileServer_FileSystem_var getFS() { return FS; }
+};
+
+extern "C" {
+
+  //
+  // interface File
+  //
+  // pread, readv, pwrite, writev
+  int read(int FD, void *Buffer, size_t NumBytes);
+  int write(int FD, void *Buffer, size_t NumBytes);
+  int close(int FD);
+  // fcntl
+  // fstat
+  // fchdir
+  // seek
+  int dup(int FD);
+  int dup2(int FDFrom, int FDTo);
+	
+  //
+  // interface FileSystem
+  //
+  //  int open(const char *path, int oflag, mode_t mode);
+  int creat(const char *path, mode_t mode);
+
+//	link
+//	unlink
+//	rename
+//	readlink
+//      stat
+//      lstat
+  int mkdir(const char *Path, mode_t Mode);
+//	rmdir
+  int chdir(const char *Path);
+}
+
+//
+// Local function prototypes.
+//
+
+#endif
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/Makefile linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/Makefile
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/Makefile	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,29 @@
+CC = CC -mt -pta -g
+OBDIR = /home/class/cs423/local
+IDL = $(OBDIR)/bin/idl
+CPPFLAGS = -I. -I$(OBDIR)/include
+LDFLAGS = -L$(OBDIR)/lib -G -fPIC
+LIBS = -lCosNaming -lOB -lJTC -lsocket -lnsl -lposix4  -lCstd -lCrun
+
+all: libfswrapper.so 
+
+libfswrapper.so: FileServer.o FileServer_wrapper.o
+	CC $(LDFLAGS) -o $@ FileServer_wrapper.o FileServer.o $(LIBS)
+
+FileServer.h FileServer.cpp: ../FileServer.idl
+	rm -f FileServer.cpp FileServer.h
+	rm -f FileServer_skel.h FileServer_skel.cpp
+	$(IDL) ../FileServer.idl
+
+FileServer_skel.cpp FileServer_skel.h: FileServer.cpp
+
+%.o: %.cpp
+	$(CC) $(CPPFLAGS) -c $<
+
+clean:
+	rm -f libfswrapper.so *.o *~
+
+realclean: clean
+	rm -f FileServer.h FileServer.cpp
+	rm -f FileServer_skel.h FileServer_skel.cpp
+	rm -rf SunWS_cache
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/README linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/README
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/README	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,5 @@
+This is a library that may be LD_PRELOAD'd to forward filesystem related calls
+through the FileServer interface.
+
+ORB: ORBacus
+Status: Mostly not working
diff -urN linux-2.4.1/net/korbit/modules/FileServer/wrapper/test.c linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/test.c
--- linux-2.4.1/net/korbit/modules/FileServer/wrapper/test.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/FileServer/wrapper/test.c	Thu Feb  1 11:47:09 2001
@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+int main(void)
+{
+	if (mkdir("test", 0666) == -1)
+		{
+		perror ("mkdir failed because: ");
+		return (1);
+		}
+
+	return (0);
+}
diff -urN linux-2.4.1/net/korbit/modules/Makefile linux-2.4.1-korbit/net/korbit/modules/Makefile
--- linux-2.4.1/net/korbit/modules/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Makefile	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,15 @@
+#
+# Makefile for KORBit/modules
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+
+subdir-$(CONFIG_CORBA_CONSOLE) += Console
+subdir-$(CONFIG_CORBA_ECHO) += Echo
+subdir-$(CONFIG_CORBA_FILESERVER) += FileServer
+subdir-$(CONFIG_CORBA_CORBAFS) += CorbaFS
+subdir-$(CONFIG_CORBA_CHARDEV) += CharDev
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/modules/Makefile.module linux-2.4.1-korbit/net/korbit/modules/Makefile.module
--- linux-2.4.1/net/korbit/modules/Makefile.module	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/Makefile.module	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,9 @@
+M_OBJS := $(O_TARGET)
+
+EXTRA_CFLAGS = -D__KORBIT__ -DHAVE_CONFIG_H -I. -I../../.. -I../../../include -I../../../kglib -nostdinc
+
+
+ORBIT_IDL = orbit-idl
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/modules/README linux-2.4.1-korbit/net/korbit/modules/README
--- linux-2.4.1/net/korbit/modules/README	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/README	Thu Feb  1 11:46:58 2001
@@ -0,0 +1,7 @@
+Modules included so far:
+
+CharDev   : Implement Linux character device drivers
+Console   : Print strings to the Linux console
+CorbaFS   : Implement Linux filesystems through the VFS layer
+Echo      : Testcase to test orb two-way communication
+FileServer: Access a filesystem through CORBA
diff -urN linux-2.4.1/net/korbit/modules/UserFS/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Entries
--- linux-2.4.1/net/korbit/modules/UserFS/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Entries	Thu Feb  1 11:47:09 2001
@@ -0,0 +1 @@
+D
diff -urN linux-2.4.1/net/korbit/modules/UserFS/CVS/Entries.Log linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Entries.Log
--- linux-2.4.1/net/korbit/modules/UserFS/CVS/Entries.Log	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Entries.Log	Thu Feb  1 11:47:10 2001
@@ -0,0 +1 @@
+A D/client////
diff -urN linux-2.4.1/net/korbit/modules/UserFS/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Repository
--- linux-2.4.1/net/korbit/modules/UserFS/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Repository	Thu Feb  1 11:47:09 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/UserFS
diff -urN linux-2.4.1/net/korbit/modules/UserFS/CVS/Root linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Root
--- linux-2.4.1/net/korbit/modules/UserFS/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/UserFS/CVS/Root	Thu Feb  1 11:47:09 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/modules/UserFS/client/CVS/Entries linux-2.4.1-korbit/net/korbit/modules/UserFS/client/CVS/Entries
--- linux-2.4.1/net/korbit/modules/UserFS/client/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/UserFS/client/CVS/Entries	Thu Feb  1 11:47:10 2001
@@ -0,0 +1 @@
+D
diff -urN linux-2.4.1/net/korbit/modules/UserFS/client/CVS/Repository linux-2.4.1-korbit/net/korbit/modules/UserFS/client/CVS/Repository
--- linux-2.4.1/net/korbit/modules/UserFS/client/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/UserFS/client/CVS/Repository	Thu Feb  1 11:47:10 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/modules/UserFS/client
diff -urN linux-2.4.1/net/korbit/modules/UserFS/client/CVS/Root linux-2.4.1-korbit/net/korbit/modules/UserFS/client/CVS/Root
--- linux-2.4.1/net/korbit/modules/UserFS/client/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/modules/UserFS/client/CVS/Root	Thu Feb  1 11:47:10 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/orb/CVS/Entries linux-2.4.1-korbit/net/korbit/orb/CVS/Entries
--- linux-2.4.1/net/korbit/orb/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/CVS/Entries	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,60 @@
+/Makefile/1.6/Thu Feb  1 09:47:10 2001//
+/allocator-defs.h/1.1.1.1/Thu Feb  1 09:47:10 2001//
+/allocators.c/1.2/Thu Feb  1 09:47:10 2001//
+/allocators.h/1.1.1.1/Thu Feb  1 09:47:10 2001//
+/cdr.c/1.1.1.1/Thu Feb  1 09:47:10 2001//
+/cdr.h/1.1.1.1/Thu Feb  1 09:47:10 2001//
+/corba_any.c/1.3/Thu Feb  1 09:47:10 2001//
+/corba_any.h/1.1.1.1/Thu Feb  1 09:47:10 2001//
+/corba_any_proto.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_any_type.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_basic_sequences_type.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_context.c/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_context.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_env.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_env_type.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_object.c/1.7/Thu Feb  1 09:47:11 2001//
+/corba_object.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_object_type.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_orb.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_orb_type.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_portableserver.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_portableserver_type.h/1.1.1.1/Thu Feb  1 09:47:11 2001//
+/corba_sequences.h/1.1.1.1/Thu Feb  1 09:47:12 2001//
+/corba_sequences_type.h/1.1.1.1/Thu Feb  1 09:47:12 2001//
+/corba_typecode.h/1.1.1.1/Thu Feb  1 09:47:12 2001//
+/corba_typecode_type.h/1.3/Thu Feb  1 09:47:12 2001//
+/dii.c/1.2/Thu Feb  1 09:47:12 2001//
+/dii.h/1.2/Thu Feb  1 09:47:12 2001//
+/env.c/1.2/Thu Feb  1 09:47:12 2001//
+/env.h/1.2/Thu Feb  1 09:47:12 2001//
+/genrand.c/1.4/Thu Feb  1 09:47:12 2001//
+/genrand.h/1.1.1.1/Thu Feb  1 09:47:12 2001//
+/iop.h/1.1.1.1/Thu Feb  1 09:47:12 2001//
+/ir.c/1.1.1.1/Thu Feb  1 09:47:12 2001//
+/ir.h/1.1.1.1/Thu Feb  1 09:47:12 2001//
+/options.c/1.2/Thu Feb  1 09:47:12 2001//
+/options.h/1.2/Thu Feb  1 09:47:13 2001//
+/orb.c/1.13/Thu Feb  1 09:47:13 2001//
+/orb.h/1.2/Thu Feb  1 09:47:13 2001//
+/orbit.c/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit.h/1.2/Thu Feb  1 09:47:13 2001//
+/orbit.h.in/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit_config.h/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit_object.c/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit_object.h/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit_object_type.h/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit_poa.c/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit_poa.h/1.3/Thu Feb  1 09:47:13 2001//
+/orbit_poa_type.h/1.1.1.1/Thu Feb  1 09:47:13 2001//
+/orbit_typecode.c/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/orbit_typecode.h/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/orbit_types.h/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/poa.c/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/poa.h/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/sequences.c/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/sequences.h/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/server.c/1.5/Thu Feb  1 09:47:14 2001//
+/typecode.c/1.1.1.1/Thu Feb  1 09:47:14 2001//
+/typecode.h/1.1.1.1/Thu Feb  1 09:47:14 2001//
+D
diff -urN linux-2.4.1/net/korbit/orb/CVS/Repository linux-2.4.1-korbit/net/korbit/orb/CVS/Repository
--- linux-2.4.1/net/korbit/orb/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/CVS/Repository	Thu Feb  1 11:47:10 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/orb
diff -urN linux-2.4.1/net/korbit/orb/CVS/Root linux-2.4.1-korbit/net/korbit/orb/CVS/Root
--- linux-2.4.1/net/korbit/orb/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/CVS/Root	Thu Feb  1 11:47:10 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit
diff -urN linux-2.4.1/net/korbit/orb/Makefile linux-2.4.1-korbit/net/korbit/orb/Makefile
--- linux-2.4.1/net/korbit/orb/Makefile	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/Makefile	Thu Feb  1 11:47:10 2001
@@ -0,0 +1,25 @@
+#
+# Makefile for KORBit/orb
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .o file).
+#
+# Note 2! The CFLAGS definition is now in the main makefile...
+
+O_TARGET := orblib.o
+
+#obj-m := $(O_TARGET)
+obj-y := allocators.o options.o poa.o \
+          cdr.o env.o orb.o sequences.o \
+          corba_any.o genrand.o orbit.o server.o \
+          corba_context.o orbit_object.o typecode.o \
+          corba_object.o orbit_poa.o \
+          dii.o ir.o orbit_typecode.o
+
+EXTRA_CFLAGS = -D__KORBIT__ -DHAVE_CONFIG_H -I. -I.. -I../include -I../kglib -I../ORBitutil -nostdinc \
+               -DORBit_SYSRC=\"/etc/orbitrc\" \
+               -DORBIT_MAJOR_VERSION="0" -DORBIT_MINOR_VERSION="5" -DORBIT_MICRO_VERSION="3" -DORBIT_VERSION=\"0.5.3\"
+
+include $(TOPDIR)/Rules.make
+
diff -urN linux-2.4.1/net/korbit/orb/allocator-defs.h linux-2.4.1-korbit/net/korbit/orb/allocator-defs.h
--- linux-2.4.1/net/korbit/orb/allocator-defs.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/allocator-defs.h	Thu Feb  1 11:47:10 2001
@@ -0,0 +1,40 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/* By Elliot Lee. Copyright (c) 1998 Red Hat Software */
+
+
+/********************************************************
+ * Never include this header file directly. Only allocators.[ch]
+ * should do this
+ ********************************************************/
+
+/* Macro crap */
+
+#ifdef ALLOCATOR_DEFINITION
+
+#define ORBIT_DEFINE_CHUNK(x, xsize) \
+DEFINE_LOCK(x##_allocator); \
+GMemChunk *x##_allocator = NULL
+
+#elif defined(ALLOCATOR_INITIALIZATION)
+
+#define ORBIT_DEFINE_CHUNK(x, xsize) INIT_LOCK(x##_allocator); \
+x##_allocator = g_mem_chunk_new(#x, (xsize), \
+(xsize) * ORBIT_CHUNKS_PREALLOC, G_ALLOC_AND_FREE)
+
+#else
+
+#define ORBIT_DEFINE_CHUNK(x, xsize) \
+EXTERN_LOCK(x##_allocator); \
+extern GMemChunk *x##_allocator
+
+#endif
+
+/*****************************************************
+ * Here's where we define the actual chunks that are used
+ *****************************************************/
+ORBIT_DEFINE_CHUNK(CORBA_TypeCode, sizeof(struct CORBA_TypeCode_struct));
+ORBIT_DEFINE_CHUNK(CORBA_Object, sizeof(struct CORBA_Object_struct));
+ORBIT_DEFINE_CHUNK(CORBA_NVList, sizeof(struct CORBA_NVList_type));
+
+#undef ORBIT_DEFINE_CHUNK
diff -urN linux-2.4.1/net/korbit/orb/allocators.c linux-2.4.1-korbit/net/korbit/orb/allocators.c
--- linux-2.4.1/net/korbit/orb/allocators.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/allocators.c	Thu Feb  1 11:47:10 2001
@@ -0,0 +1,241 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/* By Elliot Lee. Copyright (c) 1998 Red Hat Software */
+
+#include "orbit.h"
+
+#if 0
+#define CORBA_Object_release(x, y) ({ g_message(__FILE__ ":%d Releasing object %#x from %d", __LINE__, \
+x, ORBIT_ROOT_OBJECT(x)->refs); CORBA_Object_release(x, y); })
+#define CORBA_Object_duplicate(x, y) ({ g_message(__FILE__ ":%d Duping object %#x from %d", __LINE__, \
+x, ORBIT_ROOT_OBJECT(x)->refs); CORBA_Object_duplicate(x, y); })
+#endif
+
+/* The memory chunk stuff */
+
+#define ALLOCATOR_DEFINITION
+#include "allocator-defs.h"
+#undef ALLOCATOR_DEFINITION
+
+void
+ORBit_chunks_init(void)
+{
+#define ALLOCATOR_INITIALIZATION
+#include "allocator-defs.h"
+#undef ALLOCATOR_INTIALIZATION
+}
+
+gpointer
+ORBit_chunk_alloc(GMemChunk *chunk,
+		  PARAM_LOCK(chunk))
+{
+  gpointer retval;
+
+  GET_LOCK(chunk);
+  retval = g_mem_chunk_alloc(chunk);
+  RELEASE_LOCK(chunk);
+
+  return retval;
+}
+
+void
+ORBit_chunk_free(GMemChunk *chunk,
+		 PARAM_LOCK(chunk),
+		 gpointer mem)
+{
+  GET_LOCK(chunk);
+  g_mem_chunk_free(chunk, mem);
+  RELEASE_LOCK(chunk);
+}
+
+/* end memory chunk routines */
+
+/****************************************************************/
+
+/************* begin funky memory alloc/free system */
+
+/****** functions */
+
+gpointer ORBit_alloc(size_t block_size,
+		     ORBit_free_childvals freefunc,
+		     gpointer func_data)
+{
+	return ORBit_alloc_2(block_size, freefunc, func_data, 0);
+}
+
+gpointer
+ORBit_alloc_2(size_t block_size,
+	      ORBit_free_childvals freefunc,
+	      gpointer func_data,
+	      size_t before_size)
+{
+	ORBit_mem_info *block;
+
+	if(block_size == 0) return NULL;
+
+	block = (ORBit_mem_info *)((char *)
+		g_malloc(block_size + sizeof(ORBit_mem_info) + before_size)
+		+ before_size);
+
+#ifdef ORBIT_DEBUG
+	block->magic = 0xdeadbeef;
+#endif
+	block->free = freefunc;
+	block->func_data = func_data;
+
+	return MEMINFO_TO_PTR(block);
+}
+
+/*
+  ORBit_free
+  ----------
+
+  Frees a corba primitive type.
+
+  mem = pointer to the memory block. (must have a preceeding pointer to a meminfo block)
+
+  1)obtains a pointer to the preceeding meminfo structure
+  2)Uses the meminfo structure to find the number of elements in the memory block
+  3)iterates through the memory block, calling the free function for each item.
+  
+ */
+
+void
+ORBit_free(gpointer mem, CORBA_boolean free_strings)
+{
+	ORBit_mem_info *block;
+
+	if(!mem)
+		return;
+
+	block = PTR_TO_MEMINFO(mem);
+
+#ifdef ORBIT_DEBUG
+	g_assert(block->magic == 0xdeadbeef);
+#endif
+
+	if(block->free) {
+		int i;
+		gpointer x;
+		gpointer my_data;
+
+		if((gpointer)block->free == (gpointer)ORBit_free_via_TypeCode)
+			my_data = ((guchar *)block) - sizeof(CORBA_TypeCode);
+		else
+			my_data = NULL;
+
+#ifdef ORBIT_DEBUG
+		if(block->func_data == NULL)
+			g_warning("block with freefunc %p has no items", block->free);
+#endif
+
+		for(i = 0, x = mem; i < (gulong)block->func_data; i++)
+			x = block->free(x, my_data, free_strings);
+
+		if((gpointer)block->free == (gpointer)ORBit_free_via_TypeCode)
+			/* ((guchar *)block) -= sizeof(CORBA_TypeCode); */
+			block = (ORBit_mem_info *)
+				(((guchar *)block) - sizeof(CORBA_TypeCode));
+		g_free(block);
+	} else
+		g_free(block);
+}
+
+/******************************************************************/
+/* These aren't currently used... */
+
+gpointer
+ORBit_free_via_TypeCode(gpointer mem, gpointer tcp, gboolean free_strings)
+{
+	CORBA_TypeCode tc = *(CORBA_TypeCode *)tcp, subtc;
+	int i;
+	guchar *retval = NULL;
+
+	switch(tc->kind) {
+	case CORBA_tk_any:
+		{
+			CORBA_any *anyval = mem;
+			if(anyval->_release)
+				CORBA_free(anyval->_value);
+			retval = (guchar *)(anyval + 1);
+		}
+		break;
+	case CORBA_tk_TypeCode:
+	case CORBA_tk_objref:
+		{
+			CORBA_Object_release(*(CORBA_Object *)mem, NULL);
+
+			retval = (guchar *)mem + sizeof(CORBA_Object);
+		}
+		break;
+	case CORBA_tk_Principal:
+		{
+			CORBA_Principal *pval = mem;
+			if(pval->_release)
+				CORBA_free(pval->_buffer);
+			retval = (guchar *)(pval + 1);
+		}
+		break;
+	case CORBA_tk_except:
+	case CORBA_tk_struct:
+		mem = ALIGN_ADDRESS(mem, ORBit_find_alignment(tc));
+		for(i = 0; i < tc->sub_parts; i++) {
+			subtc = (CORBA_TypeCode)CORBA_Object_duplicate((CORBA_Object)tc->subtypes[i], NULL);
+			mem = ORBit_free_via_TypeCode(mem, &subtc,
+						      free_strings);
+		}
+		retval = mem;
+		break;
+	case CORBA_tk_union:
+		subtc = (CORBA_TypeCode)CORBA_Object_duplicate(
+		  (CORBA_Object)ORBit_get_union_tag(tc, &mem, TRUE), NULL);
+		{
+		    int sz = 0;
+		    int al = 1;
+		    for(i = 0; i < tc->sub_parts; i++) {
+		        al = MAX(al, ORBit_find_alignment(tc->subtypes[i]));
+		        sz = MAX(sz, ORBit_gather_alloc_info(tc->subtypes[i]));
+		    }
+		    mem = ALIGN_ADDRESS(mem, al);
+		    ORBit_free_via_TypeCode(mem, &subtc, free_strings);
+		    /* the end of the body (subtc) may not be the
+		     * same as the end of the union */
+		    retval = mem + sz;
+		}
+		break;
+	case CORBA_tk_wstring:
+	case CORBA_tk_string:
+		if(free_strings)
+			CORBA_free(*(char **)mem);
+		retval = (guchar *)mem + sizeof(char *);
+		break;
+	case CORBA_tk_sequence:
+		{
+			CORBA_sequence_octet *pval = mem;
+			if(pval->_release)
+				CORBA_free(pval->_buffer);
+
+			retval = (guchar *)mem + sizeof(CORBA_sequence_octet);
+		}
+		break;
+	case CORBA_tk_array:
+		for(i = 0; i < tc->length; i++) {
+			subtc = (CORBA_TypeCode)CORBA_Object_duplicate((CORBA_Object)tc->subtypes[0], NULL);
+			mem = ORBit_free_via_TypeCode(mem, &subtc,
+						      free_strings);
+		}
+		retval = mem;
+		break;
+	case CORBA_tk_alias:
+		subtc = (CORBA_TypeCode)CORBA_Object_duplicate((CORBA_Object)tc->subtypes[0], NULL);
+		retval = ORBit_free_via_TypeCode(mem, &subtc, free_strings);
+		break;
+	default:
+		retval = ((guchar *)mem) + ORBit_gather_alloc_info(tc);
+		break;
+	}
+
+	CORBA_Object_release((CORBA_Object)tc, NULL);
+
+	return (gpointer)retval;
+}
diff -urN linux-2.4.1/net/korbit/orb/allocators.h linux-2.4.1-korbit/net/korbit/orb/allocators.h
--- linux-2.4.1/net/korbit/orb/allocators.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/allocators.h	Thu Feb  1 11:47:10 2001
@@ -0,0 +1,61 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/* By Elliot Lee. Copyright (c) 1998 Red Hat Software */
+
+#ifndef ALLOCATORS_H
+#define ALLOCATORS_H 1
+
+#include <orb/orbit.h>
+
+#include <orb/allocator-defs.h>
+
+#define ORBIT_CHUNK_ALLOC(typename) \
+ORBit_chunk_alloc(typename##_allocator, LOCK_NAME(typename##_allocator))
+
+#define ORBIT_CHUNK_FREE(typename, mem) \
+ORBit_chunk_free(typename##_allocator, LOCK_NAME(typename##_allocator), (mem))
+
+void ORBit_chunks_init(void);
+
+gpointer ORBit_chunk_alloc(GMemChunk *chunk,
+			   PARAM_LOCK(chunk_lock));
+
+void ORBit_chunk_free(GMemChunk *chunk,
+		      PARAM_LOCK(chunk_lock),
+		      gpointer mem);
+
+/* General memory allocation routines */
+
+#define PTR_TO_MEMINFO(x) (((ORBit_mem_info *)(x)) - 1)
+#define MEMINFO_TO_PTR(x) ((gpointer)((x) + 1))
+
+typedef gpointer (*ORBit_free_childvals)(gpointer mem,
+					 gpointer func_data,
+					 CORBA_boolean free_strings);
+
+typedef struct {
+#ifdef ORBIT_DEBUG
+	gulong magic;
+#endif
+	/* If this routine returns FALSE, it indicates that it already free'd
+	   the memory block itself */
+	ORBit_free_childvals free; /* function pointer to free function */
+	gpointer func_data;
+} ORBit_mem_info;
+
+gpointer ORBit_alloc(size_t block_size,
+		     ORBit_free_childvals freefunc,
+		     gpointer func_data);
+gpointer ORBit_alloc_2(size_t block_size,
+		       ORBit_free_childvals freefunc,
+		       gpointer func_data,
+		       size_t before_size);
+
+void ORBit_free(gpointer mem, CORBA_boolean free_strings);
+
+/* internal stuff */
+gpointer ORBit_free_via_TypeCode(gpointer mem,
+				 gpointer tcp,
+				 gboolean free_strings);
+
+#endif /* ALLOCATORS_H */
diff -urN linux-2.4.1/net/korbit/orb/cdr.c linux-2.4.1-korbit/net/korbit/orb/cdr.c
--- linux-2.4.1/net/korbit/orb/cdr.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/cdr.c	Thu Feb  1 11:47:10 2001
@@ -0,0 +1,643 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#include "config.h"
+#include "../IIOP/iiop-endianP.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "orbit.h"
+
+#define CDR_GROW_AMOUNT 128
+
+static CORBA_boolean CDR_buffer_grow(CDR_Codec *codec, const unsigned int growth)
+{
+	unsigned int real_growth;
+	div_t divvy;
+
+	if(codec->release_buffer) {
+		divvy=div(growth, CDR_GROW_AMOUNT);
+		real_growth=CDR_GROW_AMOUNT * (divvy.quot+1);
+		
+		codec->buffer=(CORBA_octet *)g_realloc(codec->buffer,
+						       codec->buf_len
+						       +real_growth);
+	}
+
+	return CORBA_TRUE;
+}
+
+static void CDR_buffer_puts(CDR_Codec *codec, const void *data, const unsigned int len)
+{
+	if(codec->wptr+len > codec->buf_len) {
+		CORBA_boolean res=CDR_buffer_grow(codec, len);
+
+		if(res==CORBA_FALSE) {
+			/* just bail out for now */
+			g_assert(!"Malloc error");
+		}
+	}
+
+	memcpy(&codec->buffer[codec->wptr], data, len);
+	codec->wptr+=len;
+}
+
+CORBA_boolean CDR_buffer_gets(CDR_Codec *codec, void *dest, const unsigned int len)
+{
+	if(codec->rptr+len > codec->buf_len) {
+		ORBit_Trace(TraceMod_CDR, TraceLevel_Debug, "CDR_buffer_gets: attempt to read past end of buffer\n");
+		return(CORBA_FALSE);
+	}
+
+	memcpy(dest, &codec->buffer[codec->rptr], len);
+	codec->rptr+=len;
+
+	return(CORBA_TRUE);
+}
+
+static void CDR_buffer_put(CDR_Codec *codec, void *datum)
+{
+	if(codec->wptr+1 > codec->buf_len) {
+		CORBA_boolean res=CDR_buffer_grow(codec, 1);
+
+		if(res==CORBA_FALSE) {
+			/* just bail out for now */
+			g_assert(!"Malloc error");
+		}
+	}
+
+	codec->buffer[codec->wptr++]=*(unsigned char *)datum;
+}
+
+static CORBA_boolean CDR_buffer_get(CDR_Codec *codec, void *dest)
+{
+	if(codec->rptr+1 > codec->buf_len) {
+		ORBit_Trace(TraceMod_CDR, TraceLevel_Debug, "CDR_buffer_get: attempt to read past end of buffer\n");
+		return(CORBA_FALSE);
+	}
+
+	*(CORBA_octet *)dest=codec->buffer[codec->rptr++];
+	return(CORBA_TRUE);
+}
+
+#ifdef lame_slow_code
+static void CDR_buffer_put2(CDR_Codec *codec, void *datum)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(codec->readonly!=CORBA_TRUE);
+	g_assert(codec->wptr<=codec->buf_len);
+
+	align=((codec->wptr+1)&~1L);
+
+	if(align+2 > codec->buf_len) {
+		CORBA_boolean res=CDR_buffer_grow(codec, align+2-codec->wptr);
+
+		if(res==CORBA_FALSE) {
+			/* just bail out for now */
+			g_assert(!"Malloc error");
+		}
+	}
+
+	while(codec->wptr < align) {
+		codec->buffer[codec->wptr++]='\0';
+	}
+
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[0];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[1];
+}
+
+static CORBA_boolean CDR_buffer_get2(CDR_Codec *codec, void *dest)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(dest!=NULL);
+	g_assert(codec->rptr<=codec->buf_len);
+
+	align=((codec->rptr+1)&~1L);
+
+	if(align+2 > codec->buf_len) {
+		ORBit_Trace(TraceMod_CDR, TraceLevel_Debug, "CDR_buffer_get2: attempt to read past end of buffer\n");
+		return(CORBA_FALSE);
+	}
+
+	codec->rptr=align;
+
+	((CORBA_octet *)dest)[0]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[1]=codec->buffer[codec->rptr++];
+
+	return(CORBA_TRUE);
+}
+
+static void CDR_buffer_put4(CDR_Codec *codec, void *datum)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(codec->readonly!=CORBA_TRUE);
+	g_assert(codec->wptr<=codec->buf_len);
+
+	align=((codec->wptr+3)&~3L);
+
+	if(align+4 > codec->buf_len) {
+		CORBA_boolean res=CDR_buffer_grow(codec, align+4-codec->wptr);
+
+		if(res==CORBA_FALSE) {
+			/* just bail out for now */
+			g_assert(!"Malloc error");
+		}
+	}
+
+	while(codec->wptr < align) {
+		codec->buffer[codec->wptr++]='\0';
+	}
+
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[0];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[1];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[2];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[3];
+}
+
+static CORBA_boolean CDR_buffer_get4(CDR_Codec *codec, void *dest)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(dest!=NULL);
+	g_assert(codec->rptr<=codec->buf_len);
+
+	align=((codec->rptr+3)&~3L);
+
+	if(align+4 > codec->buf_len) {
+		ORBit_Trace(TraceMod_CDR, TraceLevel_Debug, "CDR_buffer_get4: attempt to read past end of buffer\n");
+		return(CORBA_FALSE);
+	}
+
+	codec->rptr=align;
+
+	((CORBA_octet *)dest)[0]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[1]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[2]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[3]=codec->buffer[codec->rptr++];
+
+	return(CORBA_TRUE);
+}
+
+static void CDR_buffer_put8(CDR_Codec *codec, void *datum)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(codec->readonly!=CORBA_TRUE);
+	g_assert(codec->wptr<=codec->buf_len);
+
+	align=((codec->wptr+7)&~7L);
+
+	if(align+8 > codec->buf_len) {
+		CORBA_boolean res=CDR_buffer_grow(codec, align+8-codec->wptr);
+
+		if(res==CORBA_FALSE) {
+			/* just bail out for now */
+			g_assert(!"Malloc error");
+		}
+	}
+
+	while(codec->wptr < align) {
+		codec->buffer[codec->wptr++]='\0';
+	}
+
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[0];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[1];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[2];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[3];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[4];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[5];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[6];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[7];
+}
+
+#if 0
+static CORBA_boolean CDR_buffer_get8(CDR_Codec *codec, void *dest)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(dest!=NULL);
+	g_assert(codec->rptr<=codec->buf_len);
+
+	align=((codec->rptr+7)&~7L);
+
+	if(align+8 > codec->buf_len) {
+		ORBit_Trace(TraceMod_CDR, TraceLevel_Debug, "CDR_buffer_get8: attempt to read past end of buffer\n");
+		return(CORBA_FALSE);
+	}
+
+	codec->rptr=align;
+
+	((CORBA_octet *)dest)[0]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[1]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[2]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[3]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[4]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[5]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[6]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[7]=codec->buffer[codec->rptr++];
+
+	return(CORBA_TRUE);
+}
+#endif
+
+static void CDR_buffer_put16(CDR_Codec *codec, void *datum)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(codec->readonly!=CORBA_TRUE);
+	g_assert(codec->wptr<=codec->buf_len);
+
+	align=((codec->wptr+15)&~15L);
+
+	if(align+16 > codec->buf_len) {
+		CORBA_boolean res=CDR_buffer_grow(codec, align+16-codec->wptr);
+
+		if(res==CORBA_FALSE) {
+			/* just bail out for now */
+			g_assert(!"Malloc error");
+		}
+	}
+
+	while(codec->wptr < align) {
+		codec->buffer[codec->wptr++]='\0';
+	}
+
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[0];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[1];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[2];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[3];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[4];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[5];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[6];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[7];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[8];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[9];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[10];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[11];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[12];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[13];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[14];
+	codec->buffer[codec->wptr++]=((CORBA_octet *)datum)[15];
+}
+
+#if 0
+static CORBA_boolean CDR_buffer_get16(CDR_Codec *codec, void *dest)
+{
+	unsigned long align;
+
+	g_assert(codec!=NULL);
+	g_assert(dest!=NULL);
+	g_assert(codec->rptr<=codec->buf_len);
+
+	align=((codec->rptr+15)&~15L);
+
+	if(align+16 > codec->buf_len) {
+		ORBit_Trace(TraceMod_CDR, TraceLevel_Debug, "CDR_buffer_get16: attempt to read past end of buffer\n");
+		return(CORBA_FALSE);
+	}
+
+	codec->rptr=align;
+
+	((CORBA_octet *)dest)[0]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[1]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[2]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[3]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[4]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[5]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[6]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[7]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[8]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[9]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[10]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[11]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[12]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[13]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[14]=codec->buffer[codec->rptr++];
+	((CORBA_octet *)dest)[15]=codec->buffer[codec->rptr++];
+
+	return(CORBA_TRUE);
+}
+#endif
+#endif /* lame_slow_code */
+
+#define CDR_buffer_put2(codec, datum) CDR_buffer_putn(codec, datum, 2)
+#define CDR_buffer_put4(codec, datum) CDR_buffer_putn(codec, datum, 4)
+#define CDR_buffer_put8(codec, datum) CDR_buffer_putn(codec, datum, 8)
+#define CDR_buffer_put16(codec, datum) CDR_buffer_putn(codec, datum, 16)
+#define CDR_buffer_get2(codec, dest) CDR_buffer_getn(codec, dest, 2)
+#define CDR_buffer_get4(codec, dest) CDR_buffer_getn(codec, dest, 4)
+#define CDR_buffer_get8(codec, dest) CDR_buffer_getn(codec, dest, 8)
+#define CDR_buffer_get16(codec, dest) CDR_buffer_getn(codec, dest, 16)
+
+static CORBA_boolean
+CDR_buffer_getn(CDR_Codec *codec, void *dest, int bsize)
+{
+	codec->rptr = (unsigned long)ALIGN_ADDRESS(codec->rptr, bsize);
+	if(codec->host_endian==codec->data_endian)
+		memcpy(dest, codec->buffer + codec->rptr, bsize);
+	else
+		iiop_byteswap(dest, codec->buffer + codec->rptr, bsize);
+	codec->rptr += bsize;
+
+	return CORBA_TRUE;
+}
+
+static CORBA_boolean
+CDR_buffer_putn(CDR_Codec *codec, void *datum, int bsize)
+{
+	codec->wptr = (unsigned long)ALIGN_ADDRESS(codec->wptr, bsize);
+	if(codec->host_endian==codec->data_endian)
+		memcpy(codec->buffer + codec->wptr, datum, bsize);
+	else
+		iiop_byteswap(codec->buffer + codec->wptr, datum, bsize);
+	codec->wptr += bsize;
+
+	return CORBA_TRUE;
+}
+
+#define CDR_swap2(d,s) iiop_byteswap((d), (s), 2)
+#define CDR_swap4(d,s) iiop_byteswap((d), (s), 4)
+#define CDR_swap8(d,s) iiop_byteswap((d), (s), 8)
+#define CDR_swap16(d,s) iiop_byteswap((d), (s), 16)
+
+#ifdef lame_slow_code
+static void CDR_swap2(void *d, void *s)
+{
+	((CORBA_octet *)d)[0]=((CORBA_octet *)s)[1];
+	((CORBA_octet *)d)[1]=((CORBA_octet *)s)[0];
+}
+
+static void CDR_swap4(void *d, void *s)
+{
+	((CORBA_octet *)d)[0]=((CORBA_octet *)s)[3];
+	((CORBA_octet *)d)[1]=((CORBA_octet *)s)[2];
+	((CORBA_octet *)d)[2]=((CORBA_octet *)s)[1];
+	((CORBA_octet *)d)[3]=((CORBA_octet *)s)[0];
+}
+
+static void CDR_swap8(void *d, void *s)
+{
+	((CORBA_octet *)d)[0]=((CORBA_octet *)s)[7];
+	((CORBA_octet *)d)[1]=((CORBA_octet *)s)[6];
+	((CORBA_octet *)d)[2]=((CORBA_octet *)s)[5];
+	((CORBA_octet *)d)[3]=((CORBA_octet *)s)[4];
+	((CORBA_octet *)d)[4]=((CORBA_octet *)s)[3];
+	((CORBA_octet *)d)[5]=((CORBA_octet *)s)[2];
+	((CORBA_octet *)d)[6]=((CORBA_octet *)s)[1];
+	((CORBA_octet *)d)[7]=((CORBA_octet *)s)[0];
+}
+
+static void CDR_swap16(void *d, void *s)
+{
+	((CORBA_octet *)d)[0]=((CORBA_octet *)s)[15];
+	((CORBA_octet *)d)[1]=((CORBA_octet *)s)[14];
+	((CORBA_octet *)d)[2]=((CORBA_octet *)s)[13];
+	((CORBA_octet *)d)[3]=((CORBA_octet *)s)[12];
+	((CORBA_octet *)d)[4]=((CORBA_octet *)s)[11];
+	((CORBA_octet *)d)[5]=((CORBA_octet *)s)[10];
+	((CORBA_octet *)d)[6]=((CORBA_octet *)s)[9];
+	((CORBA_octet *)d)[7]=((CORBA_octet *)s)[8];
+	((CORBA_octet *)d)[8]=((CORBA_octet *)s)[7];
+	((CORBA_octet *)d)[9]=((CORBA_octet *)s)[6];
+	((CORBA_octet *)d)[10]=((CORBA_octet *)s)[5];
+	((CORBA_octet *)d)[11]=((CORBA_octet *)s)[4];
+	((CORBA_octet *)d)[12]=((CORBA_octet *)s)[3];
+	((CORBA_octet *)d)[13]=((CORBA_octet *)s)[2];
+	((CORBA_octet *)d)[14]=((CORBA_octet *)s)[1];
+	((CORBA_octet *)d)[15]=((CORBA_octet *)s)[0];
+}
+#endif
+
+
+void CDR_put_short(CDR_Codec *codec, CORBA_short s)
+{
+	CDR_buffer_put2(codec, &s);
+}
+
+CORBA_boolean CDR_get_short(CDR_Codec *codec, CORBA_short *s)
+{
+	return CDR_buffer_get2(codec, s);
+}
+
+void CDR_put_ushort(CDR_Codec *codec, CORBA_unsigned_short us)
+{
+	CDR_buffer_put2(codec, &us);
+}
+
+CORBA_boolean CDR_get_ushort(CDR_Codec *codec, CORBA_unsigned_short *us)
+{
+	return CDR_buffer_get2(codec, us);
+}
+
+void CDR_put_long(CDR_Codec *codec, CORBA_long l)
+{
+	CDR_buffer_put4(codec, &l);
+}
+
+CORBA_boolean CDR_get_long(CDR_Codec *codec, CORBA_long *l)
+{
+	return CDR_buffer_get4(codec, l);
+}
+
+void CDR_put_ulong(CDR_Codec *codec, CORBA_unsigned_long ul)
+{
+	CDR_buffer_put4(codec, &ul);
+}
+
+CORBA_boolean CDR_get_ulong(CDR_Codec *codec, CORBA_unsigned_long *ul)
+{
+	return CDR_buffer_get4(codec, ul);
+}
+
+#ifdef HAVE_CORBA_LONG_LONG
+CORBA_boolean CDR_get_long_long(CDR_Codec *codec, CORBA_long_long *ul)
+{
+	return CDR_buffer_get8(codec, ul);
+}
+
+void CDR_put_long_long(CDR_Codec *codec, CORBA_long_long ll)
+{
+	CDR_buffer_put8(codec, &ll);
+}
+
+void CDR_put_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long ll)
+{
+	CDR_buffer_put8(codec, &ll);
+}
+
+CORBA_boolean CDR_get_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long *ull)
+{
+	return CDR_buffer_get8(codec, ull);
+}
+#endif
+
+void CDR_put_float(CDR_Codec *codec, CORBA_float f)
+{
+	CDR_buffer_put4(codec, &f);
+}
+
+void CDR_put_double(CDR_Codec *codec, CORBA_double d)
+{
+	CDR_buffer_put8(codec, &d);
+}
+
+void CDR_put_long_double(CDR_Codec *codec, CORBA_long_double ld)
+{
+	CDR_buffer_put16(codec, &ld);
+}
+
+void CDR_put_octet(CDR_Codec *codec, CORBA_octet datum)
+{
+	CDR_buffer_put(codec, &datum);
+}
+
+CORBA_boolean CDR_get_octet(CDR_Codec *codec, CORBA_octet *datum)
+{
+	return(CDR_buffer_get(codec, datum));
+}
+
+void CDR_put_octets(CDR_Codec *codec, void *data, unsigned long len)
+{
+	CDR_buffer_puts(codec, data, len);
+}
+
+void CDR_put_char(CDR_Codec *codec, CORBA_char c)
+{
+	CDR_buffer_put(codec, &c);
+}
+
+CORBA_boolean CDR_get_char(CDR_Codec *codec, CORBA_char *c)
+{
+	return CDR_buffer_get(codec, c);
+}
+
+void CDR_put_boolean(CDR_Codec *codec, CORBA_boolean datum)
+{
+	datum = datum&&1;
+	CDR_buffer_put(codec, &datum);
+}
+
+CORBA_boolean CDR_get_boolean(CDR_Codec *codec, CORBA_boolean *b)
+{
+	return CDR_buffer_get(codec, b);
+}
+
+void CDR_put_string(CDR_Codec *codec, const char *str)
+{
+	unsigned int len;
+
+	len=strlen(str)+1;
+
+	CDR_put_ulong(codec, len);
+	CDR_buffer_puts(codec, str, len);
+}
+
+CORBA_boolean CDR_get_string_static(CDR_Codec *codec,
+				    CORBA_char **str)
+{
+	CORBA_unsigned_long len;
+
+	if(CDR_get_ulong(codec, &len)==CORBA_FALSE)
+		return CORBA_FALSE;
+
+	if((codec->rptr + len) > codec->buf_len)
+		return CORBA_FALSE;
+
+	*str = ((CORBA_char *)codec->buffer) + codec->rptr;
+
+	codec->rptr += len;
+
+	return CORBA_TRUE;
+}
+
+CORBA_boolean CDR_get_string(CDR_Codec *codec, CORBA_char **str)
+{
+	CORBA_unsigned_long len;
+
+	if(CDR_get_ulong(codec, &len)==CORBA_FALSE)
+		return(CORBA_FALSE);
+
+	if(len==0)
+		return(CORBA_FALSE);
+
+	*str=g_new(CORBA_char, len);
+
+	if(CDR_buffer_gets(codec, *str, len)==CORBA_FALSE) {
+		g_free(*str);
+		return(CORBA_FALSE);
+	}
+
+	if((*str)[len-1]!='\0') {
+		ORBit_Trace(TraceMod_CDR, TraceLevel_Notice, "CDR_get_string: string was not NULL-terminated, terminating it now\n");
+		(*str)[len-1]='\0';
+	}
+
+	return(CORBA_TRUE);
+}
+
+CORBA_boolean CDR_get_seq_begin(CDR_Codec *codec, CORBA_unsigned_long *ul)
+{
+	return(CDR_get_ulong(codec, ul));
+}
+
+CDR_Codec *CDR_codec_init_static(CDR_Codec *codec)
+{
+	memset(codec, 0, sizeof(CDR_Codec));
+
+	codec->host_endian = FLAG_ENDIANNESS;
+
+	return codec;
+}
+
+CDR_Codec *CDR_codec_init(void)
+{
+	CDR_Codec *new;
+
+	new=g_new0(CDR_Codec, 1);
+	CDR_codec_init_static(new);
+	new->release_buffer = CORBA_TRUE;
+
+	return(new);
+}
+
+void CDR_codec_free(CDR_Codec *codec)
+{
+	if(codec->release_buffer)
+		g_free(codec->buffer);
+
+	g_free(codec);
+}
diff -urN linux-2.4.1/net/korbit/orb/cdr.h linux-2.4.1-korbit/net/korbit/orb/cdr.h
--- linux-2.4.1/net/korbit/orb/cdr.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/cdr.h	Thu Feb  1 16:22:12 2001
@@ -0,0 +1,83 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CDR_H_
+#define _ORBIT_CDR_H_
+
+#include "orbit_types.h"
+
+typedef enum {
+	BigEndian=0,
+	LittleEndian=1
+} CDR_Endianness;
+
+typedef struct {
+	CDR_Endianness host_endian;
+	CDR_Endianness data_endian;
+	CORBA_octet *buffer;
+	unsigned int buf_len;
+	unsigned int wptr, rptr;
+	CORBA_boolean readonly;
+	CORBA_boolean release_buffer;
+} CDR_Codec;
+
+#define HEXDIGIT(c) (isdigit((guchar)(c))?(c)-'0':tolower((guchar)(c))-'a'+10)
+#define HEXOCTET(a,b) ((HEXDIGIT((a)) << 4) | HEXDIGIT((b)))
+
+extern CDR_Codec *CDR_codec_init(void);
+extern CDR_Codec *CDR_codec_init_static(CDR_Codec *codec);
+extern void CDR_codec_free(CDR_Codec *);
+
+extern void CDR_put_short(CDR_Codec *codec, CORBA_short s);
+extern void CDR_put_ushort(CDR_Codec *codec, CORBA_unsigned_short us);
+extern void CDR_put_long(CDR_Codec *codec, CORBA_long l);
+extern void CDR_put_ulong(CDR_Codec *codec, CORBA_unsigned_long ul);
+#ifdef HAVE_CORBA_LONG_LONG
+extern void CDR_put_long_long(CDR_Codec *codec, CORBA_long_long ll);
+extern void CDR_put_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long ull);
+extern CORBA_boolean CDR_get_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long *ul);
+extern CORBA_boolean CDR_get_long_long(CDR_Codec *codec, CORBA_long_long *ul);
+#endif
+extern void CDR_put_float(CDR_Codec *codec, CORBA_float f);
+extern void CDR_put_double(CDR_Codec *codec, CORBA_double d);
+extern void CDR_put_long_double(CDR_Codec *codec, CORBA_long_double ld);
+extern void CDR_put_octet(CDR_Codec *codec, CORBA_octet datum);
+extern void CDR_put_octets(CDR_Codec *codec, void *data, unsigned long len);
+extern void CDR_put_char(CDR_Codec *codec, CORBA_char c);
+extern void CDR_put_boolean(CDR_Codec *codec, CORBA_boolean datum);
+extern void CDR_put_string(CDR_Codec *codec, const char *str);
+extern CORBA_boolean CDR_buffer_gets(CDR_Codec *codec, void *dest, const unsigned int len);
+extern CORBA_boolean CDR_get_short(CDR_Codec *codec, CORBA_short *us);
+extern CORBA_boolean CDR_get_ushort(CDR_Codec *codec, CORBA_unsigned_short *us);
+extern CORBA_boolean CDR_get_long(CDR_Codec *codec, CORBA_long *l);
+extern CORBA_boolean CDR_get_ulong(CDR_Codec *codec, CORBA_unsigned_long *ul);
+extern CORBA_boolean CDR_get_octet(CDR_Codec *codec, CORBA_octet *datum);
+extern CORBA_boolean CDR_get_boolean(CDR_Codec *codec, CORBA_boolean *b);
+extern CORBA_boolean CDR_get_char(CDR_Codec *codec, CORBA_char *c);
+extern CORBA_boolean CDR_get_string(CDR_Codec *codec, CORBA_char **str);
+extern CORBA_boolean CDR_get_string_static(CDR_Codec *codec, CORBA_char **str);
+extern CORBA_boolean CDR_get_seq_begin(CDR_Codec *codec, CORBA_unsigned_long *ul);
+
+#endif /* !_ORBIT_CDR_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_any.c linux-2.4.1-korbit/net/korbit/orb/corba_any.c
--- linux-2.4.1/net/korbit/orb/corba_any.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_any.c	Thu Feb  1 11:47:10 2001
@@ -0,0 +1,914 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+#include <config.h>
+#include <IIOP/IIOP.h>
+#include "orbit.h"
+
+#if 0
+#define CORBA_Object_release(x, y) ({ g_message(__FILE__ ":%d Releasing object %#x from %d", __LINE__, \
+x, ORBIT_ROOT_OBJECT(x)->refs); CORBA_Object_release(x, y); })
+#define CORBA_Object_duplicate(x, y) ({ g_message(__FILE__ ":%d Duping object %#x from %d", __LINE__, \
+x, ORBIT_ROOT_OBJECT(x)->refs); CORBA_Object_duplicate(x, y); })
+#endif
+
+gint
+ORBit_find_alignment(CORBA_TypeCode tc)
+{
+    gint retval = 1;
+    int i;
+
+    switch(tc->kind) {
+    case CORBA_tk_union:
+	retval = MAX(retval, ORBit_find_alignment(tc->discriminator));
+    case CORBA_tk_except:
+    case CORBA_tk_struct:
+#if ALIGNOF_CORBA_STRUCT > 1
+	retval = MAX(retval, ALIGNOF_CORBA_STRUCT);
+#endif
+	for(i = 0; i < tc->sub_parts; i++)
+	    retval = MAX(retval, ORBit_find_alignment(tc->subtypes[i]));
+	return retval;
+    case CORBA_tk_ulong:
+    case CORBA_tk_long:
+    case CORBA_tk_enum:
+	return ALIGNOF_CORBA_LONG;
+    case CORBA_tk_ushort:
+    case CORBA_tk_short:
+    case CORBA_tk_wchar:
+	return ALIGNOF_CORBA_SHORT;
+    case CORBA_tk_longlong:
+    case CORBA_tk_ulonglong:
+	return ALIGNOF_CORBA_LONG_LONG;
+    case CORBA_tk_longdouble:
+	return ALIGNOF_CORBA_LONG_DOUBLE;
+    case CORBA_tk_float:
+	return ALIGNOF_CORBA_FLOAT;
+    case CORBA_tk_double:
+	return ALIGNOF_CORBA_DOUBLE;
+    case CORBA_tk_boolean:
+    case CORBA_tk_char:
+    case CORBA_tk_octet:
+	return ALIGNOF_CORBA_CHAR;
+    case CORBA_tk_string:
+    case CORBA_tk_wstring:
+    case CORBA_tk_TypeCode:
+    case CORBA_tk_objref:
+	return ALIGNOF_CORBA_POINTER;
+    case CORBA_tk_sequence:
+    case CORBA_tk_any:
+	return MAX(MAX(ALIGNOF_CORBA_LONG, ALIGNOF_CORBA_STRUCT), ALIGNOF_CORBA_POINTER);
+    case CORBA_tk_array:
+    case CORBA_tk_alias:
+	return ORBit_find_alignment(tc->subtypes[0]);
+    case CORBA_tk_fixed:
+	return MAX(ALIGNOF_CORBA_SHORT, ALIGNOF_CORBA_STRUCT);
+    default:
+	return 1;
+    }
+}
+
+static void
+ORBit_marshal_value(GIOPSendBuffer *buf,
+		    gpointer *val,
+		    CORBA_TypeCode tc,
+		    ORBit_marshal_value_info *mi)
+{
+    CORBA_unsigned_long i, ulval;
+    gpointer subval;
+    ORBit_marshal_value_info submi;
+
+#if 0
+    g_message("Marshalling a %d value from %#x to offset %d",
+	      tc->kind, (gulong)*val,
+	      GIOP_MESSAGE_BUFFER(buf)->message_header.message_size);
+#endif
+
+    switch(tc->kind) {
+    case CORBA_tk_wchar:
+    case CORBA_tk_ushort:
+    case CORBA_tk_short:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_SHORT);
+	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_short));
+	*val = ((guchar *)*val) + sizeof(CORBA_short);
+	break;
+    case CORBA_tk_enum:
+    case CORBA_tk_long:
+    case CORBA_tk_ulong:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG);
+	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_long));
+	*val = ((guchar *)*val) + sizeof(CORBA_long);
+	break;
+    case CORBA_tk_float:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_FLOAT);
+	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_float));
+	*val = ((guchar *)*val) + sizeof(CORBA_float);
+	break;
+    case CORBA_tk_double:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_DOUBLE);
+	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_double));
+	*val = ((guchar *)*val) + sizeof(CORBA_double);
+	break;
+    case CORBA_tk_boolean:
+    case CORBA_tk_char:
+    case CORBA_tk_octet:
+	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_octet));
+	*val = ((guchar *)*val) + sizeof(CORBA_octet);
+	break;
+    case CORBA_tk_any:
+	*val = ALIGN_ADDRESS(*val, MAX(ALIGNOF_CORBA_STRUCT, ALIGNOF_CORBA_POINTER));
+	ORBit_marshal_any(buf, *val);
+	*val = ((guchar *)*val) + sizeof(CORBA_any);
+	break;
+    case CORBA_tk_TypeCode:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	ORBit_encode_CORBA_TypeCode(*val, buf);
+	*val = ((guchar *)*val) + sizeof(CORBA_TypeCode);
+	break;
+    case CORBA_tk_Principal:
+	*val = ALIGN_ADDRESS(*val,
+			     MAX(MAX(ALIGNOF_CORBA_LONG, ALIGNOF_CORBA_STRUCT),
+				 ALIGNOF_CORBA_POINTER));
+
+	ulval = *(CORBA_unsigned_long *)(*val);
+	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_unsigned_long));
+
+	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf),
+				       *(char**)((char *)*val+sizeof(CORBA_unsigned_long)),
+				       ulval);
+	*val = ((guchar *)*val) + sizeof(CORBA_Principal);
+	break;
+    case CORBA_tk_objref:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	ORBit_marshal_object(buf, *val);
+	*val = ((guchar *)*val) + sizeof(CORBA_Object);
+	break;
+    case CORBA_tk_except:
+    case CORBA_tk_struct:
+	*val = ALIGN_ADDRESS(*val, ORBit_find_alignment(tc));
+	for(i = 0; i < tc->sub_parts; i++) {
+	    ORBit_marshal_value(buf, val, tc->subtypes[i], mi);
+	}
+	break;
+    case CORBA_tk_union:
+	/* Basic algorithm:
+	   marshal the discriminator
+	   find out which value we want to use */
+	{
+	    CORBA_TypeCode utc;
+
+	    *val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_STRUCT);
+
+	    utc = ORBit_get_union_tag(tc, val, TRUE);
+
+	    *val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_STRUCT);
+
+	    ORBit_marshal_value(buf, val, tc->discriminator, mi);
+	    *val = ALIGN_ADDRESS(*val, ORBit_find_alignment(tc));
+	    ORBit_marshal_value(buf, val, utc, mi);
+	}
+	break;
+    case CORBA_tk_wstring:
+	ulval = strlen(*(char **)*val) + 1;
+
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	giop_send_buffer_append_mem_indirect_a(buf,
+					       &ulval,
+					       sizeof(CORBA_unsigned_long));
+	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), *(char **)*val, ulval);
+	
+	*val = ((guchar *)*val) + sizeof(char *);
+	break;
+    case CORBA_tk_string:
+	ulval = strlen(*(char **)*val) + 1;
+	
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+
+	giop_send_buffer_append_mem_indirect_a(buf,
+					       &ulval,
+					       sizeof(CORBA_unsigned_long));
+	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), *(char **)*val, ulval);
+	
+	*val = ((guchar *)*val) + sizeof(char *);
+	break;
+    case CORBA_tk_sequence:
+	{
+	    CORBA_sequence_octet *sval = *val;
+
+	    *val = ALIGN_ADDRESS(*val,
+				 MAX(MAX(ALIGNOF_CORBA_LONG, ALIGNOF_CORBA_STRUCT), ALIGNOF_CORBA_POINTER));
+
+	    giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf),
+					     &sval->_length,
+					     sizeof(sval->_length));
+
+	    subval = sval->_buffer;
+
+	    for(i = 0; i < sval->_length; i++)
+		ORBit_marshal_value(buf, &subval, tc->subtypes[0], mi);
+	    
+	    *val = ((guchar *)*val) + sizeof(CORBA_sequence_octet);
+	}
+	break;
+    case CORBA_tk_array:
+	submi.alias_element_type = tc->subtypes[0];
+	for(i = 0; i < tc->length; i++) {
+	    ORBit_marshal_value(buf, val, submi.alias_element_type, &submi);
+	    *val = ALIGN_ADDRESS(*val, ORBit_find_alignment(tc->subtypes[0]));
+	}
+	break;
+    case CORBA_tk_alias:
+	submi.alias_element_type = tc->subtypes[0];
+	ORBit_marshal_value(buf, val, submi.alias_element_type, &submi);
+	break;
+    case CORBA_tk_longlong:
+    case CORBA_tk_ulonglong:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_LONG);
+	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_long_long));
+	return /* *val + sizeof(CORBA_long_long)*/;
+	break;
+    case CORBA_tk_longdouble:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_DOUBLE);
+	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_long_double));
+	return /* *val + sizeof(CORBA_long_double)*/;
+	break;
+    case CORBA_tk_fixed:
+	/* XXX todo */
+	g_error("CORBA_fixed NYI");
+	
+	break;
+    case CORBA_tk_null:
+    case CORBA_tk_void:
+	break;
+    default:
+	g_error("Can't encode unknown type %d", tc->kind);
+    }
+}
+
+static glong ORBit_get_union_switch(CORBA_TypeCode tc, gpointer *val, gboolean update)
+{
+#ifdef __KORBIT__
+    glong retval = 0;
+#else
+    glong retval;
+#endif
+
+    switch(tc->kind) {
+    case CORBA_tk_ulong:
+    case CORBA_tk_long:
+    case CORBA_tk_enum:
+	retval = *(CORBA_long *)*val;
+	if(update) *val += sizeof(CORBA_long);
+	break;
+    case CORBA_tk_ushort:
+    case CORBA_tk_short:
+	retval = *(CORBA_short *)*val;
+	if(update) *val += sizeof(CORBA_short);
+	break;
+    case CORBA_tk_char:
+    case CORBA_tk_boolean:
+    case CORBA_tk_octet:
+	retval = *(CORBA_octet *)*val;
+	if(update) *val += sizeof(CORBA_char);
+	break;
+    case CORBA_tk_alias:
+	return ORBit_get_union_switch(tc->subtypes[0], val, update);
+	break;
+    default:
+	g_error("Wow, some nut has passed us a weird type[%d] as a union discriminator!", tc->kind);
+    }
+
+    return retval;
+}
+
+/* This function (and the one above it) exist for the
+   sole purpose of finding out which CORBA_TypeCode a union discriminator value
+   indicates.
+
+   If {update} is TRUE, {*val} will be advanced by the native size
+   of the descriminator type.
+
+   Hairy stuff.
+*/
+CORBA_TypeCode
+ORBit_get_union_tag(CORBA_TypeCode union_tc, gpointer *val, gboolean update)
+{
+    glong discrim_val, case_val;
+    int i;
+    CORBA_TypeCode retval = CORBA_OBJECT_NIL;
+
+    discrim_val = ORBit_get_union_switch(union_tc->discriminator, val, update);
+
+    for(i = 0; i < union_tc->sub_parts; i++) {
+	if(i == union_tc->default_index)
+	    continue;
+
+	case_val = ORBit_get_union_switch(union_tc->sublabels[i]._type,
+					  &union_tc->sublabels[i]._value, FALSE);
+	if(case_val == discrim_val) {
+	    retval = union_tc->subtypes[i];
+	    break;
+	}
+    }
+
+    if(retval)
+	return retval;
+    else if(union_tc->default_index >= 0)
+	return union_tc->subtypes[union_tc->default_index];
+    else {
+	return TC_null;
+    }
+}
+
+void
+ORBit_marshal_arg(GIOPSendBuffer *buf,
+		  gpointer val,
+		  CORBA_TypeCode tc)
+{
+    ORBit_marshal_value_info mi;
+
+    ORBit_marshal_value(buf, &val, tc, &mi);
+}
+
+
+void
+ORBit_marshal_any(GIOPSendBuffer *buf, const CORBA_any *val)
+{
+    ORBit_marshal_value_info mi;
+
+    gpointer mval = val->_value;
+
+    ORBit_encode_CORBA_TypeCode(val->_type, buf);
+
+    ORBit_marshal_value(buf, &mval, val->_type, &mi);
+}
+
+size_t
+ORBit_gather_alloc_info(CORBA_TypeCode tc)
+{
+    int i, n, align=1, prevalign, sum, prev;
+    size_t block_size;
+
+    switch(tc->kind) {
+    case CORBA_tk_long:
+    case CORBA_tk_ulong:
+    case CORBA_tk_enum:
+	return sizeof(CORBA_long);
+	break;
+    case CORBA_tk_short:
+    case CORBA_tk_ushort:
+	return sizeof(CORBA_short);
+	break;
+    case CORBA_tk_float:
+	return sizeof(CORBA_float);
+	break;
+    case CORBA_tk_double:
+	return sizeof(CORBA_double);
+	break;
+    case CORBA_tk_boolean:
+    case CORBA_tk_char:
+    case CORBA_tk_octet:
+	return sizeof(CORBA_octet);
+	break;
+    case CORBA_tk_any:
+	return sizeof(CORBA_any);
+	break;
+    case CORBA_tk_TypeCode:
+	return sizeof(CORBA_TypeCode);
+	break;
+    case CORBA_tk_Principal:
+	return sizeof(CORBA_Principal);
+	break;
+    case CORBA_tk_objref:
+	return sizeof(CORBA_Object);
+	break;
+    case CORBA_tk_except:
+    case CORBA_tk_struct:
+	sum = 0;
+	for(i = 0; i < tc->sub_parts; i++) {
+	    sum = GPOINTER_TO_INT(ALIGN_ADDRESS(sum, ORBit_find_alignment(tc->subtypes[i])));
+	    sum += ORBit_gather_alloc_info(tc->subtypes[i]);
+	}
+	sum = GPOINTER_TO_INT(ALIGN_ADDRESS(sum, ORBit_find_alignment(tc)));
+	return sum;
+	break;
+    case CORBA_tk_union:
+	sum = ORBit_gather_alloc_info(tc->discriminator);
+	n = -1;
+	align = 1;
+	for(prev = prevalign = i = 0; i < tc->sub_parts; i++) {
+	    prevalign = align;
+	    align = ORBit_find_alignment(tc->subtypes[i]);
+	    if(align > prevalign)
+		n = i;
+
+	    prev = MAX(prev, ORBit_gather_alloc_info(tc->subtypes[i]));
+	}
+	if(n >= 0)
+	    sum = GPOINTER_TO_INT(ALIGN_ADDRESS(sum, ORBit_find_alignment(tc->subtypes[n])));
+	sum += prev;
+	sum = GPOINTER_TO_INT(ALIGN_ADDRESS(sum, ORBit_find_alignment(tc)));
+	return sum;
+ 	break;
+    case CORBA_tk_wstring:
+    case CORBA_tk_string:
+	return sizeof(char *);
+	break;
+    case CORBA_tk_sequence:
+	return sizeof(CORBA_sequence_octet);
+	break;
+    case CORBA_tk_array:
+	block_size = ORBit_gather_alloc_info(tc->subtypes[0]);
+	return block_size * tc->length;
+	break;
+    case CORBA_tk_alias:
+	return ORBit_gather_alloc_info(tc->subtypes[0]);
+    case CORBA_tk_longlong:
+    case CORBA_tk_ulonglong:
+	return sizeof(CORBA_long_long);
+    case CORBA_tk_longdouble:
+	return sizeof(CORBA_long_double);
+    case CORBA_tk_wchar:
+	return sizeof(CORBA_wchar);
+    case CORBA_tk_fixed:
+	return sizeof(CORBA_fixed_d_s);
+    default:
+	return 0;
+    }
+}
+
+/* to allocate a block, we need to know of any important data
+   contained in it.
+*/
+static gpointer
+ORBit_demarshal_allocate_mem(CORBA_TypeCode tc, gint nelements)
+{
+    size_t block_size;
+    gpointer retval = NULL;
+
+    if(!nelements) return retval;
+
+    block_size = ORBit_gather_alloc_info(tc);
+
+    if(block_size) {
+	retval = ORBit_alloc_2(block_size * nelements,
+			       (ORBit_free_childvals)ORBit_free_via_TypeCode,
+			       GINT_TO_POINTER(nelements),
+			       sizeof(CORBA_TypeCode));
+
+	*(CORBA_TypeCode *)((char *)retval-sizeof(ORBit_mem_info)-sizeof(CORBA_TypeCode)) = (CORBA_TypeCode)CORBA_Object_duplicate((CORBA_Object)tc, NULL);
+    }
+
+    return retval;
+}
+
+#define DM_GET_ATOM(x, n) G_STMT_START{ GIOP_RECV_BUFFER(buf)->decoder(x, (GIOP_RECV_BUFFER(buf)->cur), n); GIOP_RECV_BUFFER(buf)->cur = ((guchar *)GIOP_RECV_BUFFER(buf)->cur) + n; }G_STMT_END
+
+static void
+ORBit_demarshal_value(GIOPRecvBuffer *buf,
+		      gpointer *val,
+		      CORBA_TypeCode tc,
+		      gboolean dup_strings,
+		      CORBA_ORB orb)
+{
+    CORBA_long i, n;
+
+#if 0
+    g_message("Demarshalling a %d value from offset %d into %#x",
+	      tc->kind, buf->cur - buf->message_body, (gulong)*val);
+#endif
+
+    switch(tc->kind) {
+    case CORBA_tk_short:
+    case CORBA_tk_ushort:
+    case CORBA_tk_wchar:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_SHORT);
+	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_short));
+	DM_GET_ATOM(*val, sizeof(CORBA_short));
+	*val = ((guchar *)*val) + sizeof(CORBA_short);
+	break;
+    case CORBA_tk_long:
+    case CORBA_tk_ulong:
+    case CORBA_tk_enum:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG);
+	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long));
+	DM_GET_ATOM(*val, sizeof(CORBA_long));
+	*val = ((guchar *)*val) + sizeof(CORBA_long);
+	break;
+    case CORBA_tk_longlong:
+    case CORBA_tk_ulonglong:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_LONG);
+	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long_long));
+	DM_GET_ATOM(*val, sizeof(CORBA_long_long));
+	*val = ((guchar *)*val) + sizeof(CORBA_long_long);
+	break;
+    case CORBA_tk_longdouble:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_DOUBLE);
+	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long_double));
+	DM_GET_ATOM(*val, sizeof(CORBA_long_double));
+	*val = ((guchar *)*val) + sizeof(CORBA_long_double);
+	break;
+    case CORBA_tk_float:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_FLOAT);
+	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_float));
+	DM_GET_ATOM(*val, sizeof(CORBA_float));
+	*val = ((guchar *)*val) + sizeof(CORBA_float);
+	break;
+    case CORBA_tk_double:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_DOUBLE);
+	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_double));
+	DM_GET_ATOM(*val, sizeof(CORBA_double));
+	*val = ((guchar *)*val) + sizeof(CORBA_double);
+	break;
+    case CORBA_tk_boolean:
+    case CORBA_tk_char:
+    case CORBA_tk_octet:
+	DM_GET_ATOM(*val, sizeof(CORBA_octet));
+	*val = ((guchar *)*val) + sizeof(CORBA_octet);
+	break;
+    case CORBA_tk_any:
+	{
+	    CORBA_any *decoded;
+
+	    *val = ALIGN_ADDRESS(*val,
+				 MAX(ALIGNOF_CORBA_LONG,
+				     MAX(ALIGNOF_CORBA_POINTER, ALIGNOF_CORBA_STRUCT)));
+	    decoded = *val;
+	    decoded->_release = CORBA_FALSE;
+	    ORBit_demarshal_any(buf, decoded, dup_strings, orb);
+	    *val = ((guchar *)*val) + sizeof(CORBA_any);
+	}
+	break;
+    case CORBA_tk_TypeCode:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	ORBit_decode_CORBA_TypeCode(*val, buf);
+	CORBA_Object_duplicate(*(CORBA_Object *)*val, NULL);
+	*val = ((guchar *)*val) + sizeof(CORBA_TypeCode);
+	break;
+    case CORBA_tk_Principal:
+	{
+	    CORBA_Principal *p;
+
+	    *val = ALIGN_ADDRESS(*val, MAX(ALIGNOF_CORBA_STRUCT,
+					   MAX(ALIGNOF_CORBA_LONG, ALIGNOF_CORBA_POINTER)));
+
+	    p = *val;
+	    buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long));
+	    CORBA_sequence_set_release(p, dup_strings);
+	    DM_GET_ATOM(&p->_length, sizeof(CORBA_long));
+	    p->_buffer = ORBit_alloc(p->_length, NULL, GINT_TO_POINTER(1));
+	    memcpy(p->_buffer, buf->cur, p->_length);
+	    buf->cur = ((guchar *)buf->cur) + p->_length;
+	    *val = ((guchar *)*val) + sizeof(CORBA_sequence_octet);
+	}
+	break;
+    case CORBA_tk_objref:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	*(CORBA_Object *)*val = ORBit_demarshal_object(buf, orb);
+	*val = ((guchar *)*val) + sizeof(CORBA_Object);
+	break;
+    case CORBA_tk_except:
+    case CORBA_tk_struct:
+	*val = ALIGN_ADDRESS(*val, ORBit_find_alignment(tc));
+	for(i = 0; i < tc->sub_parts; i++) {
+	    ORBit_demarshal_value(buf, val, tc->subtypes[i], dup_strings, orb);
+	}
+	break;
+    case CORBA_tk_union:
+	{
+	    gpointer discrimptr;
+
+	    discrimptr = *val = ALIGN_ADDRESS(*val, ORBit_find_alignment(tc));
+	    ORBit_demarshal_value(buf, val, tc->discriminator, dup_strings, orb);
+	    n = 1;
+	    for(i = 0; i < tc->sub_parts; i++) {
+		n = MAX(n, ORBit_find_alignment(tc->subtypes[i]));
+	    }
+	    *val = ALIGN_ADDRESS(*val, n);
+	    ORBit_demarshal_value(buf, val,
+				  ORBit_get_union_tag(tc, &discrimptr, FALSE),
+				  dup_strings, orb);
+	}
+	break;
+    case CORBA_tk_string:
+    case CORBA_tk_wstring:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long));
+	DM_GET_ATOM(&i, sizeof(CORBA_long));
+	if(dup_strings)
+	    *(char **)*val = CORBA_string_dup(buf->cur);
+	else
+	    *(char **)*val = buf->cur;
+	*val = ((guchar *)*val) + sizeof(CORBA_char *);
+	buf->cur = (gpointer)((char *)buf->cur + i);
+	break;
+    case CORBA_tk_sequence:
+	{
+	    CORBA_sequence_octet *p;
+	    gpointer subval;
+
+	    *val = ALIGN_ADDRESS(*val, MAX(ALIGNOF_CORBA_STRUCT,
+					   MAX(ALIGNOF_CORBA_LONG, ALIGNOF_CORBA_POINTER)));
+	    p = *val;
+	    buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long));
+	    DM_GET_ATOM(&p->_length, sizeof(CORBA_long));
+	    if(tc->subtypes[0]->kind == CORBA_tk_octet
+	       || tc->subtypes[0]->kind == CORBA_tk_boolean
+	       || tc->subtypes[0]->kind == CORBA_tk_char) {
+		/* This special-casing could be taken further to apply to
+		   all atoms... */
+		p->_buffer = ORBit_alloc(p->_length, NULL, GINT_TO_POINTER(1));
+		memcpy(p->_buffer, buf->cur, p->_length);
+		buf->cur = ((guchar *)buf->cur) + p->_length;
+	    } else {
+		p->_buffer = ORBit_demarshal_allocate_mem(tc->subtypes[0],
+							  p->_length);
+		subval = p->_buffer;
+
+		for(i = 0; i < p->_length; i++)
+		    ORBit_demarshal_value(buf, &subval,
+					  tc->subtypes[0],
+					  dup_strings,
+					  orb);
+	    }
+
+	    *val = ((guchar *)*val) + sizeof(CORBA_sequence_octet);
+	}
+	break;
+    case CORBA_tk_array:
+	for(i = 0; i < tc->length; i++)
+	    ORBit_demarshal_value(buf, val, tc->subtypes[0], dup_strings, orb);
+	break;
+    case CORBA_tk_alias:
+	ORBit_demarshal_value(buf, val, tc->subtypes[0], dup_strings, orb);
+	break;
+    case CORBA_tk_fixed:
+	g_error("CORBA_fixed NYI");
+	break;
+    default:
+        break;
+    }
+}
+
+gpointer
+ORBit_demarshal_arg(GIOPRecvBuffer *buf,
+		    CORBA_TypeCode tc,
+		    gboolean dup_strings,
+		    CORBA_ORB orb)
+{
+    gpointer retval, val;
+
+    retval = val = ORBit_demarshal_allocate_mem(tc, 1);
+
+    ORBit_demarshal_value(buf, &val, tc, dup_strings, orb);
+
+    return retval;
+}
+
+void
+ORBit_demarshal_any(GIOPRecvBuffer *buf, CORBA_any *retval,
+		    gboolean dup_strings,
+		    CORBA_ORB orb)
+{
+    gpointer val;
+
+#if 0
+    /* I wish I knew whether this was correct or not. It breaks things like 'any anop();' for sure,
+       since we can't always initialize every single possible 'any' underneath _ORBIT_retval */
+    if(retval->_release)
+	CORBA_free(retval->_value);
+#endif
+
+    CORBA_any_set_release(retval, CORBA_TRUE);
+
+    ORBit_decode_CORBA_TypeCode(&retval->_type, buf);
+    CORBA_Object_duplicate((CORBA_Object)retval->_type, NULL);
+
+    val = retval->_value = ORBit_demarshal_allocate_mem(retval->_type, 1);
+    ORBit_demarshal_value(buf, &val, retval->_type, dup_strings, orb);
+}
+
+void
+_ORBit_copy_value(gpointer *val, gpointer *newval, CORBA_TypeCode tc)
+{
+    CORBA_long i;
+    gpointer pval1, pval2;
+
+    switch(tc->kind) {
+    case CORBA_tk_wchar:
+    case CORBA_tk_short:
+    case CORBA_tk_ushort:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_SHORT);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_SHORT);
+	*(CORBA_short *)*newval = *(CORBA_short *)*val;
+	*val = ((guchar *)*val) + sizeof(CORBA_short);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_short);
+	break;
+    case CORBA_tk_enum:
+    case CORBA_tk_long:
+    case CORBA_tk_ulong:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_LONG);
+	*(CORBA_long *)*newval = *(CORBA_long *)*val;
+	*val = ((guchar *)*val) + sizeof(CORBA_long);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_long);
+	break;
+    case CORBA_tk_longlong:
+    case CORBA_tk_ulonglong:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_LONG);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_LONG_LONG);
+	*(CORBA_long_long *)*newval = *(CORBA_long_long *)*val;
+	*val = ((guchar *)*val) + sizeof(CORBA_long_long);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_long_long);
+	break;
+    case CORBA_tk_longdouble:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_DOUBLE);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_LONG_DOUBLE);
+	*(CORBA_long_double *)*newval = *(CORBA_long_double *)*val;
+	*val = ((guchar *)*val) + sizeof(CORBA_long_double);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_long_double);
+	break;
+    case CORBA_tk_float:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_FLOAT);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_FLOAT);
+	*(CORBA_long *)*newval = *(CORBA_long *)*val;
+	*val = ((guchar *)*val) + sizeof(CORBA_float);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_float);
+	break;
+    case CORBA_tk_double:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_DOUBLE);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_DOUBLE);
+	*(CORBA_double *)*newval = *(CORBA_double *)*val;
+	*val = ((guchar *)*val) + sizeof(CORBA_double);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_double);
+	break;
+    case CORBA_tk_boolean:
+    case CORBA_tk_char:
+    case CORBA_tk_octet:
+	*(CORBA_octet *)*newval = *(CORBA_octet *)*val;
+	*val = ((guchar *)*val) + sizeof(CORBA_octet);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_octet);
+	break;
+    case CORBA_tk_any:
+	{
+	    CORBA_any *oldany, *newany;
+	    *val = ALIGN_ADDRESS(*val, MAX(ALIGNOF_CORBA_STRUCT, ALIGNOF_CORBA_POINTER));
+	    *newval = ALIGN_ADDRESS(*newval, MAX(ALIGNOF_CORBA_STRUCT, ALIGNOF_CORBA_POINTER));
+	    oldany = *val;
+	    newany = *newval;
+	    newany->_type = (CORBA_TypeCode)CORBA_Object_duplicate((CORBA_Object)oldany->_type, NULL);
+	    /* XXX are we supposed to do this even if oldany->_release
+               == FALSE? */
+	    newany->_value = ORBit_copy_value(oldany->_value, oldany->_type);
+	    newany->_release = CORBA_TRUE;
+	    *val = ((guchar *)*val) + sizeof(CORBA_any);
+	    *newval = ((guchar *)*newval) + sizeof(CORBA_any);
+	}
+	break;
+    case CORBA_tk_Principal:
+	*val = ALIGN_ADDRESS(*val,
+			     MAX(MAX(ALIGNOF_CORBA_LONG,
+				     ALIGNOF_CORBA_STRUCT),
+				 ALIGNOF_CORBA_POINTER));
+	*newval = ALIGN_ADDRESS(*newval,
+				MAX(MAX(ALIGNOF_CORBA_LONG,
+					ALIGNOF_CORBA_STRUCT),
+				    ALIGNOF_CORBA_POINTER));
+	*(CORBA_Principal *)*newval = *(CORBA_Principal *)*val;
+	((CORBA_Principal *)*newval)->_buffer =
+	    CORBA_octet_allocbuf(((CORBA_Principal *)*newval)->_length);
+	memcpy(((CORBA_Principal *)*newval)->_buffer,
+	       ((CORBA_Principal *)*val)->_buffer,
+	       ((CORBA_Principal *)*val)->_length);
+	*val = ((guchar *)*val) + sizeof(CORBA_Principal);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_Principal);
+	break;
+    case CORBA_tk_TypeCode:
+    case CORBA_tk_objref:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_POINTER);
+	*(CORBA_Object *)*newval = CORBA_Object_duplicate(*(CORBA_Object *)*val,
+							  NULL);
+	*val = ((guchar *)*val) + sizeof(CORBA_Object);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_Object);
+	break;
+    case CORBA_tk_struct:
+    case CORBA_tk_except:
+	*val = ALIGN_ADDRESS(*val, ORBit_find_alignment(tc));
+	*newval = ALIGN_ADDRESS(*newval, ORBit_find_alignment(tc));
+	for(i = 0; i < tc->sub_parts; i++) {
+	    _ORBit_copy_value(val, newval, tc->subtypes[i]);
+	}
+	break;
+    case CORBA_tk_union:
+	{
+	    CORBA_TypeCode utc = ORBit_get_union_tag(tc, val, FALSE);
+	    gint	union_align = ORBit_find_alignment(tc);
+	    size_t	union_size = ORBit_gather_alloc_info(tc);
+
+	    /* need to advance val,newval by size of union, not just
+	     * current tagged field within it */
+	    pval1 = *val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_STRUCT);
+	    pval2 = *newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_STRUCT);
+	    _ORBit_copy_value(&pval1, &pval2, tc->discriminator);
+	    pval1 = ALIGN_ADDRESS(pval1, union_align);
+	    pval2 = ALIGN_ADDRESS(pval2, union_align);
+	    _ORBit_copy_value(&pval1, &pval2, utc);
+	    *val = ((guchar *)*val) + union_size;
+	    *newval = ((guchar *)*newval) + union_size;
+	}
+	break;
+    case CORBA_tk_wstring:
+    case CORBA_tk_string:
+	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
+	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_POINTER);
+	
+	*(CORBA_char **)*newval = CORBA_string_dup(*(CORBA_char **)*val);
+	*val = ((guchar *)*val) + sizeof(CORBA_char *);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_char *);
+	break;
+    case CORBA_tk_sequence:
+	*val = ALIGN_ADDRESS(*val,
+			     MAX(MAX(ALIGNOF_CORBA_LONG,
+				     ALIGNOF_CORBA_STRUCT),
+				 ALIGNOF_CORBA_POINTER));
+	*newval = ALIGN_ADDRESS(*newval,
+				MAX(MAX(ALIGNOF_CORBA_LONG,
+					ALIGNOF_CORBA_STRUCT),
+				    ALIGNOF_CORBA_POINTER));
+	((CORBA_Principal *)*newval)->_release = CORBA_TRUE;
+	((CORBA_Principal *)*newval)->_length =
+	     ((CORBA_Principal *)*newval)->_maximum =
+					 ((CORBA_Principal *)*val)->_length;
+	((CORBA_Principal *)*newval)->_buffer = pval2 =
+	    ORBit_demarshal_allocate_mem(tc->subtypes[0],
+					 ((CORBA_Principal *)*val)->_length);
+	pval1 = ((CORBA_Principal *)*val)->_buffer;
+	
+	for(i = 0; i < ((CORBA_Principal *)*newval)->_length; i++) {
+	    _ORBit_copy_value(&pval1, &pval2, tc->subtypes[0]);
+	}
+	*val = ((guchar *)*val) + sizeof(CORBA_sequence_octet);
+	*newval = ((guchar *)*newval) + sizeof(CORBA_sequence_octet);
+	break;
+    case CORBA_tk_array:
+	for(i = 0; i < tc->length; i++) {
+	    _ORBit_copy_value(val, newval, tc->subtypes[0]);
+	}
+	break;
+    case CORBA_tk_alias:
+	_ORBit_copy_value(val, newval, tc->subtypes[0]);
+	break;
+    case CORBA_tk_fixed:
+	g_error("CORBA_fixed NYI!");
+	break;
+    case CORBA_tk_void:
+    case CORBA_tk_null:
+	*val = NULL;
+	break;
+    default:
+	g_error("Can't handle copy of value kind %d", tc->kind);
+    }
+}
+
+gpointer
+ORBit_copy_value(gpointer value, CORBA_TypeCode tc)
+{
+    gpointer retval, newval;
+
+    retval = newval = ORBit_demarshal_allocate_mem(tc, 1);
+    _ORBit_copy_value(&value, &newval, tc);
+
+    return retval;
+}
+
+void
+CORBA_any__copy(CORBA_any *out, CORBA_any *in)
+{
+    out->_type = (CORBA_TypeCode)CORBA_Object_duplicate((CORBA_Object)in->_type,
+							NULL);
+    out->_value = ORBit_copy_value(in->_value, in->_type);
+    out->_release = CORBA_TRUE;
+}
diff -urN linux-2.4.1/net/korbit/orb/corba_any.h linux-2.4.1-korbit/net/korbit/orb/corba_any.h
--- linux-2.4.1/net/korbit/orb/corba_any.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_any.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,45 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_ANY_H_
+#define _ORBIT_CORBA_ANY_H_
+
+#include "orbit_types.h"
+#include "corba_typecode.h"
+
+#include <unistd.h>
+
+typedef struct CORBA_any_type CORBA_any;
+
+size_t ORBit_gather_alloc_info(CORBA_TypeCode tc);
+gint ORBit_find_alignment(CORBA_TypeCode tc);
+CORBA_TypeCode ORBit_get_union_tag(CORBA_TypeCode union_tc,
+				   gpointer *val, gboolean update);
+gpointer ORBit_copy_value(gpointer value, CORBA_TypeCode tc);
+void _ORBit_copy_value(gpointer *val, gpointer *newval, CORBA_TypeCode tc);
+
+void CORBA_any__copy(CORBA_any *out, CORBA_any *in);
+
+#endif /* !_ORBIT_CORBA_ANY_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_any_proto.h linux-2.4.1-korbit/net/korbit/orb/corba_any_proto.h
--- linux-2.4.1/net/korbit/orb/corba_any_proto.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_any_proto.h	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,16 @@
+#ifndef _ORBIT_CORBA_ANY_PROTO_H_
+#define _ORBIT_CORBA_ANY_PROTO_H_
+
+void ORBit_marshal_arg(GIOPSendBuffer *buf,
+		       gpointer val,
+		       CORBA_TypeCode tc);
+void ORBit_marshal_any(GIOPSendBuffer *buf, const CORBA_any *val);
+gpointer ORBit_demarshal_arg(GIOPRecvBuffer *buf,
+			     CORBA_TypeCode tc,
+			     gboolean dup_strings,
+			     CORBA_ORB orb);
+void ORBit_demarshal_any(GIOPRecvBuffer *buf, CORBA_any *retval,
+			 gboolean dup_strings,
+			 CORBA_ORB orb);
+
+#endif /* !_ORBIT_CORBA_ANY_PROTO_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_any_type.h linux-2.4.1-korbit/net/korbit/orb/corba_any_type.h
--- linux-2.4.1/net/korbit/orb/corba_any_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_any_type.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,48 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@acm.org>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_ANY_TYPE_H_
+#define _ORBIT_CORBA_ANY_TYPE_H_
+
+#include "corba_any.h"
+#include "corba_typecode.h"
+
+struct CORBA_any_type {
+	CORBA_TypeCode _type;
+	gpointer _value;
+	CORBA_boolean _release;
+};
+
+typedef struct ORBit_marshal_value_info_struct {
+	CORBA_TypeCode alias_element_type;
+} ORBit_marshal_value_info;
+
+#define CORBA_ANYFLAGS_RELEASE 1
+
+
+#endif /* !_ORBIT_CORBA_ANY_TYPE_H_ */
+
+
+
diff -urN linux-2.4.1/net/korbit/orb/corba_basic_sequences_type.h linux-2.4.1-korbit/net/korbit/orb/corba_basic_sequences_type.h
--- linux-2.4.1/net/korbit/orb/corba_basic_sequences_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_basic_sequences_type.h	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,43 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_BASIC_SEQUENCES_TYPE_H_
+#define _ORBIT_CORBA_BASIC_SEQUENCES_TYPE_H_
+
+#include <ORBitutil/basic_types.h>
+
+#ifndef _CORBA_sequence_octet_defined
+#define _CORBA_sequence_octet_defined 1
+
+typedef struct CORBA_sequence_octet_struct {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_octet *_buffer;
+	CORBA_boolean _release;
+} CORBA_sequence_octet;
+#endif /* !_CORBA_sequence_octet_defined */
+
+#include <orb/corba_sequences.h>
+#endif /* !_ORBIT_CORBA_BASIC_SEQUENCES_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_context.c linux-2.4.1-korbit/net/korbit/orb/corba_context.c
--- linux-2.4.1/net/korbit/orb/corba_context.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_context.c	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,390 @@
+#include "orb/orbit.h"
+
+#define o_return_val_if_fail(expr, val) if(!(expr)) { CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM, CORBA_COMPLETED_NO); return (val); }
+#define o_return_if_fail(expr) if(!(expr)) { CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM, CORBA_COMPLETED_NO); return; }
+
+static gboolean
+free_entry(gpointer key, gpointer value, gpointer user_data)
+{
+  g_free(key);
+  g_free(value);
+
+  return TRUE;
+}
+
+static void
+ORBit_Context_release(CORBA_Context ctx, CORBA_Environment *ev);
+
+static gboolean
+free_child(gpointer value, gpointer user_data)
+{
+  CORBA_Context ctx = value;
+
+  ORBIT_ROOT_OBJECT(ctx)->refs = 1;
+  ctx->parent_ctx = CORBA_OBJECT_NIL;
+  ORBit_Context_release(ctx, NULL);
+
+  return TRUE;
+}
+
+static void
+ORBit_Context_release(CORBA_Context ctx,
+		      CORBA_Environment *ev)
+{
+  ORBIT_ROOT_OBJECT_UNREF(ctx);
+
+  if(ORBIT_ROOT_OBJECT(ctx)->refs <= 0) {
+    if(ctx->children) {
+      g_slist_foreach(ctx->children, (GFunc)free_child, ctx);
+      g_slist_free(ctx->children);
+    }
+
+    if(ctx->mappings) {
+      g_hash_table_foreach_remove(ctx->mappings, free_entry, ctx);
+      g_hash_table_destroy(ctx->mappings);
+    }
+
+    if(ctx->parent_ctx != CORBA_OBJECT_NIL)
+      ctx->parent_ctx->children = g_slist_remove(ctx->parent_ctx->children, ctx->the_name);
+	  
+    g_free(ctx->the_name);
+	  
+    g_free(ctx);
+  }
+}
+
+static const ORBit_RootObject_Interface CORBA_Context_epv =
+{
+  (void (*)(gpointer, CORBA_Environment *))ORBit_Context_release,
+};
+
+static CORBA_Context
+CORBA_Context_new(CORBA_Context parent, const char *name, CORBA_Environment *ev)
+{
+  CORBA_Context retval;
+
+  retval = g_new0(struct CORBA_Context_type, 1);
+
+  ORBit_pseudo_object_init(ORBIT_PSEUDO_OBJECT(retval), ORBIT_PSEUDO_CONTEXT, ev);
+
+  ORBIT_ROOT_OBJECT(retval)->refs = 0;
+  ORBit_RootObject_set_interface(ORBIT_ROOT_OBJECT(retval), (gpointer)&CORBA_Context_epv, ev);
+
+  if(name)
+    retval->the_name = g_strdup(name);
+
+  retval->parent_ctx = parent;
+  if(parent)
+    parent->children = g_slist_prepend(parent->children, retval);
+
+  return retval;
+}
+
+/* Section 5.6.1 */
+CORBA_Status CORBA_ORB_get_default_context(CORBA_ORB orb, CORBA_Context *ctx, CORBA_Environment *ev)
+{
+  g_return_if_fail(ev != NULL);
+  o_return_if_fail(orb && ctx);
+
+  if(!orb->default_ctx)
+    orb->default_ctx = CORBA_Context_new(CORBA_OBJECT_NIL, NULL, ev);
+
+  *ctx = (CORBA_Context)CORBA_Object_duplicate((CORBA_Object)orb->default_ctx, ev);
+}
+
+/********* XXX todo - CORBA_Context support */
+CORBA_Status CORBA_Context_set_one_value(CORBA_Context ctx, CORBA_Identifier prop_name, char *value, CORBA_Environment *ev)
+{
+  gpointer old_nom, old_value;
+  g_return_if_fail(ev != NULL);
+  o_return_if_fail(ctx && prop_name && value);
+
+  if(!ctx->mappings)
+    ctx->mappings = g_hash_table_new(g_str_hash, g_str_equal);
+
+  if(g_hash_table_lookup_extended(ctx->mappings, prop_name, &old_nom, &old_value)) {
+    g_free(old_nom);
+    g_free(old_value);
+  }
+
+  g_hash_table_insert(ctx->mappings, g_strdup(prop_name), g_strdup(value));
+}
+
+/* Section 5.6.3 */
+CORBA_Status CORBA_Context_set_values(CORBA_Context ctx, CORBA_NVList *values, CORBA_Environment *ev)
+{
+  int i;
+
+  for(i = 0; i < values->list->len; i++) {
+    CORBA_NamedValue *nvp;
+
+    nvp = ((CORBA_NamedValue *)values->list->data) + i;
+
+    g_assert(nvp->argument._type == TC_string);
+
+    CORBA_Context_set_one_value(ctx, nvp->name, nvp->argument._value, ev);
+  }
+}
+
+/* Section 5.6.4 */
+
+typedef struct {
+  CORBA_Context ctx;
+  CORBA_Identifier prop_name;
+  CORBA_NVList *values;
+  CORBA_Environment *ev;
+  int len;
+} CTXSearchInfo;
+
+static gboolean
+list_has_key(CORBA_NVList *list, const char *key)
+{
+  int i;
+
+  for(i = 0; i < list->list->len; i++) {
+    CORBA_NamedValue *nvp;
+
+    nvp = ((CORBA_NamedValue *)list->list->data) + i;
+
+    if(!strcmp(nvp->name, key))
+      return TRUE;
+  }
+
+  return FALSE;
+}
+
+static void
+search_props(gpointer key, gpointer value, CTXSearchInfo *csi)
+{
+  if(strncmp(key, csi->prop_name, csi->len))
+    return;
+
+  if(list_has_key(csi->values, key))
+    return;
+
+  CORBA_NVList_add_item(csi->values, key, TC_string, &value, strlen(value) + 1, CORBA_IN_COPY_VALUE, NULL);
+}
+
+static void
+ctx_get_values(CORBA_Context ctx, CORBA_Flags op_flags,
+	       CORBA_Identifier prop_name, CORBA_NVList **values,
+	       gint is_wc,
+	       CORBA_Environment *ev)
+{
+  gboolean go_up = FALSE;
+
+  if(is_wc >= 0) {
+    CTXSearchInfo csi;
+  
+    csi.ctx = ctx;
+    csi.prop_name = prop_name;
+    csi.values = *values;
+    csi.ev = ev;
+    csi.len = is_wc;
+
+    if(ctx->mappings)
+      g_hash_table_foreach(ctx->mappings, (GHFunc)search_props, &csi);
+
+    go_up = TRUE;
+
+  } else {
+    char *val = NULL;
+
+    if(ctx->mappings)
+      val = g_hash_table_lookup(ctx->mappings, prop_name);
+
+    if(val)
+      CORBA_NVList_add_item(*values, prop_name, TC_string, &val, strlen(val) + 1, CORBA_IN_COPY_VALUE, ev);
+    else
+      go_up = TRUE;
+  }
+
+  if(go_up
+     && ctx->parent_ctx
+     && !(op_flags & CORBA_CTX_RESTRICT_SCOPE))
+    ctx_get_values(ctx->parent_ctx, op_flags, prop_name, values, is_wc, ev);
+}
+
+CORBA_Status CORBA_Context_get_values(CORBA_Context ctx,
+				      CORBA_Identifier start_scope,
+				      CORBA_Flags op_flags,
+				      CORBA_Identifier prop_name,
+				      CORBA_NVList **values,
+				      CORBA_Environment *ev)
+{
+  char *ctmp;
+  int wc_pos;
+
+  CORBA_ORB_create_list(CORBA_OBJECT_NIL, 0, values, ev);
+
+  if(start_scope && *start_scope) {
+    while(ctx && (!ctx->the_name || strcmp(ctx->the_name, start_scope)))
+      ctx = ctx->parent_ctx;
+
+    if(!ctx) {
+      CORBA_exception_set_system(ev, ex_CORBA_INV_IDENT, CORBA_COMPLETED_NO);
+      return;
+    }
+  }
+
+  ctmp = strchr(prop_name, '*');
+  if(ctmp)
+    wc_pos = ctmp - prop_name;
+  else
+    wc_pos = -1;
+
+  CORBA_ORB_create_list(CORBA_OBJECT_NIL, 0, values, ev);
+
+  ctx_get_values(ctx, op_flags, prop_name, values, (prop_name[strlen(prop_name) - 1] == '*'), ev);
+
+  if((*values)->list->len == 0)
+    {
+      CORBA_NVList_free(*values, ev);
+      *values = NULL;
+      CORBA_exception_set_system(ev, ex_CORBA_UNKNOWN, CORBA_COMPLETED_NO);
+    }
+}
+
+/* Section 5.6.5 */
+static void
+delete_props(gpointer key, gpointer value, CTXSearchInfo *csi)
+{
+  if(strncmp(key, csi->prop_name, csi->len))
+    return;
+
+  g_hash_table_remove(csi->ctx->mappings, key);
+  g_free(key);
+  g_free(value);
+}
+
+CORBA_Status CORBA_Context_delete_values(CORBA_Context ctx, CORBA_Identifier prop_name, CORBA_Environment *ev)
+{
+  char *ctmp;
+  int wc_pos;
+
+  if(!ctx->mappings)
+    return;
+
+  ctmp = strchr(prop_name, '*');
+  if(ctmp)
+    wc_pos = ctmp - prop_name;
+  else
+    wc_pos = -1;
+
+  if(wc_pos >= 0) {
+    CTXSearchInfo csi;
+
+    memset(&csi, 0, sizeof(csi));
+    csi.ctx = ctx;
+    csi.prop_name = prop_name;
+    csi.ev = ev;
+    csi.len = wc_pos;
+
+    g_hash_table_foreach(ctx->mappings, (GHFunc)delete_props, &csi);
+  } else {
+    gpointer old_nom, old_value;
+
+    if(g_hash_table_lookup_extended(ctx->mappings, prop_name, &old_nom, &old_value)) {
+      g_free(old_nom);
+      g_free(old_value);
+    }
+  }
+}
+
+/* Section 5.6.6 */
+CORBA_Status CORBA_Context_create_child(CORBA_Context ctx, CORBA_Identifier ctx_name, CORBA_Context *child_ctx, CORBA_Environment *ev)
+{
+  *child_ctx = CORBA_Context_new(ctx, ctx_name, ev);
+}
+
+/* Section 5.6.7 */
+CORBA_Status CORBA_Context_delete(CORBA_Context ctx, CORBA_Flags del_flags, CORBA_Environment *ev)
+{
+  if((del_flags & CORBA_CTX_DELETE_DESCENDENTS)
+     || !ctx->children)
+    free_child(ctx, NULL);
+}
+
+void
+ORBit_Context_marshal(CORBA_Context ctx, const ORBit_ContextMarshalItem *mlist, CORBA_unsigned_long nitems, GIOPSendBuffer *buf)
+{
+  int i;
+  CORBA_unsigned_long *real_nitems, ltmp;
+
+  real_nitems = giop_send_buffer_append_mem_indirect_a(buf, &nitems, sizeof(nitems));
+  if(!ctx->mappings) {
+    *real_nitems = 0;
+    return;
+  }
+
+  for(*real_nitems = i = 0; i < nitems; i++) {
+    char *value;
+
+    value = g_hash_table_lookup(ctx->mappings, mlist[i].str);
+    if(!value)
+      continue;
+
+    /* Key */
+    giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), &(mlist[i].len), sizeof(mlist[i].len));
+    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), mlist[i].str, mlist[i].len);
+    (*real_nitems)++;
+
+    /* Value */
+    ltmp = strlen(value) + 1;
+    giop_send_buffer_append_mem_indirect_a(buf, &ltmp, sizeof(ltmp));
+    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), value, ltmp);
+    (*real_nitems)++;
+  }
+}
+
+#define GET_ATOM(x) G_STMT_START{ GIOP_RECV_BUFFER(recv_buffer)->decoder(&x, (GIOP_RECV_BUFFER(recv_buffer)->cur), sizeof(x)); \
+GIOP_RECV_BUFFER(recv_buffer)->cur = ((guchar *)GIOP_RECV_BUFFER(recv_buffer)->cur) + sizeof(x); \
+}G_STMT_END
+#define ALIGNFOR(x) recv_buffer->cur = ALIGN_ADDRESS(recv_buffer->cur, sizeof(x))
+
+void
+ORBit_Context_demarshal(CORBA_Context parent, CORBA_Context initme, GIOPRecvBuffer *recv_buffer)
+{
+  CORBA_unsigned_long nstrings, keylen, vallen, i;
+  char *key, *value;
+
+  memset(initme, 0, sizeof(struct CORBA_Context_type));
+  ORBIT_ROOT_OBJECT(initme)->refs = -1;
+
+  initme->parent_ctx = parent;
+
+  ALIGNFOR(nstrings);
+  GET_ATOM(nstrings);
+
+  if(nstrings)
+    initme->mappings = g_hash_table_new(g_str_hash, g_str_equal);
+  else
+    return;
+
+  g_hash_table_freeze(initme->mappings);
+  for(i = 0; i < nstrings; ) {
+    ALIGNFOR(keylen);
+    GET_ATOM(keylen);
+    key = recv_buffer->cur;
+    recv_buffer->cur = ((char *)recv_buffer->cur) + keylen;
+    i++;
+
+    if(i >= nstrings)
+      break;
+
+    ALIGNFOR(vallen);
+    GET_ATOM(vallen);
+    value = recv_buffer->cur;
+    recv_buffer->cur = ((char *)recv_buffer->cur) + vallen;
+    i++;
+
+    g_hash_table_insert(initme->mappings, key, value);
+  }
+  g_hash_table_thaw(initme->mappings);
+}
+
+void
+ORBit_Context_server_free(CORBA_Context ctx)
+{
+  g_hash_table_destroy(ctx->mappings);
+}
diff -urN linux-2.4.1/net/korbit/orb/corba_context.h linux-2.4.1-korbit/net/korbit/orb/corba_context.h
--- linux-2.4.1/net/korbit/orb/corba_context.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_context.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,65 @@
+#ifndef CORBA_CONTEXT_H
+#define CORBA_CONTEXT_H 1
+
+#include "orbit_object_type.h"
+#include "orbit_object.h"
+
+typedef struct {
+  CORBA_unsigned_long len;
+  const CORBA_char *str;
+} ORBit_ContextMarshalItem;
+
+typedef struct CORBA_Context_type *CORBA_Context;
+
+struct CORBA_Context_type {
+  struct ORBit_PseudoObject_struct parent;
+  GHashTable *mappings;
+  GSList *children;
+
+  char *the_name;
+
+  CORBA_Context parent_ctx;
+};
+
+
+extern CORBA_Status CORBA_Context_set_one_value(
+	CORBA_Context ctx,
+	CORBA_Identifier prop_name,
+	char *value,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Context_set_values(
+	CORBA_Context ctx,
+	CORBA_NVList *values,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Context_get_values(
+	CORBA_Context ctx,
+	CORBA_Identifier start_scope,
+	CORBA_Flags op_flags,
+	CORBA_Identifier prop_name,
+	CORBA_NVList **values,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Context_delete_values(
+	CORBA_Context ctx,
+	CORBA_Identifier prop_name,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Context_create_child(
+	CORBA_Context ctx,
+	CORBA_Identifier ctx_name,
+	CORBA_Context *child_ctx,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Context_delete(
+	CORBA_Context ctx,
+	CORBA_Flags del_flags,
+	CORBA_Environment *ev);
+
+void ORBit_Context_marshal(CORBA_Context ctx, const ORBit_ContextMarshalItem *mlist,
+			   CORBA_unsigned_long nitems, GIOPSendBuffer *buf);
+void ORBit_Context_demarshal(CORBA_Context parent, CORBA_Context initme, GIOPRecvBuffer *recv_buffer);
+void ORBit_Context_server_free(CORBA_Context ctx);
+
+#endif
diff -urN linux-2.4.1/net/korbit/orb/corba_env.h linux-2.4.1-korbit/net/korbit/orb/corba_env.h
--- linux-2.4.1/net/korbit/orb/corba_env.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_env.h	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,79 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_ENV_H_
+#define _ORBIT_CORBA_ENV_H_
+
+typedef struct CORBA_Environment_type CORBA_Environment;
+
+/* 3.15 */
+typedef enum {
+	CORBA_COMPLETED_YES=0,
+	CORBA_COMPLETED_NO,
+	CORBA_COMPLETED_MAYBE
+} CORBA_completion_status;
+
+typedef enum {
+	CORBA_NO_EXCEPTION=0,
+	CORBA_USER_EXCEPTION,
+	CORBA_SYSTEM_EXCEPTION
+} CORBA_exception_type;
+
+
+#define ex_CORBA_UNKNOWN 1
+#define ex_CORBA_BAD_PARAM 2
+#define ex_CORBA_NO_MEMORY 3
+#define ex_CORBA_IMP_LIMIT 4
+#define ex_CORBA_COMM_FAILURE 5
+#define ex_CORBA_INV_OBJREF 6
+#define ex_CORBA_NO_PERMISSION 7
+#define ex_CORBA_INTERNAL 8
+#define ex_CORBA_MARSHAL 9
+#define ex_CORBA_INITIALIZE 10
+#define ex_CORBA_NO_IMPLEMENT 11
+#define ex_CORBA_BAD_TYPECODE 12
+#define ex_CORBA_BAD_OPERATION 13
+#define ex_CORBA_NO_RESOURCES 14
+#define ex_CORBA_NO_RESPONSE 15
+#define ex_CORBA_PERSIST_STORE 16
+#define ex_CORBA_BAD_INV_ORDER 17
+#define ex_CORBA_TRANSIENT 18
+#define ex_CORBA_FREE_MEM 19
+#define ex_CORBA_INV_IDENT 20
+#define ex_CORBA_INV_FLAG 21
+#define ex_CORBA_INTF_REPOS 22
+#define ex_CORBA_BAD_CONTEXT 23
+#define ex_CORBA_OBJ_ADAPTER 24
+#define ex_CORBA_DATA_CONVERSION 25
+#define ex_CORBA_OBJECT_NOT_EXIST 26
+#define ex_CORBA_TRANSACTION_REQUIRED 27
+#define ex_CORBA_TRANSACTION_ROLLEDBACK 28
+#define ex_CORBA_INVALID_TRANSACTION 29
+
+
+#endif /* !_ORBIT_CORBA_ENV_H_ */
+
+
+
diff -urN linux-2.4.1/net/korbit/orb/corba_env_type.h linux-2.4.1-korbit/net/korbit/orb/corba_env_type.h
--- linux-2.4.1/net/korbit/orb/corba_env_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_env_type.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,79 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_ENV_TYPE_H_
+#define _ORBIT_CORBA_ENV_TYPE_H_
+
+#include "corba_env.h"
+#include "corba_any.h"
+
+typedef struct CORBA_system_exception {
+	CORBA_unsigned_long minor;
+	CORBA_completion_status completed;
+} CORBA_SystemException;
+
+#define SYSEXC(name)	typedef CORBA_SystemException name;
+
+SYSEXC(CORBA_UNKNOWN)
+SYSEXC(CORBA_BAD_PARAM)
+SYSEXC(CORBA_NO_MEMORY)
+SYSEXC(CORBA_IMP_LIMIT)
+SYSEXC(CORBA_COMM_FAILURE)
+SYSEXC(CORBA_INV_OBJREF)
+SYSEXC(CORBA_NO_PERMISSION)
+SYSEXC(CORBA_INTERNAL)
+SYSEXC(CORBA_MARSHAL)
+SYSEXC(CORBA_INITIALIZE)
+SYSEXC(CORBA_NO_IMPLEMENT)
+SYSEXC(CORBA_BAD_TYPECODE)
+SYSEXC(CORBA_BAD_OPERATION)
+SYSEXC(CORBA_NO_RESOURCES)
+SYSEXC(CORBA_NO_RESPONSE)
+SYSEXC(CORBA_PERSIST_STORE)
+SYSEXC(CORBA_BAD_INV_ORDER)
+SYSEXC(CORBA_TRANSIENT)
+SYSEXC(CORBA_FREE_MEM)
+SYSEXC(CORBA_INV_IDENT)
+SYSEXC(CORBA_INV_FLAG)
+SYSEXC(CORBA_INTF_REPOS)
+SYSEXC(CORBA_BAD_CONTEXT)
+SYSEXC(CORBA_OBJ_ADAPTER)
+SYSEXC(CORBA_DATA_CONVERSION)
+SYSEXC(CORBA_OBJECT_NOT_EXIST)
+SYSEXC(CORBA_TRANSACTION_REQUIRED)
+SYSEXC(CORBA_TRANSACTION_ROLLEDBACK)
+SYSEXC(CORBA_INVALID_TRANSACTION)
+
+
+/* 19.22 */
+struct CORBA_Environment_type {
+	CORBA_exception_type _major;
+	CORBA_char *_repo_id;
+	void *_params;
+	CORBA_any *_any;
+};
+
+
+#endif /* !_ORBIT_CORBA_ENV_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_object.c linux-2.4.1-korbit/net/korbit/orb/corba_object.c
--- linux-2.4.1/net/korbit/orb/corba_object.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_object.c	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,467 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *          Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+#include "config.h"
+#include <IIOP/IIOP.h>
+#include "orbit_types.h"
+#include "corba_object.h"
+#include "corba_object_type.h"
+#include "env.h"
+#include "orb.h"
+#ifdef __KORBIT__
+#include "orbit.h"
+#else /* !__KORBIT__ */
+#include "interface_repository.h"
+#endif /* !__KORBIT__ */
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <alloca.h>
+
+#ifndef __KERNEL__
+#define freeca(ptr)
+#endif
+
+#ifndef __KORBIT__
+/* Section 4.2.1 */
+CORBA_InterfaceDef CORBA_Object_get_interface(CORBA_Object obj, CORBA_Environment *ev)
+{
+	CORBA_Repository repo;
+	CORBA_InterfaceDef interface;
+
+	if(obj==CORBA_OBJECT_NIL)
+		return(CORBA_OBJECT_NIL); /* no exception defined in spec */
+
+	repo=CORBA_ORB_resolve_initial_references(obj->orb, "InterfaceRepository", ev);
+	if(repo==CORBA_OBJECT_NIL)
+		return(CORBA_OBJECT_NIL);
+
+	interface=CORBA_Repository_lookup_id(repo, obj->object_id, ev);
+	CORBA_Object_release(repo, ev);
+
+	return(interface);
+}
+#endif /* !__KORBIT__ */
+
+/* Section 4.2.3 */
+CORBA_boolean CORBA_Object_is_nil(CORBA_Object obj, CORBA_Environment *ev)
+{
+	if(obj==CORBA_OBJECT_NIL) {
+		return(CORBA_TRUE);
+	} else {
+		return(CORBA_FALSE);
+	}
+}
+
+/* Section 4.2.2 */
+/* XXXX Big warning: lots of places inside ORBit expect this to
+                     always return 'obj'. Do not change this, upon pain
+		     of death... */
+CORBA_Object CORBA_Object_duplicate(CORBA_Object obj, CORBA_Environment *ev)
+{
+	if(obj == CORBA_OBJECT_NIL)
+		return CORBA_OBJECT_NIL;
+
+	if(ORBIT_ROOT_OBJECT(obj)->refs >= 0)
+		ORBIT_ROOT_OBJECT_REF(obj);
+
+	return(obj);
+}
+
+
+/* Section 4.2.2 */
+void CORBA_Object_release(CORBA_Object obj, CORBA_Environment *ev)
+{
+	if(obj != CORBA_OBJECT_NIL)
+		ORBIT_ROOT_OBJECT_release(obj,ev);
+}
+
+extern GHashTable *ORBit_class_assignments;
+
+void ORBit_impl_CORBA_Object_is_a(gpointer servant,
+				  GIOPRecvBuffer * _ORBIT_recv_buffer,
+				  CORBA_Environment *ev,
+				  gpointer dummy)
+{
+	GIOPSendBuffer *_ORBIT_send_buffer;
+	struct CORBA_Object_struct objdummy; /* XXX badhack to save backwards compat */
+	CORBA_boolean retval;
+	char *repo_id;
+	CORBA_unsigned_long slen;
+	guchar *curptr;
+	ORBit_ObjectKey *objkey;
+	gpointer *tmp_vepv;
+	guint sz;
+	CORBA_unsigned_long clsid;
+	PortableServer_ServantBase *_ORBIT_servant;
+
+	_ORBIT_servant = servant;
+
+	/* XXX security implications */
+	curptr = _ORBIT_recv_buffer->cur;
+	curptr = ALIGN_ADDRESS(curptr, 4);
+	if(giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)))
+		iiop_byteswap((guchar *)&slen, curptr, sizeof(CORBA_unsigned_long));
+	else
+		slen = *((CORBA_unsigned_long *)curptr);
+	curptr += 4;
+	repo_id = curptr;
+
+	repo_id[slen] = '\0';
+
+	objkey = ORBIT_OBJECT_KEY(_ORBIT_servant->_private);
+
+	sz = sizeof(gpointer) * (ORBit_class_assignment_counter + 1);
+	tmp_vepv = alloca(sz);
+	memset(tmp_vepv, '\0', sz);
+
+	objdummy.vepv = tmp_vepv;
+	objkey->class_info->init_local_objref(&objdummy, servant);
+
+	clsid = GPOINTER_TO_UINT(g_hash_table_lookup(ORBit_class_assignments, repo_id));
+	retval = (clsid && tmp_vepv[clsid]);
+
+	_ORBIT_send_buffer = giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->connection, NULL,
+							_ORBIT_recv_buffer->message.u.request.request_id, ev->_major);
+	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer), &retval, sizeof(retval));
+	giop_send_buffer_write(_ORBIT_send_buffer);
+	giop_send_buffer_unuse(_ORBIT_send_buffer);
+	freeca(tmp_vepv);
+}
+
+/* Section 4.2.4 */
+CORBA_boolean CORBA_Object_is_a(CORBA_Object obj, CORBA_char *logical_type_id, CORBA_Environment *ev)
+{
+	if(obj == CORBA_OBJECT_NIL)
+		return CORBA_FALSE;
+
+	if (obj->servant && obj->vepv) {
+		CORBA_unsigned_long clsid;
+
+		clsid = GPOINTER_TO_UINT(g_hash_table_lookup(ORBit_class_assignments, logical_type_id));
+
+		return (clsid && (clsid < obj->vepv_size) && obj->vepv[clsid]);
+	} else if(!strcmp(obj->object_id, logical_type_id)
+		  || !strcmp("IDL:CORBA/Object:1.0", logical_type_id)) {
+		return CORBA_TRUE;
+	} else {
+		/* Cut and paste from orbit-idl output */
+		/* XXX security implications */
+		GIOP_unsigned_long _ORBIT_request_id;
+		register GIOP_unsigned_long _ORBIT_system_exception_minor;
+		register CORBA_completion_status _ORBIT_completion_status;
+		register GIOPSendBuffer *_ORBIT_send_buffer;
+		register GIOPRecvBuffer *_ORBIT_recv_buffer;
+		register GIOPConnection *_cnx;
+
+		_cnx = ORBit_object_get_connection(obj);
+
+	_ORBIT_retry_request:
+		_ORBIT_send_buffer = NULL;
+		_ORBIT_recv_buffer = NULL;
+		_ORBIT_completion_status = CORBA_COMPLETED_NO;
+		/* A unique uint pointer is anything on the stack,
+		   so set this variable to point to its own address on the
+		   stack. :) */
+		_ORBIT_request_id = GPOINTER_TO_UINT(&_ORBIT_request_id);
+		{				/* marshalling */
+			static const struct {
+				CORBA_unsigned_long len;
+				char opname[6];
+			} _ORBIT_operation_name_data = {
+				6, "_is_a"
+			};
+			static const struct iovec _ORBIT_operation_vec =
+			{(gpointer) & _ORBIT_operation_name_data, 10};
+			register CORBA_unsigned_long _ORBIT_tmpvar_0;
+			CORBA_unsigned_long _ORBIT_tmpvar_1;
+
+			_ORBIT_send_buffer =
+				giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id, CORBA_TRUE,
+							     &(obj->active_profile->object_key_vec), &_ORBIT_operation_vec, &ORBit_default_principal_iovec);
+
+			_ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
+			if (!_ORBIT_send_buffer)
+				goto _ORBIT_system_exception;
+			_ORBIT_tmpvar_1 = strlen(logical_type_id) + 1;
+			giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer), 4);
+			giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer), &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
+			giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer), (logical_type_id), sizeof(logical_type_id[_ORBIT_tmpvar_0]) * _ORBIT_tmpvar_1);
+			giop_send_buffer_write(_ORBIT_send_buffer);
+			_ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
+			giop_send_buffer_unuse(_ORBIT_send_buffer);
+			_ORBIT_send_buffer = NULL;
+		}
+		{				/* demarshalling */
+			register guchar *_ORBIT_curptr;
+			CORBA_boolean _ORBIT_retval;
+
+			_ORBIT_recv_buffer = giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
+			if (!_ORBIT_recv_buffer)
+				goto _ORBIT_system_exception;
+			_ORBIT_completion_status = CORBA_COMPLETED_YES;
+			if (_ORBIT_recv_buffer->message.u.reply.reply_status != GIOP_NO_EXCEPTION)
+				goto _ORBIT_msg_exception;
+			if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
+				_ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+				_ORBIT_retval = *((CORBA_boolean *) _ORBIT_curptr);
+			} else {
+				_ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
+				_ORBIT_retval = *((CORBA_boolean *) _ORBIT_curptr);
+			}
+			giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+			return _ORBIT_retval;
+		_ORBIT_system_exception:
+			CORBA_exception_set_system(ev, _ORBIT_system_exception_minor, _ORBIT_completion_status);
+			giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+			giop_send_buffer_unuse(_ORBIT_send_buffer);
+			return _ORBIT_retval;
+		_ORBIT_msg_exception:
+			if (_ORBIT_recv_buffer->message.u.reply.reply_status == GIOP_LOCATION_FORWARD) {
+				if (obj->forward_locations != NULL)
+					ORBit_delete_profiles(obj->forward_locations);
+				obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
+				_cnx = ORBit_object_get_forwarded_connection(obj);
+				giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+
+				goto _ORBIT_retry_request;
+			} else {
+				ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, obj->orb);
+				giop_recv_buffer_unuse(_ORBIT_recv_buffer);
+				return _ORBIT_retval;
+			}
+		}
+
+	}
+}
+
+/* Section 4.2.5 */
+#ifndef __KORBIT__
+static void do_exit(int signum) {
+  _exit(5);
+#warning "This should be removed... use BUG instead..."
+}
+#endif
+
+/* Lovely hack to try and figure out without hanging whether an object exists or not. */
+CORBA_boolean CORBA_Object_non_existent(CORBA_Object obj, CORBA_Environment *ev)
+{
+#ifndef __KORBIT__
+  int childpid, exitstatus, itmp;
+#endif
+
+  ev->_major = CORBA_NO_EXCEPTION;
+
+  if(obj == CORBA_OBJECT_NIL)
+	  return TRUE;
+
+  if(obj->servant)
+	  return FALSE;
+
+  if(obj->connection && obj->connection->is_valid)
+	  return FALSE;
+
+#ifndef __KORBIT__
+  childpid = fork();
+
+  if(!childpid) {
+	  GIOPConnection* cnx = NULL;
+	  struct sigaction sa;
+
+	  memset(&sa, 0, sizeof(sa));
+	  sa.sa_handler = do_exit;
+	  sigaction(SIGALRM, &sa, NULL);
+	  alarm(2);
+	  cnx = _ORBit_object_get_connection(obj);
+
+	  /* XXX todo - try invoking a strange operation on the object, and see what type of exception we get. */ 
+
+	  _exit((cnx == NULL)?1:0);
+  }
+
+  itmp = waitpid(childpid, &exitstatus, 0);
+
+  if(itmp < 0) return TRUE;
+  return WEXITSTATUS(exitstatus) && TRUE;
+#else /* __KORBIT__ */
+  return FALSE;
+#endif /* __KORBIT__ */
+}
+
+gboolean
+g_CORBA_Object_equal(CORBA_Object obj1, CORBA_Object obj2)
+{
+	gboolean retval;
+	CORBA_Environment ev;
+
+	CORBA_exception_init(&ev);
+
+	retval = (gboolean)CORBA_Object_is_equivalent(obj1, obj2, &ev);
+
+	CORBA_exception_free(&ev);
+
+	return retval;
+}
+
+/* Section 4.2.6 */
+CORBA_boolean CORBA_Object_is_equivalent(CORBA_Object obj, CORBA_Object other_object, CORBA_Environment *ev)
+{
+	ORBit_Object_info *obj_profile, *other_object_profile;
+	int i,j, obj_profile_count, other_object_profile_count;
+
+	if(obj == CORBA_OBJECT_NIL
+	   && other_object == CORBA_OBJECT_NIL)
+		return CORBA_TRUE;
+
+	if(obj == CORBA_OBJECT_NIL
+	   || other_object == CORBA_OBJECT_NIL)
+		goto ret_false;
+
+	/*
+	 * If one profile in "obj" matches one in "other_object", then these
+	 * objects are equivalent.
+	 *
+	 * This is O(n*m) at worst case :-( Hopefully though most objects will
+	 * only have 1 or 2 profiles.
+	 *
+	 * The profile list could be indexed as a hash table (the linked list
+	 * is still needed, as the profile order is significant)
+	 */
+
+	obj_profile_count = g_slist_length(obj->profile_list);
+	other_object_profile_count = g_slist_length(other_object->profile_list);
+
+	for(i=0;i<obj_profile_count;i++) {
+		obj_profile=(ORBit_Object_info *)g_slist_nth_data(obj->profile_list, i);
+
+		for(j=0;j<other_object_profile_count;j++) {
+			other_object_profile=(ORBit_Object_info *)g_slist_nth_data(other_object->profile_list, j);
+
+			if(obj_profile->profile_type != other_object_profile->profile_type)
+				continue;
+			
+			if(obj_profile->object_key._length != other_object_profile->object_key._length)
+				continue;
+
+			if(memcmp(obj_profile->object_key._buffer, other_object_profile->object_key._buffer, obj_profile->object_key._length))
+				continue;
+
+			if(obj_profile->profile_type == IOP_TAG_INTERNET_IOP) {
+				TAG_INTERNET_IOP_info *ii1, *ii2;
+
+				ii1 = &obj_profile->tag.iopinfo;
+				ii2 = &other_object_profile->tag.iopinfo;
+
+				if(ii1->port != ii2->port)
+					continue;
+				if(strcmp(ii1->host, ii2->host))
+					continue;
+
+				return(CORBA_TRUE);
+			} else if(obj_profile->profile_type == IOP_TAG_ORBIT_SPECIFIC) {
+				TAG_ORBIT_SPECIFIC_info *oi1, *oi2;
+
+				oi1 = &obj_profile->tag.orbitinfo;
+				oi2 = &other_object_profile->tag.orbitinfo;
+
+				if(strcmp(oi1->unix_sock_path, oi2->unix_sock_path))
+					continue;
+				if(oi1->ipv6_port != oi2->ipv6_port)
+					continue;
+
+				return(CORBA_TRUE);
+			}
+		}
+	}
+
+ ret_false:
+	return CORBA_FALSE;
+}
+
+guint
+g_CORBA_Object_hash(CORBA_Object obj)
+{
+	guint retval;
+	CORBA_Environment ev;
+
+	CORBA_exception_init(&ev);
+
+	retval = (guint)CORBA_Object_hash(obj, UINT_MAX, &ev);
+
+	CORBA_exception_free(&ev);
+
+	return retval;
+}
+
+static void profile_hash(gpointer item, gpointer data)
+{
+	ORBit_Object_info *info = (ORBit_Object_info *)item;
+	CORBA_unsigned_long *retval = (CORBA_unsigned_long *)data;
+
+	g_assert(info);
+	g_assert(retval);
+
+	*retval ^= info->object_key._length;
+
+	if(info->profile_type == IOP_TAG_INTERNET_IOP) {
+		*retval ^= !info->tag.iopinfo.port;
+	} else if(info->profile_type == IOP_TAG_ORBIT_SPECIFIC) {
+		*retval ^= g_str_hash(info->tag.orbitinfo.unix_sock_path);
+		*retval ^= !info->tag.orbitinfo.ipv6_port;
+	}
+}
+
+/* Section 4.2.6 */
+CORBA_unsigned_long CORBA_Object_hash(CORBA_Object obj,
+				      CORBA_unsigned_long maximum,
+				      CORBA_Environment *ev)
+{
+	CORBA_unsigned_long retval = 0;
+	char *tptr;
+
+	g_assert(obj);
+
+	tptr = obj->object_id;
+	while(*tptr) {
+		retval = (retval << 8) ^ *tptr;
+		tptr++;
+	}
+
+	if(g_slist_length(obj->profile_list)>0) {
+		g_slist_foreach(obj->profile_list, profile_hash, &retval);
+	} else {
+		g_warning("Object of type %s doesn't seem to have any connection info!", obj->object_id);
+	}
+
+	return (retval % maximum);
+}
+
+/* Section 4.2.7 */
+CORBA_Policy CORBA_Object_get_policy(CORBA_Object obj, CORBA_PolicyType policy_type, CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
diff -urN linux-2.4.1/net/korbit/orb/corba_object.h linux-2.4.1-korbit/net/korbit/orb/corba_object.h
--- linux-2.4.1/net/korbit/orb/corba_object.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_object.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,59 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_OBJECT_H_
+#define _ORBIT_CORBA_OBJECT_H_
+
+#include <ORBitutil/basic_types.h>
+
+#include "corba_env.h"
+#include "corba_orb.h"
+#include "corba_sequences.h"
+
+#define CORBA_OBJECT_NIL NULL
+
+typedef struct CORBA_Object_struct *CORBA_Object;
+
+#define CORBA_OBJECT(x) ((CORBA_Object)(x))
+
+/* Used for internal stuff mostly, but also good if you want to store
+   a hash of objects */
+gboolean g_CORBA_Object_equal(CORBA_Object obj1, CORBA_Object obj2);
+guint g_CORBA_Object_hash(CORBA_Object obj);
+
+void ORBit_impl_CORBA_Object_is_a(gpointer servant,
+				  GIOPRecvBuffer * _ORBIT_recv_buffer,
+				  CORBA_Environment *ev, gpointer dummy);
+#define ORBIT_IMPLEMENTS_IS_A
+
+extern CORBA_boolean CORBA_Object_is_a(
+	CORBA_Object obj,
+	CORBA_char *logical_type_id,
+	CORBA_Environment *ev);
+
+#endif /* !_ORBIT_CORBA_OBJECT_H_ */
+
+
+
diff -urN linux-2.4.1/net/korbit/orb/corba_object_type.h linux-2.4.1-korbit/net/korbit/orb/corba_object_type.h
--- linux-2.4.1/net/korbit/orb/corba_object_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_object_type.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,54 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_OBJECT_TYPE_H_
+#define _ORBIT_CORBA_OBJECT_TYPE_H_
+
+#include <sys/uio.h> /* for struct iovec */
+
+#include <IIOP/IIOP.h>	  /* for giop_connection */
+
+#include "corba_object.h"
+#include "corba_basic_sequences_type.h"
+
+#include "orbit_object_type.h"
+
+struct CORBA_Object_struct {
+	struct ORBit_RootObject_struct parent;
+	CORBA_ORB orb;
+	GIOPConnection *connection;
+	CORBA_char *object_id;
+	GSList *profile_list;
+	GSList *forward_locations;
+	ORBit_Object_info *active_profile;	/* points at a member of profile_list or forward_locations */
+
+	/* Used for direct calls */
+	gpointer *vepv;
+	/* PortableServer_Servant - looping includes :( */ gpointer servant;
+	guint vepv_size;
+};
+
+
+#endif /* !_ORBIT_CORBA_OBJECT_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_orb.h linux-2.4.1-korbit/net/korbit/orb/corba_orb.h
--- linux-2.4.1/net/korbit/orb/corba_orb.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_orb.h	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,48 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_ORB_H_
+#define _ORBIT_CORBA_ORB_H_
+
+typedef char *CORBA_ORB_ObjectId;
+
+#ifndef CORBA_POLICY_TYPE
+#define CORBA_POLICY_TYPE 1
+/* We need to define this in corba_orb_type.h as well, sometimes... */
+typedef struct CORBA_Policy_type *CORBA_Policy;
+#endif
+
+typedef CORBA_unsigned_long CORBA_PolicyType;
+
+typedef struct CORBA_ORB_type *CORBA_ORB;
+
+typedef struct CORBA_DomainManager_type *CORBA_DomainManager;
+
+typedef struct CORBA_ConstructionPolicy_type *CORBA_ConstructionPolicy;
+
+#define ex_CORBA_ORB_InvalidName "IDL:CORBA/ORB/InvalidName:1.0"
+
+#endif /* !_ORBIT_CORBA_ORB_H_ */
+
diff -urN linux-2.4.1/net/korbit/orb/corba_orb_type.h linux-2.4.1-korbit/net/korbit/orb/corba_orb_type.h
--- linux-2.4.1/net/korbit/orb/corba_orb_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_orb_type.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,77 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_ORB_TYPE_H_
+#define _ORBIT_CORBA_ORB_TYPE_H_
+
+#include "corba_object.h"
+
+struct CORBA_ORB_type {
+	struct ORBit_PseudoObject_struct parent;
+	CORBA_ORBid orb_identifier;
+	CORBA_RepositoryId repoid;
+	CORBA_boolean use_poa;
+
+	CORBA_Object imr, ir, naming, root_poa;
+	struct {
+		GIOPConnection *ipv4;
+		GIOPConnection *ipv6;
+		GIOPConnection *usock;
+	} cnx;
+
+	GHashTable *objrefs;
+
+	GPtrArray *poas;
+
+	CORBA_Context default_ctx;
+};
+
+#define CORBA_ORB_CAST(orb) ((CORBA_ORB)orb)
+
+typedef struct CORBA_ORB_InvalidName {
+	int dummy;
+} CORBA_ORB_InvalidName;
+
+struct CORBA_Policy_type {
+	struct ORBit_PseudoObject_struct parent;
+	CORBA_PolicyType policy_type;
+};
+#ifndef CORBA_POLICY_TYPE
+#define CORBA_POLICY_TYPE 1
+typedef struct CORBA_Policy_type *CORBA_Policy;
+#endif
+
+struct CORBA_DomainManager_type {
+	struct ORBit_PseudoObject_struct parent;
+};
+
+#define CORBA_SecConstruction (11)
+
+struct CORBA_ConstructionPolicy_type {
+	int fill_me_in;
+};
+
+
+#endif /* !_ORBIT_CORBA_ORB_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_portableserver.h linux-2.4.1-korbit/net/korbit/orb/corba_portableserver.h
--- linux-2.4.1/net/korbit/orb/corba_portableserver.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_portableserver.h	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,80 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_PORTABLESERVER_H_
+#define _ORBIT_CORBA_PORTABLESERVER_H_
+
+typedef struct PortableServer_ThreadPolicy_type *PortableServer_ThreadPolicy;
+typedef struct PortableServer_LifespanPolicy_type *PortableServer_LifespanPolicy;
+typedef struct PortableServer_IdUniquenessPolicy_type *PortableServer_IdUniquenessPolicy;
+typedef struct PortableServer_IdAssignmentPolicy_type *PortableServer_IdAssignmentPolicy;
+typedef struct PortableServer_ImplicitActivationPolicy_type *PortableServer_ImplicitActivationPolicy;
+typedef struct PortableServer_ServantRetentionPolicy_type *PortableServer_ServantRetentionPolicy;
+typedef struct PortableServer_RequestProcessingPolicy_type *PortableServer_RequestProcessingPolicy;
+typedef struct PortableServer_POAManager_type* PortableServer_POAManager;
+typedef struct PortableServer_AdapterActivator_type *PortableServer_AdapterActivator;
+typedef struct PortableServer_ServantManager_type *PortableServer_ServantManager;
+typedef struct PortableServer_ServantActivator_type *PortableServer_ServantActivator;
+typedef struct PortableServer_ServantLocator_type *PortableServer_ServantLocator;
+typedef struct PortableServer_POA_type *PortableServer_POA;
+typedef struct PortableServer_Current_type *PortableServer_Current;
+
+typedef enum {
+	PortableServer_ORB_CTRL_MODEL=0,
+	PortableServer_SINGLE_THREAD_MODEL
+} PortableServer_ThreadPolicyValue;
+
+typedef enum {
+	PortableServer_TRANSIENT=0,
+	PortableServer_PERSISTENT
+} PortableServer_LifespanPolicyValue;
+
+typedef enum {
+	PortableServer_UNIQUE_ID=0,
+	PortableServer_MULTIPLE_ID
+} PortableServer_IdUniquenessPolicyValue;
+
+typedef enum {
+	PortableServer_USER_ID=0,
+	PortableServer_SYSTEM_ID
+} PortableServer_IdAssignmentPolicyValue;
+
+typedef enum {
+	PortableServer_IMPLICIT_ACTIVATION=0,
+	PortableServer_NO_IMPLICIT_ACTIVATION
+} PortableServer_ImplicitActivationPolicyValue;
+
+typedef enum {
+	PortableServer_RETAIN=0,
+	PortableServer_NON_RETAIN
+} PortableServer_ServantRetentionPolicyValue;
+
+typedef enum {
+	PortableServer_USE_ACTIVE_OBJECT_MAP_ONLY=0,
+	PortableServer_USE_DEFAULT_SERVANT,
+	PortableServer_USE_SERVANT_MANAGER
+} PortableServer_RequestProcessingPolicyValue;
+
+#endif /* !_ORBIT_CORBA_PORTABLESERVER_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_portableserver_type.h linux-2.4.1-korbit/net/korbit/orb/corba_portableserver_type.h
--- linux-2.4.1/net/korbit/orb/corba_portableserver_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_portableserver_type.h	Thu Feb  1 11:47:11 2001
@@ -0,0 +1,361 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_PORTABLESERVER_TYPE_H_
+#define _ORBIT_CORBA_PORTABLESERVER_TYPE_H_
+
+/* 19.26 */
+
+typedef void *PortableServer_ServantLocator_Cookie;
+typedef void *PortableServer_Servant;
+
+#ifndef _PortableServer_ForwardRequest_defined
+#define _PortableServer_ForwardRequest_defined
+
+typedef struct PortableServer_ForwardRequest {
+   CORBA_Object forward_reference;
+} PortableServer_ForwardRequest;
+
+#define ex_PortableServer_ForwardRequest "IDL:PortableServer/ForwardRequest:1.0"
+#endif /* !_PortableServer_ForwardRequest_defined */
+
+#define PortableServer_THREAD_POLICY_ID 16
+struct PortableServer_ThreadPolicy_type {
+	struct CORBA_Policy_type corba_policy;
+	PortableServer_ThreadPolicyValue value;
+};
+
+#define PortableServer_LIFESPAN_POLICY_ID 17
+extern const CORBA_PolicyType PortableServer_LifespanPolicy_PolicyType;
+struct PortableServer_LifespanPolicy_type {
+	struct CORBA_Policy_type corba_policy;
+	PortableServer_LifespanPolicyValue value;
+};
+
+#define PortableServer_ID_UNIQUENESS_POLICY_ID 18
+struct PortableServer_IdUniquenessPolicy_type {
+	struct CORBA_Policy_type corba_policy;
+	PortableServer_IdUniquenessPolicyValue value;
+};
+
+#define PortableServer_ID_ASSIGNMENT_POLICY_ID 19
+struct PortableServer_IdAssignmentPolicy_type {
+	struct CORBA_Policy_type corba_policy;
+	PortableServer_IdAssignmentPolicyValue value;
+};
+
+#define PortableServer_IMPLICIT_ACTIVATION_POLICY_ID 20
+struct PortableServer_ImplicitActivationPolicy_type {
+	struct CORBA_Policy_type corba_policy;
+	PortableServer_ImplicitActivationPolicyValue value;
+};
+
+#define PortableServer_SERVANT_RETENTION_POLICY_ID 21
+struct PortableServer_ServantRetentionPolicy_type {
+	struct CORBA_Policy_type corba_policy;
+	PortableServer_ServantRetentionPolicyValue value;
+};
+
+#define PortableServer_REQUEST_PROCESSING_POLICY_ID 22
+struct PortableServer_RequestProcessingPolicy_type {
+	struct CORBA_Policy_type corba_policy;
+	PortableServer_RequestProcessingPolicyValue value;
+};
+
+#ifndef _PortableServer_POAManager_AdapterInactive_defined
+#define _PortableServer_POAManager_AdapterInactive_defined
+
+typedef struct PortableServer_POAManager_AdapterInactive {
+	int fill_me_in;
+} PortableServer_POAManager_AdapterInactive;
+
+#define ex_PortableServer_POAManager_AdapterInactive "IDL:PortableServer/POAManager/AdapterInactive:1.0"
+#endif /* !_PortableServer_POAManager_AdapterInactive_defined */
+
+typedef enum { PortableServer_POAManager_HOLDING,
+	       PortableServer_POAManager_ACTIVE,
+	       PortableServer_POAManager_DISCARDING,
+	       PortableServer_POAManager_INACTIVE
+} PortableServer_POAManager_State;
+
+struct PortableServer_POAManager_type {
+	struct ORBit_PseudoObject_struct parent;
+	GSList* poa_collection;
+	CORBA_ORB orb;
+	PortableServer_POAManager_State state;
+};
+
+struct PortableServer_AdapterActivator_type {
+	int fill_me_in;
+};
+
+struct PortableServer_ServantManager_type {
+	int fill_me_in;
+};
+
+#ifndef _PortableServer_POA_AdapterAlreadyExists_defined
+#define _PortableServer_POA_AdapterAlreadyExists_defined
+
+typedef struct PortableServer_POA_AdapterAlreadyExists {
+	int fill_me_in;
+} PortableServer_POA_AdapterAlreadyExists;
+
+#define ex_PortableServer_POA_AdapterAlreadyExists "IDL:PortableServer/POA/AdapterAlreadyExists:1.0"
+#endif /* !_PortableServer_POA_AdapterAlreadyExists_defined */
+
+#ifndef _PortableServer_POAManager_AdapterInactive_defined
+#define _PortableServer_POAManager_AdapterInactive_defined
+
+typedef struct PortableServer_POAManager_AdapterInactive {
+	int fill_me_in;
+} PortableServer_POAManager_AdapterInactive;
+
+#define ex_PortableServer_POAManager_AdapterInactive "IDL:PortableServer/POAManager/AdapterInactive:1.0"
+#endif /* !_PortableServer_POAManager_AdapterInactive_defined */
+
+#ifndef _PortableServer_POA_AdapterNonExistent_defined
+#define _PortableServer_POA_AdapterNonExistent_defined
+
+typedef struct PortableServer_POA_AdapterNonExistent {
+	int fill_me_in;
+} PortableServer_POA_AdapterNonExistent;
+
+#define ex_PortableServer_POA_AdapterNonExistent "IDL:PortableServer/POA/AdapterNonExistent:1.0"
+#endif /* !_PortableServer_POA_AdapterNonExistent_defined */
+
+#ifndef _PortableServer_POA_InvalidPolicy_defined
+#define _PortableServer_POA_InvalidPolicy_defined
+
+typedef struct PortableServer_POA_InvalidPolicy {
+   CORBA_unsigned_short index;
+} PortableServer_POA_InvalidPolicy;
+
+#define ex_PortableServer_POA_InvalidPolicy "IDL:PortableServer/POA/InvalidPolicy:1.0"
+#endif /* !_PortableServer_POA_InvalidPolicy_defined */
+
+#ifndef _PortableServer_POA_NoServant_defined
+#define _PortableServer_POA_NoServant_defined
+
+typedef struct PortableServer_POA_NoServant {
+	int fill_me_in;
+} PortableServer_POA_NoServant;
+
+#define ex_PortableServer_POA_NoServant "IDL:PortableServer/POA/NoServant:1.0"
+#endif /* !_PortableServer_POA_NoServant_defined */
+
+#ifndef _PortableServer_POA_ObjectAlreadyActive_defined
+#define _PortableServer_POA_ObjectAlreadyActive_defined
+
+typedef struct PortableServer_POA_ObjectAlreadyActive {
+	int fill_me_in;
+} PortableServer_POA_ObjectAlreadyActive;
+
+#define ex_PortableServer_POA_ObjectAlreadyActive "IDL:PortableServer/POA/ObjectAlreadyActive:1.0"
+#endif /* !_PortableServer_POA_ObjectAlreadyActive_defined */
+
+#ifndef _PortableServer_POA_ObjectNotActive_defined
+#define _PortableServer_POA_ObjectNotActive_defined
+
+typedef struct PortableServer_POA_ObjectNotActive {
+	int fill_me_in;
+} PortableServer_POA_ObjectNotActive;
+
+#define ex_PortableServer_POA_ObjectNotActive "IDL:PortableServer/POA/ObjectNotActive:1.0"
+#endif /* !_PortableServer_POA_ObjectNotActive_defined */
+
+#ifndef _PortableServer_POA_ServantAlreadyActive_defined
+#define _PortableServer_POA_ServantAlreadyActive_defined
+
+typedef struct PortableServer_POA_ServantAlreadyActive {
+	int fill_me_in;
+} PortableServer_POA_ServantAlreadyActive;
+
+#define ex_PortableServer_POA_ServantAlreadyActive "IDL:PortableServer/POA/ServantAlreadyActive:1.0"
+#endif /* !_PortableServer_POA_ServantAlreadyActive_defined */
+
+#ifndef _PortableServer_POA_ServantNotActive_defined
+#define _PortableServer_POA_ServantNotActive_defined
+
+typedef struct PortableServer_POA_ServantNotActive {
+	int fill_me_in;
+} PortableServer_POA_ServantNotActive;
+
+#define ex_PortableServer_POA_ServantNotActive "IDL:PortableServer/POA/ServantNotActive:1.0"
+#endif /* !_PortableServer_POA_ServantNotActive_defined */
+
+#ifndef _PortableServer_POA_WrongAdapter_defined
+#define _PortableServer_POA_WrongAdapter_defined
+
+typedef struct PortableServer_POA_WrongAdapter {
+	int fill_me_in;
+} PortableServer_POA_WrongAdapter;
+
+#define ex_PortableServer_POA_WrongAdapter "IDL:PortableServer/POA/WrongAdapter:1.0"
+#endif /* !_PortableServer_POA_WrongAdapter_defined */
+
+#ifndef _PortableServer_POA_WrongPolicy_defined
+#define _PortableServer_POA_WrongPolicy_defined
+
+typedef struct PortableServer_POA_WrongPolicy {
+	int fill_me_in;
+} PortableServer_POA_WrongPolicy;
+
+#define ex_PortableServer_POA_WrongPolicy "IDL:PortableServer/POA/WrongPolicy:1.0"
+#endif /* !_PortableServer_POA_WrongPolicy_defined */
+
+#ifndef _PortableServer_Current_NoContext_defined
+#define _PortableServer_Current_NoContext_defined
+
+typedef struct PortableServer_Current_NoContext {
+	int fill_me_in;
+} PortableServer_Current_NoContext;
+
+#define ex_PortableServer_Current_NoContext "IDL:PortableServer/Current/NoContext:1.0"
+#endif /* !_PortableServer_Current_NoContext_defined */
+
+struct PortableServer_Current_type {
+	int fill_me_in;
+};
+
+typedef struct PortableServer_ServantBase__epv {
+	void *_private;
+	void (*finalize)(PortableServer_Servant, CORBA_Environment *);
+	PortableServer_POA (*default_POA)(PortableServer_Servant, CORBA_Environment *);
+} PortableServer_ServantBase__epv;
+
+typedef PortableServer_ServantBase__epv *PortableServer_ServantBase__vepv;
+
+typedef struct PortableServer_ServantBase {
+	void *_private;
+	PortableServer_ServantBase__vepv *vepv;
+} PortableServer_ServantBase;
+
+/* 19.27 */
+
+typedef void (*PortableServer_DynamicImplRoutine) (PortableServer_Servant servant, CORBA_ServerRequest request);
+
+typedef struct PortableServer_DynamicImpl__epv {
+	void *_private;
+	PortableServer_DynamicImplRoutine invoke;
+	CORBA_RepositoryId (*primary_interface) (PortableServer_Servant svt, PortableServer_ObjectId id, PortableServer_POA poa, CORBA_Environment *env);
+} PortableServer_DynamicImpl__epv;
+
+typedef struct PortableServer_DynamicImpl__vepv {
+	PortableServer_ServantBase__epv *_base_epv;
+	PortableServer_DynamicImpl__epv *PortableServer_DynamicImpl_epv;
+} PortableServer_DynamicImpl__vepv;
+
+typedef struct PortableServer_DynamicImpl {
+	void *_private;
+	PortableServer_DynamicImpl__vepv *vepv;
+} PortableServer_DynamicImpl;
+
+typedef struct {
+   void *_private;
+} POA_PortableServer_ServantManager__epv;
+
+typedef struct {
+	void *_private;
+
+	PortableServer_Servant (*incarnate) (PortableServer_Servant servant,
+					     PortableServer_ObjectId * oid,
+					     PortableServer_POA adapter,
+					     CORBA_Environment * ev);
+
+	void (*etherealize) (PortableServer_Servant servant,
+			     PortableServer_ObjectId* oid,
+			     PortableServer_POA adapter,
+			     PortableServer_Servant serv,
+			     CORBA_boolean cleanup_in_progress,
+			     CORBA_boolean remaining_activations,
+			     CORBA_Environment * ev);
+
+} POA_PortableServer_ServantActivator__epv;
+
+typedef struct {
+   PortableServer_ServantBase__epv *_base_epv;
+   POA_PortableServer_ServantManager__epv *PortableServer_ServantManager_epv;
+   POA_PortableServer_ServantActivator__epv *PortableServer_ServantActivator_epv;
+} POA_PortableServer_ServantActivator__vepv;
+
+typedef struct {
+   void *_private;
+   POA_PortableServer_ServantActivator__vepv *vepv;
+} POA_PortableServer_ServantActivator;
+
+extern void
+POA_PortableServer_ServantActivator__init(PortableServer_Servant servant,
+					  CORBA_Environment * ev);
+extern void
+POA_PortableServer_ServantActivator__fini(PortableServer_Servant servant,
+					  CORBA_Environment * ev);
+
+typedef struct {
+	void *_private;
+
+	PortableServer_Servant (*preinvoke) (PortableServer_Servant servant,
+					     PortableServer_ObjectId * oid,
+					     PortableServer_POA adapter,
+					     CORBA_Identifier operation,
+					     PortableServer_ServantLocator_Cookie *the_cookie,
+					     CORBA_Environment * ev);
+
+	void (*postinvoke) (PortableServer_Servant servant,
+			    PortableServer_ObjectId * oid,
+			    PortableServer_POA adapter,
+			    CORBA_Identifier operation,
+			    PortableServer_ServantLocator_Cookie the_cookie,
+			    PortableServer_Servant the_servant,
+			    CORBA_Environment * ev);
+} POA_PortableServer_ServantLocator__epv;
+
+typedef struct {
+   PortableServer_ServantBase__epv *_base_epv;
+   POA_PortableServer_ServantManager__epv *PortableServer_ServantManager_epv;
+   POA_PortableServer_ServantLocator__epv *PortableServer_ServantLocator_epv;
+} POA_PortableServer_ServantLocator__vepv;
+
+typedef struct {
+   void *_private;
+   POA_PortableServer_ServantLocator__vepv *vepv;
+} POA_PortableServer_ServantLocator;
+
+extern void
+POA_PortableServer_ServantLocator__init(PortableServer_Servant servant,
+					CORBA_Environment * ev);
+extern void
+POA_PortableServer_ServantLocator__fini(PortableServer_Servant servant,
+					CORBA_Environment * ev);
+
+struct CORBA_ServerRequest_type {
+	struct ORBit_PseudoObject_struct parent;
+	GIOPRecvBuffer *rbuf;
+	GIOPSendBuffer *sbuf;
+	CORBA_NVList *params;
+	CORBA_ORB orb;
+	guchar did_ctx, did_exc;
+};
+
+#endif /* !_ORBIT_CORBA_PORTABLESERVER_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_sequences.h linux-2.4.1-korbit/net/korbit/orb/corba_sequences.h
--- linux-2.4.1/net/korbit/orb/corba_sequences.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_sequences.h	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,74 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_SEQUENCES_H_
+#define _ORBIT_CORBA_SEQUENCES_H_
+
+
+/* moved from sequences.h */
+#include "corba_basic_sequences_type.h"
+
+typedef CORBA_sequence_octet CORBA_ReferenceData;
+
+#define _CORBA_sequence_ServiceOption_defined
+typedef struct CORBA_sequence_ServiceOption CORBA_sequence_ServiceOption;
+
+#define _CORBA_sequence_ServiceDetail_defined
+typedef struct CORBA_sequence_ServiceDetail CORBA_sequence_ServiceDetail;
+
+#define _CORBA_sequence_ORB_ObjectId_defined
+typedef struct CORBA_sequence_ORB_ObjectId CORBA_ORB_ObjectIdList;
+
+#define _CORBA_sequence_NameValuePair_defined
+typedef struct CORBA_sequence_NameValuePair CORBA_NameValuePairSeq;
+
+#define _CORBA_sequence_CORBA_any_defined
+typedef struct CORBA_sequence_CORBA_any_struct CORBA_AnySeq;
+typedef struct CORBA_sequence_CORBA_any_struct CORBA_sequence_CORBA_any;
+
+#define _CORBA_sequence_Policy_defined
+typedef struct CORBA_sequence_Policy CORBA_PolicyList;
+
+#define _CORBA_sequence_DomainManager_defined
+typedef struct CORBA_sequence_DomainManager CORBA_DomainManagerList;
+
+#define _PortableServer_sequence_octet_defined
+typedef struct PortableServer_sequence_octet PortableServer_ObjectId;
+
+
+/* Moved from orbit_types.h */
+#ifndef HAVE_CORBA_PRINCIPAL
+#define HAVE_CORBA_PRINCIPAL 1
+typedef CORBA_sequence_octet CORBA_Principal;
+#endif
+typedef CORBA_sequence_octet CORBA_DynAny_OctetSeq;
+typedef CORBA_sequence_octet CORBA_DynFixed_OctetSeq;
+typedef CORBA_sequence_octet CORBA_DynEnum_OctetSeq;
+typedef CORBA_sequence_octet CORBA_DynStruct_OctetSeq;
+typedef CORBA_sequence_octet CORBA_DynUnion_OctetSeq;
+typedef CORBA_sequence_octet CORBA_DynSequence_OctetSeq;
+typedef CORBA_sequence_octet CORBA_DynArray_OctetSeq;
+
+#endif /* !_ORBIT_CORBA_SEQUENCES_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_sequences_type.h linux-2.4.1-korbit/net/korbit/orb/corba_sequences_type.h
--- linux-2.4.1/net/korbit/orb/corba_sequences_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_sequences_type.h	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,98 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_SEQUENCES_TYPE_H_
+#define _ORBIT_CORBA_SEQUENCES_TYPE_H_
+
+#include "corba_sequences.h"
+
+struct CORBA_sequence_ServiceOption {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_ServiceOption *_buffer;
+	CORBA_boolean _release;
+};
+
+struct CORBA_sequence_ServiceDetail {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_ServiceDetail *_buffer;
+	CORBA_boolean _release;
+};
+
+struct CORBA_sequence_ORB_ObjectId {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_ORB_ObjectId *_buffer;  
+	CORBA_boolean _release;
+};
+
+struct CORBA_sequence_NameValuePair {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	struct CORBA_NameValuePair *_buffer;
+	CORBA_boolean _release;
+};
+
+struct CORBA_sequence_CORBA_any_struct {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_any *_buffer;
+	CORBA_boolean _release;
+};
+
+struct CORBA_sequence_Policy {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_Policy *_buffer;
+	CORBA_boolean _release;
+};
+
+struct CORBA_sequence_DomainManager {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_DomainManager *_buffer;
+	CORBA_boolean _release;
+};
+
+struct PortableServer_sequence_octet {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CORBA_octet *_buffer;
+	CORBA_boolean _release;
+};
+
+/* Generic sequence */
+struct CORBA_Sequence_type {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	void *_buffer;
+	CORBA_boolean _release;
+};
+
+#define CORBA_SEQFLAGS_RELEASE 1
+
+
+#endif /* !_ORBIT_CORBA_SEQUENCES_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/corba_typecode.h linux-2.4.1-korbit/net/korbit/orb/corba_typecode.h
--- linux-2.4.1/net/korbit/orb/corba_typecode.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_typecode.h	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,167 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_TYPECODE_H_
+#define _ORBIT_CORBA_TYPECODE_H_
+
+/* moved from orbit_types.h */
+typedef struct CORBA_TypeCode_struct *CORBA_TypeCode;
+
+typedef enum {
+	CORBA_tk_null=0,
+	CORBA_tk_void=1,
+	CORBA_tk_short=2,
+	CORBA_tk_long=3,
+	CORBA_tk_ushort=4,
+	CORBA_tk_ulong=5,
+	CORBA_tk_float=6,
+	CORBA_tk_double=7,
+	CORBA_tk_boolean=8,
+	CORBA_tk_char=9,
+	CORBA_tk_octet=10,
+	CORBA_tk_any=11,
+	CORBA_tk_TypeCode=12,
+	CORBA_tk_Principal=13,
+	CORBA_tk_objref=14,
+ 	CORBA_tk_struct=15,
+	CORBA_tk_union=16,
+	CORBA_tk_enum=17,
+	CORBA_tk_string=18,
+	CORBA_tk_sequence=19,
+	CORBA_tk_array=20,
+	CORBA_tk_alias=21,
+	CORBA_tk_except=22,
+	CORBA_tk_longlong=23,
+	CORBA_tk_ulonglong=24,
+	CORBA_tk_longdouble=25,
+	CORBA_tk_wchar=26,
+	CORBA_tk_wstring=27,
+	CORBA_tk_fixed=28,
+	CORBA_tk_recursive=0xffffffff,
+	CORBA_tk_last=29	/* hack for GIOP */
+} CORBA_TCKind;
+
+#define TC_CORBA_short TC_short
+#define TC_CORBA_long TC_long
+#define TC_CORBA_longlong TC_longlong
+#define TC_CORBA_long_long TC_longlong
+#define TC_CORBA_ushort TC_ushort
+#define TC_CORBA_unsigned_short TC_ushort
+#define TC_CORBA_ulong TC_ulong
+#define TC_CORBA_unsigned_long TC_ulong
+#define TC_CORBA_ulonglong TC_ulonglong
+#define TC_CORBA_unsigned_long_long TC_ulonglong
+#define TC_CORBA_float TC_float
+#define TC_CORBA_double TC_double
+#define TC_CORBA_longdouble TC_longdouble
+#define TC_CORBA_long_double TC_longdouble
+#define TC_CORBA_boolean TC_boolean
+#define TC_CORBA_char TC_char
+#define TC_CORBA_wchar TC_wchar
+#define TC_CORBA_octet TC_octet
+#define TC_CORBA_any TC_any
+#define TC_CORBA_TypeCode TC_TypeCode
+#define TC_CORBA_Principal TC_Principal
+#define TC_CORBA_Object TC_Object
+#define TC_CORBA_string TC_string
+#define TC_CORBA_wstring TC_wstring
+
+#define TC_null ((CORBA_TypeCode)&TC_null_struct)
+#define TC_void ((CORBA_TypeCode)&TC_void_struct)
+#define TC_short ((CORBA_TypeCode)&TC_short_struct)
+#define TC_long ((CORBA_TypeCode)&TC_long_struct)
+#define TC_longlong ((CORBA_TypeCode)&TC_longlong_struct)
+#define TC_ushort ((CORBA_TypeCode)&TC_ushort_struct)
+#define TC_ulong ((CORBA_TypeCode)&TC_ulong_struct)
+#define TC_ulonglong ((CORBA_TypeCode)&TC_ulonglong_struct)
+#define TC_float ((CORBA_TypeCode)&TC_float_struct)
+#define TC_double ((CORBA_TypeCode)&TC_double_struct)
+#define TC_longdouble ((CORBA_TypeCode)&TC_longdouble_struct)
+#define TC_boolean ((CORBA_TypeCode)&TC_boolean_struct)
+#define TC_char ((CORBA_TypeCode)&TC_char_struct)
+#define TC_wchar ((CORBA_TypeCode)&TC_wchar_struct)
+#define TC_octet ((CORBA_TypeCode)&TC_octet_struct)
+#define TC_any ((CORBA_TypeCode)&TC_any_struct)
+#define TC_TypeCode ((CORBA_TypeCode)&TC_TypeCode_struct)
+#define TC_Principal ((CORBA_TypeCode)&TC_Principal_struct)
+#define TC_Object ((CORBA_TypeCode)&TC_Object_struct)
+#define TC_string ((CORBA_TypeCode)&TC_string_struct)
+#define TC_wstring ((CORBA_TypeCode)&TC_wstring_struct)
+#define TC_CORBA_NamedValue ((CORBA_TypeCode)&TC_CORBA_NamedValue_struct)
+
+#define TC_CORBA_short_struct TC_short_struct
+#define TC_CORBA_long_struct TC_long_struct
+#define TC_CORBA_longlong_struct TC_longlong_struct
+#define TC_CORBA_long_long_struct TC_longlong_struct
+#define TC_CORBA_ushort_struct TC_ushort_struct
+#define TC_CORBA_unsigned_short_struct TC_ushort_struct
+#define TC_CORBA_ulong_struct TC_ulong_struct
+#define TC_CORBA_unsigned_long_struct TC_ulong_struct
+#define TC_CORBA_ulonglong_struct TC_ulonglong_struct
+#define TC_CORBA_unsigned_long_long_struct TC_ulonglong_struct
+#define TC_CORBA_float_struct TC_float_struct
+#define TC_CORBA_double_struct TC_double_struct
+#define TC_CORBA_longdouble_struct TC_longdouble_struct
+#define TC_CORBA_long_double_struct TC_longdouble_struct
+#define TC_CORBA_boolean_struct TC_boolean_struct
+#define TC_CORBA_char_struct TC_char_struct
+#define TC_CORBA_wchar_struct TC_wchar_struct
+#define TC_CORBA_octet_struct TC_octet_struct
+#define TC_CORBA_any_struct TC_any_struct
+#define TC_CORBA_TypeCode_struct TC_TypeCode_struct
+#define TC_CORBA_Principal_struct TC_Principal_struct
+#define TC_CORBA_Object_struct TC_Object_struct
+#define TC_CORBA_string_struct TC_string_struct
+#define TC_CORBA_wstring_struct TC_wstring_struct
+
+extern const struct CORBA_TypeCode_struct TC_null_struct;
+extern const struct CORBA_TypeCode_struct TC_void_struct;
+extern const struct CORBA_TypeCode_struct TC_short_struct;
+extern const struct CORBA_TypeCode_struct TC_long_struct;
+extern const struct CORBA_TypeCode_struct TC_longlong_struct;
+extern const struct CORBA_TypeCode_struct TC_ushort_struct;
+extern const struct CORBA_TypeCode_struct TC_ulong_struct;
+extern const struct CORBA_TypeCode_struct TC_ulonglong_struct;
+extern const struct CORBA_TypeCode_struct TC_float_struct;
+extern const struct CORBA_TypeCode_struct TC_double_struct;
+extern const struct CORBA_TypeCode_struct TC_longdouble_struct;
+extern const struct CORBA_TypeCode_struct TC_boolean_struct;
+extern const struct CORBA_TypeCode_struct TC_char_struct;
+extern const struct CORBA_TypeCode_struct TC_wchar_struct;
+extern const struct CORBA_TypeCode_struct TC_octet_struct;
+extern const struct CORBA_TypeCode_struct TC_any_struct;
+extern const struct CORBA_TypeCode_struct TC_TypeCode_struct;
+extern const struct CORBA_TypeCode_struct TC_Principal_struct;
+extern const struct CORBA_TypeCode_struct TC_Object_struct;
+extern const struct CORBA_TypeCode_struct TC_string_struct;
+extern const struct CORBA_TypeCode_struct TC_wstring_struct;
+extern const struct CORBA_TypeCode_struct TC_CORBA_NamedValue_struct;
+
+
+#endif /* !_ORBIT_CORBA_TYPECODE_H_ */
+
+
+
+
diff -urN linux-2.4.1/net/korbit/orb/corba_typecode_type.h linux-2.4.1-korbit/net/korbit/orb/corba_typecode_type.h
--- linux-2.4.1/net/korbit/orb/corba_typecode_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/corba_typecode_type.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,66 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_CORBA_TYPECODE_TYPE_H_
+#define _ORBIT_CORBA_TYPECODE_TYPE_H_
+
+#include <ORBitutil/basic_types.h>
+#include "corba_typecode.h"
+#include "corba_any.h"
+
+typedef struct CORBA_TypeCode_Bounds {
+	int dummy;
+} CORBA_TypeCode_Bounds;
+
+typedef struct CORBA_TypeCode_BadKind {
+	int dummy;
+} CORBA_TypeCode_BadKind;
+
+struct CORBA_TypeCode_struct {
+	struct ORBit_PseudoObject_struct parent;
+	CORBA_TCKind kind;
+#ifndef __KORBIT__
+	const
+#endif
+	char *name;
+#ifndef __KORBIT__
+	const 
+#endif
+	char *repo_id;
+	CORBA_unsigned_long length;
+	CORBA_unsigned_long sub_parts;
+	const char **subnames;		/* for struct, exception, union, enum */
+	CORBA_TypeCode *subtypes;	/* for struct, exception, union, alias, array, sequence */
+	CORBA_any *sublabels;		/* for union */
+	CORBA_TypeCode discriminator;	/* for union */
+	CORBA_unsigned_long recurse_depth; /* for recursive sequence */
+	CORBA_long default_index;	/* for union */
+	CORBA_unsigned_short digits; /* for fixed */
+	CORBA_short scale;	     /* for fixed */
+};
+
+
+#endif /* !_ORBIT_CORBA_TYPECODE_TYPE_H_ */
+
diff -urN linux-2.4.1/net/korbit/orb/dii.c linux-2.4.1-korbit/net/korbit/orb/dii.c
--- linux-2.4.1/net/korbit/orb/dii.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/dii.c	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,454 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Red Hat Software, Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Elliot Lee <sopwith@redhat.com>
+ *          Dick Porter <dick@cymru.net>
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "orbit.h"
+#ifndef __KORBIT__
+#include "interface_repository.h"
+#endif /* !__KORBIT__ */
+
+struct CORBA_Request_type {
+	struct ORBit_PseudoObject_struct parent;
+
+	CORBA_Object obj;
+	CORBA_Context ctx;
+
+	CORBA_Flags req_flags;
+	CORBA_Identifier operation;
+
+	CORBA_NamedValue *result;
+	CORBA_NVList *arg_list;
+
+	CORBA_unsigned_long request_id;
+	GIOPSendBuffer *request_buffer;
+	GIOPRecvBuffer *reply_buffer;
+};
+
+static const ORBit_RootObject_Interface interface_CORBA_Request = {
+	(void (*)(gpointer,CORBA_Environment *))CORBA_Request_delete
+};
+
+/* Section 5.2.1 */
+CORBA_Status
+CORBA_Object_create_request(CORBA_Object obj,
+							CORBA_Context ctx,
+							CORBA_Identifier operation,
+							CORBA_NVList *arg_list,
+							CORBA_NamedValue *result,
+							CORBA_Request *request,
+							CORBA_Flags req_flags,
+							CORBA_Environment *ev)
+{
+	CORBA_Request new;
+
+	new=g_new0(struct CORBA_Request_type, 1);
+	ORBit_pseudo_object_init((ORBit_PseudoObject)new, ORBIT_PSEUDO_REQUEST, ev);
+	ORBit_RootObject_set_interface((ORBit_RootObject)new,
+								   (ORBit_RootObject_Interface *)&interface_CORBA_Request, ev);
+
+	if(new==NULL) {
+		CORBA_exception_set_system(ev,
+								   ex_CORBA_NO_MEMORY,
+								   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	new->obj=CORBA_Object_duplicate(obj, ev);
+	new->ctx=(CORBA_Context)CORBA_Object_duplicate((CORBA_Object)ctx, ev);
+	new->operation=CORBA_string_dup(operation);
+
+	new->result=result;
+
+	new->req_flags=req_flags;
+	new->request_id = giop_get_request_id();
+	new->arg_list = arg_list;
+
+	*request=(CORBA_Request)CORBA_Object_duplicate((CORBA_Object)new, ev);
+}
+
+/* Section 5.2, 5.2.2 */
+CORBA_Status
+CORBA_Request_add_arg(CORBA_Request req,
+					  CORBA_Identifier name,
+					  CORBA_TypeCode arg_type,
+					  void *value,
+					  CORBA_long len,
+					  CORBA_Flags arg_flags,
+					  CORBA_Environment *ev)
+{
+	gpointer new_value;
+
+	g_assert(req!=NULL);
+
+	if((arg_flags & CORBA_IN_COPY_VALUE) && (arg_flags & CORBA_ARG_IN)) {
+		new_value = ORBit_copy_value(value, arg_type);
+		if(new_value==NULL) {
+			CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY,
+									   CORBA_COMPLETED_NO);
+			return;
+		}
+	} else
+		new_value=value;
+
+	CORBA_NVList_add_item(req->arg_list, name, arg_type,
+						  new_value, len, arg_flags | req->req_flags, ev);
+}
+
+/* Section 5.2, 5.2.3 */
+CORBA_Status
+CORBA_Request_invoke(CORBA_Request req,
+					 CORBA_Flags invoke_flags,
+					 CORBA_Environment *ev)
+{
+	CORBA_Request_send(req, invoke_flags, ev);
+	if(ev->_major == CORBA_NO_EXCEPTION)
+		CORBA_Request_get_response(req, invoke_flags, ev);
+}
+
+/* Section 5.2, 5.2.4 */
+CORBA_Status CORBA_Request_delete(CORBA_Request req, CORBA_Environment *ev)
+{
+	CORBA_Object_release(req->obj, ev);
+	CORBA_Object_release((CORBA_Object)req->ctx, ev);
+
+	if(req->operation != NULL)
+		CORBA_free(req->operation);
+
+	if(req->arg_list != NULL) {
+		if(req->req_flags & CORBA_OUT_LIST_MEMORY)
+			CORBA_NVList_free(req->arg_list, ev);
+		else {
+			int i;
+			for(i = 0; i < req->arg_list->list->len; i++)
+				ORBit_NamedValue_free(&g_array_index(req->arg_list->list,
+													 CORBA_NamedValue, i));
+			g_array_free(req->arg_list->list, TRUE);
+			
+			g_free(req->arg_list);
+		}
+	}
+
+	if(req->result!=NULL)
+		ORBit_NamedValue_free(req->result);
+
+	if(req->request_buffer)
+		giop_send_buffer_unuse(req->request_buffer);
+
+	if(req->reply_buffer)
+		giop_recv_buffer_unuse(req->reply_buffer);
+
+	g_free(req);
+}
+
+/* Section 5.2, 5.3.1 */
+CORBA_Status
+CORBA_Request_send(CORBA_Request req,
+				   CORBA_Flags invoke_flags,
+				   CORBA_Environment *ev)
+{
+	int i;
+	GIOPConnection *cnx;
+
+	struct { CORBA_unsigned_long opstrlen; char opname[1]; } *opnameinfo;
+	struct iovec opvec = { NULL, 0 };
+
+	opvec.iov_len = strlen(req->operation)+1+sizeof(CORBA_unsigned_long);
+
+	opnameinfo = g_malloc(strlen(req->operation)+1+sizeof(CORBA_unsigned_long));
+	opvec.iov_base = (gpointer)opnameinfo;
+	opnameinfo->opstrlen = strlen(req->operation) + 1;
+	strcpy(opnameinfo->opname, req->operation);
+
+	cnx = ORBit_object_get_connection(req->obj);
+
+	g_assert(req->obj->active_profile);
+	req->request_buffer =
+		giop_send_request_buffer_use(req->obj->connection,
+									 NULL,
+									 req->request_id,
+									 req->result?TRUE:FALSE,
+									 &(req->obj->active_profile->object_key_vec),
+									 &opvec,
+									 &ORBit_default_principal_iovec
+									 );
+
+	if(!req->request_buffer) {
+		CORBA_exception_set_system(ev,
+								   ex_CORBA_COMM_FAILURE,
+								   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	for(i = 0; i < req->arg_list->list->len; i++) {
+		CORBA_NamedValue *nv;
+
+		nv = &g_array_index(req->arg_list->list, CORBA_NamedValue, i); 
+
+		if((nv->arg_modes & CORBA_ARG_IN)
+		   || (nv->arg_modes & CORBA_ARG_INOUT))
+			ORBit_marshal_arg(req->request_buffer, 
+							  nv->argument._value,
+							  nv->argument._type);
+	}
+				      
+	giop_send_buffer_write(req->request_buffer);
+
+	giop_send_buffer_unuse(req->request_buffer);
+	req->request_buffer = 0;
+
+	g_free(opnameinfo);
+}
+
+/* Section 5.3.2 */
+CORBA_Status
+CORBA_send_multiple_requests(CORBA_Request *reqs,
+							 CORBA_Environment *env,
+							 CORBA_long count,
+							 CORBA_Flags invoke_flags)
+{
+	int i;
+
+	for(i = 0; i < count; i++)
+		CORBA_Request_send(reqs[i], invoke_flags, env);	
+}
+
+void
+ORBit_handle_dii_reply(CORBA_Request req, CORBA_Environment *ev)
+{
+	int i;
+
+	/* XXX TODO - handle exceptions, location forwards(?), all that */
+	req->result->argument._value =
+		ORBit_demarshal_arg(req->reply_buffer, req->result->argument._type,
+							TRUE, req->obj->orb);
+	req->result->argument._release = CORBA_TRUE;
+	
+	for(i = 0; i < req->arg_list->list->len; i++) {
+		CORBA_NamedValue *nv;
+
+		nv = &g_array_index(req->arg_list->list, CORBA_NamedValue, i); 
+
+		if(nv->arg_modes & CORBA_ARG_INOUT) {
+			CORBA_Object_duplicate((CORBA_Object)nv->argument._type, NULL);
+			CORBA_any__free(&nv->argument, NULL, TRUE);
+		}
+
+		if((nv->arg_modes & CORBA_ARG_OUT)
+		   || (nv->arg_modes & CORBA_ARG_INOUT))
+			nv->argument._value = ORBit_demarshal_arg(req->reply_buffer,
+													  nv->argument._type,
+													  TRUE, req->obj->orb);
+	}
+
+	giop_recv_buffer_unuse(req->reply_buffer);
+	req->reply_buffer = 0;
+}
+
+/* Section 5.2, 5.3.3
+ *
+ * Raises: WrongTransaction
+ */
+CORBA_Status
+CORBA_Request_get_response(CORBA_Request req,
+						   CORBA_Flags response_flags,
+						   CORBA_Environment *ev)
+{
+	req->reply_buffer = giop_recv_reply_buffer_use(req->request_id,
+												   !(response_flags & CORBA_RESP_NO_WAIT));
+
+	if(!req->reply_buffer) {
+		CORBA_exception_set_system(ev,
+								   ex_CORBA_COMM_FAILURE,
+								   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	ORBit_handle_dii_reply(req, ev);
+}
+
+/* Section 5.3.4
+ *
+ * Raises: WrongTransaction
+ */
+CORBA_Status
+CORBA_Request_get_next_response(CORBA_Environment *env,
+								CORBA_Flags response_flags,
+								CORBA_Request *req)
+{
+	int i;
+	GIOPRecvBuffer *rb;
+	GArray *reqids = g_array_new(FALSE, FALSE,
+								 sizeof(CORBA_unsigned_long));
+
+	for(i = 0; req[i]; i++) {
+		g_array_append_val(reqids, req[i]->request_id);
+	}
+
+	rb = giop_recv_reply_buffer_use_multiple(reqids,
+											 !(response_flags & CORBA_RESP_NO_WAIT));
+
+	if(rb) {
+		for(i = 0; i < reqids->len; i++) {
+			if(g_array_index(reqids, CORBA_unsigned_long, i)
+			   == rb->message.u.reply.request_id) {
+				req[i]->reply_buffer = rb;
+				break;
+			}
+		}
+
+		if(i < reqids->len)
+			ORBit_handle_dii_reply(req[i], env);
+	}
+
+	g_array_free(reqids, TRUE);
+}
+
+
+/* Section 5.4.1 */
+CORBA_Status
+CORBA_ORB_create_list(CORBA_ORB orb,
+					  CORBA_long count,
+					  CORBA_NVList **new_list,
+					  CORBA_Environment *ev)
+{
+	CORBA_NVList *new;
+
+	new = g_new0(CORBA_NVList, 1);
+	if(new==NULL) goto new_alloc_failed;
+
+	new->list = g_array_new(FALSE, TRUE, sizeof(CORBA_NamedValue));
+
+	*new_list = new;
+
+	return;
+
+ new_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+}
+
+#ifndef __KORBIT__
+/* Section 5.4.6 */
+CORBA_Status
+CORBA_ORB_create_operation_list(CORBA_ORB orb,
+								CORBA_OperationDef oper,
+								CORBA_NVList **new_list,
+								CORBA_Environment *ev)
+{
+	if(!new_list) {
+		CORBA_exception_set_system(ev,
+								   ex_CORBA_BAD_PARAM,
+								   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	g_warning("CORBA_ORB_create_operation_list NYI");
+
+	CORBA_exception_set_system(ev,
+							   ex_CORBA_IMP_LIMIT,
+							   CORBA_COMPLETED_NO);
+}
+#endif /* !__KORBIT__ */
+
+/* Section 5.4.2 */
+CORBA_Status
+CORBA_NVList_add_item(CORBA_NVList *list,
+					  CORBA_Identifier item_name,
+					  CORBA_TypeCode item_type,
+					  void *value,
+					  CORBA_long value_len,
+					  CORBA_Flags item_flags,
+					  CORBA_Environment *ev)
+{
+	CORBA_NamedValue newval;
+
+	g_assert(list!=NULL);
+
+	newval.name = CORBA_string_dup(item_name);
+	newval.argument._type = (CORBA_TypeCode)CORBA_Object_duplicate((CORBA_Object)item_type, ev);
+	if(item_flags & CORBA_IN_COPY_VALUE) {
+		newval.argument._value = ORBit_copy_value(value, item_type);
+		newval.argument._release = CORBA_TRUE;
+	} else {
+		newval.argument._value = value;
+		newval.argument._release = CORBA_FALSE;
+	}
+
+	newval.len = value_len; /* Is this even useful? *sigh* */
+	newval.arg_modes = item_flags;
+
+	g_array_append_val(list->list, newval);
+}
+
+void ORBit_NamedValue_free(CORBA_NamedValue *nv)
+{
+	CORBA_free(nv->name);
+}
+
+/* Section 5.4.3 */
+CORBA_Status
+CORBA_NVList_free(CORBA_NVList *list,
+				  CORBA_Environment *ev)
+{
+	int i;
+
+	CORBA_NVList_free_memory(list, ev);
+
+	for(i = 0; i < list->list->len; i++)
+		ORBit_NamedValue_free(&g_array_index(list->list, CORBA_NamedValue, i));
+
+	g_array_free(list->list, TRUE);
+
+	g_free(list);
+}
+
+/* Section 5.4.4 */
+CORBA_Status
+CORBA_NVList_free_memory(CORBA_NVList *list,
+						 CORBA_Environment *ev)
+{
+	int i;
+
+	for(i = 0; i < list->list->len; i++) {
+		CORBA_free(g_array_index(list->list, CORBA_NamedValue, i).argument._value);
+		g_array_index(list->list, CORBA_NamedValue, i).argument._value = NULL;
+		CORBA_Object_release((CORBA_Object)g_array_index(list->list, CORBA_NamedValue, i).argument._type, ev);
+		g_array_index(list->list, CORBA_NamedValue, i).argument._release = CORBA_FALSE;
+	}
+}
+
+
+/* Section 5.4.5 */
+CORBA_Status
+CORBA_NVList_get_count(CORBA_NVList *list,
+					   CORBA_long *count,
+					   CORBA_Environment *ev)
+{
+	*count = list->list->len;
+}
+
diff -urN linux-2.4.1/net/korbit/orb/dii.h linux-2.4.1-korbit/net/korbit/orb/dii.h
--- linux-2.4.1/net/korbit/orb/dii.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/dii.h	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,124 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_DII_H_
+#define _ORBIT_DII_H_
+
+#include "orb/orbit_types.h"
+#ifndef __KORBIT__
+#include "orb/interface_repository.h"
+#endif /* !__KORBIT__ */
+
+extern CORBA_Status CORBA_Object_create_request(
+	CORBA_Object obj,
+	CORBA_Context ctx,
+	CORBA_Identifier operation,
+	CORBA_NVList *arg_list,
+	CORBA_NamedValue *result,
+	CORBA_Request *request,
+	CORBA_Flags req_flags,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Request_add_arg(
+	CORBA_Request req,
+	CORBA_Identifier name,
+	CORBA_TypeCode arg_type,
+	void *value,
+	CORBA_long len,
+	CORBA_Flags arg_flags,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Request_invoke(
+	CORBA_Request req,
+	CORBA_Flags invoke_flags,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Request_delete(
+	CORBA_Request req,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_Request_send(
+	CORBA_Request req,
+	CORBA_Flags invoke_flags,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_send_multiple_requests(
+	CORBA_Request reqs[],
+	CORBA_Environment *env,
+	CORBA_long count,
+	CORBA_Flags invoke_flags);
+
+extern CORBA_Status CORBA_Request_get_response(
+	CORBA_Request req,
+	CORBA_Flags response_flags,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_get_next_response(
+	CORBA_Environment *env,
+	CORBA_Flags response_flags,
+	CORBA_Request *req);
+
+extern CORBA_Status CORBA_NVList_add_item(
+	CORBA_NVList *list,
+	CORBA_Identifier item_name,
+	CORBA_TypeCode item_type,
+	void *value,
+	CORBA_long value_len,
+	CORBA_Flags item_flags,
+	CORBA_Environment *ev);
+
+extern void ORBit_NamedValue_free(
+	CORBA_NamedValue *nv);
+
+
+extern CORBA_Status CORBA_ORB_create_list(
+	CORBA_ORB orb,
+	CORBA_long count,
+	CORBA_NVList **new_list,
+	CORBA_Environment *ev);
+
+#ifndef __KORBIT__
+extern CORBA_Status CORBA_ORB_create_operation_list(
+	CORBA_ORB orb,
+	CORBA_OperationDef oper,
+	CORBA_NVList **new_list,
+	CORBA_Environment *ev);
+#endif /* !__KORBIT__ */
+
+extern CORBA_Status CORBA_NVList_free(CORBA_NVList *list,
+				      CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_NVList_free_memory(
+	CORBA_NVList *list,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_NVList_get_count(
+	CORBA_NVList *list,
+	CORBA_long *count,
+	CORBA_Environment *ev);
+
+extern const int sizeofs[], container_sizeofs[];
+
+#endif /* _ORBIT_DII_H_ */
diff -urN linux-2.4.1/net/korbit/orb/env.c linux-2.4.1-korbit/net/korbit/orb/env.c
--- linux-2.4.1/net/korbit/orb/env.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/env.c	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,345 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+/*
+ * CORBA_Environment handling functions
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "orbit.h"
+#ifndef __KORBIT__
+#include "interface_repository.h"
+#endif /* !__KORBIT__ */
+
+struct SysExInfo {
+	const char *repo_id;
+	const int exnum;
+};
+
+static const struct SysExInfo exception_table[] = {
+	{NULL, 0},
+	{"IDL:CORBA/UNKNOWN:1.0", 1},
+	{"IDL:CORBA/BAD_PARAM:1.0", 2},
+	{"IDL:CORBA/NO_MEMORY:1.0", 3},
+	{"IDL:CORBA/IMP_LIMIT:1.0", 4},
+	{"IDL:CORBA/COMM_FAILURE:1.0", 5},
+	{"IDL:CORBA/INV_OBJREF:1.0", 6},
+	{"IDL:CORBA/NO_PERMISSION:1.0", 7},
+	{"IDL:CORBA/INTERNAL:1.0", 8},
+	{"IDL:CORBA/MARSHAL:1.0", 9},
+	{"IDL:CORBA/INITIALIZE:1.0", 10},
+	{"IDL:CORBA/NO_IMPLEMENT:1.0", 11},
+	{"IDL:CORBA/BAD_TYPECODE:1.0", 12},
+	{"IDL:CORBA/BAD_OPERATION:1.0", 13},
+	{"IDL:CORBA/NO_RESOURCES:1.0", 14},
+	{"IDL:CORBA/NO_RESPONSE:1.0", 15},
+	{"IDL:CORBA/PERSIST_STORE:1.0", 16},
+	{"IDL:CORBA/BAD_INV_ORDER:1.0", 17},
+	{"IDL:CORBA/TRANSIENT:1.0", 18},
+	{"IDL:CORBA/FREE_MEM:1.0", 19},
+	{"IDL:CORBA/INV_IDENT:1.0", 20},
+	{"IDL:CORBA/INV_FLAG:1.0", 21},
+	{"IDL:CORBA/INTF_REPOS:1.0", 22},
+	{"IDL:CORBA/BAD_CONTEXT:1.0", 23},
+	{"IDL:CORBA/OBJ_ADAPTER:1.0", 24},
+	{"IDL:CORBA/DATA_CONVERSION:1.0", 25},
+	{"IDL:CORBA/OBJECT_NOT_EXIST:1.0", 26},
+	{"IDL:CORBA/TRANSACTION_REQUIRED:1.0", 27},
+	{"IDL:CORBA/TRANSACTION_ROLLEDBACK:1.0", 28},
+	{"IDL:CORBA/INVALID_TRANSACTION:1.0", 29},
+	{NULL,0}
+};
+
+void CORBA_exception_free(CORBA_Environment *ev)
+{
+	g_assert(ev!=NULL);
+
+	ev->_major=CORBA_NO_EXCEPTION;
+
+	if(ev->_repo_id) {
+		CORBA_free(ev->_repo_id);
+		ev->_repo_id=NULL;
+	}
+
+	if(ev->_params) {
+		CORBA_free(ev->_params);
+		ev->_params=NULL;
+	}
+
+	if(ev->_any) {
+		CORBA_free(ev->_any);
+		ev->_any=NULL;
+	}
+}
+
+void CORBA_exception_set(CORBA_Environment *ev, CORBA_exception_type major, 
+			 const CORBA_char *except_repos_id, void *param)
+{
+	g_assert(ev!=NULL);
+
+	if(ev->_major != CORBA_NO_EXCEPTION)
+		CORBA_exception_free(ev);
+
+	ev->_major=major;
+
+	if(except_repos_id==NULL) {
+		ev->_repo_id=NULL;
+	} else {
+		ev->_repo_id=CORBA_string_dup(except_repos_id);
+	}
+
+	ev->_params=param;
+}
+
+void CORBA_exception_set_system(CORBA_Environment *ev, CORBA_unsigned_long ex_value,
+				CORBA_completion_status completed)
+{
+	CORBA_SystemException *new;
+
+	new=ORBit_alloc(sizeof(CORBA_SystemException), NULL, NULL);
+	if(new!=NULL) {
+		new->minor=0;
+		new->completed=completed;
+
+		/* XXX what should the repo ID be? */
+		CORBA_exception_set(ev, CORBA_SYSTEM_EXCEPTION,
+				    exception_table[ex_value].repo_id,
+				    new);
+	}
+}
+
+void CORBA_exception_init(CORBA_Environment *ev)
+{
+	g_assert(ev!=NULL);
+
+	ev->_major=CORBA_NO_EXCEPTION;
+	ev->_repo_id=NULL;
+	ev->_params=NULL;
+	ev->_any=NULL;
+}
+
+CORBA_char *CORBA_exception_id(CORBA_Environment *ev)
+{
+	g_assert(ev!=NULL);
+
+	if(ev->_major==CORBA_NO_EXCEPTION) {
+		return(NULL);
+	} else {
+		return(ev->_repo_id);
+	}
+}
+
+void *CORBA_exception_value(CORBA_Environment *ev)
+{
+	g_assert(ev!=NULL);
+
+	if(ev->_major==CORBA_NO_EXCEPTION) {
+		return(NULL);
+	} else {
+		return(ev->_params);
+	}
+}
+
+#ifndef __KORBIT__
+CORBA_any *CORBA_exception_as_any(CORBA_Environment *ev)
+{
+	g_assert(ev!=NULL);
+
+	if(ev->_major==CORBA_NO_EXCEPTION) {
+		return(NULL);
+	}
+
+	if(ev->_any!=NULL) {
+		return(ev->_any);
+	}
+
+	ev->_any=g_new(CORBA_any, 1);
+	if(ev->_any!=NULL) {
+		/* XXX is this the correct type? */
+		ev->_any->_type = (CORBA_TypeCode)TC_CORBA_ExceptionDescription;
+		ev->_any->_value = ev->_params;
+		ev->_any->_release = 0;
+	}
+
+	return(ev->_any);
+}
+#endif /* !__KORBIT__ */
+
+/**** ORBit_handle_exception
+      Inputs: 'rb' - a receive buffer for which an exception condition has
+                     been determined
+	      'ev' - memory in which to store the exception information
+
+	      'user_exceptions' -     list of user exceptions raisable
+				      for this particular operation.
+      Side-effects: reinitializes '*ev'
+
+      Description:
+           During demarshalling a reply, if reply_status != CORBA_NO_EXCEPTION,
+	   we must find out what exception was raised and place that information
+	   in '*ev'.  */
+
+void ORBit_handle_exception(GIOPRecvBuffer *rb, CORBA_Environment *ev,
+			    const ORBit_exception_demarshal_info *user_exceptions,
+			    CORBA_ORB orb)
+{
+	CORBA_SystemException *new;
+	CORBA_unsigned_long len, completion_status;
+	CORBA_char *my_repoid;
+
+	g_return_if_fail(GIOP_MESSAGE_BUFFER(rb)->message_header.message_type == GIOP_REPLY);
+
+	CORBA_exception_free(ev);
+
+	rb->cur = ALIGN_ADDRESS(rb->cur, sizeof(len));
+	rb->decoder(&len, rb->cur, sizeof(len));
+	/* (guchar *)rb->cur += sizeof(len); */
+	rb->cur = ((guchar *)rb->cur) + sizeof(len);
+
+	if(len) {
+		my_repoid = rb->cur;
+		rb->cur = ((guchar *)rb->cur) + len;
+	} else
+		my_repoid = NULL;
+
+	if(rb->message.u.reply.reply_status == CORBA_SYSTEM_EXCEPTION) {
+		CORBA_unsigned_long minor;
+
+		ev->_major = CORBA_SYSTEM_EXCEPTION;
+
+		rb->cur = ALIGN_ADDRESS(rb->cur, sizeof(minor));
+		rb->decoder(&minor, rb->cur, sizeof(minor));
+		rb->cur = ((guchar *)rb->cur) + sizeof(minor);
+
+		rb->cur = ALIGN_ADDRESS(rb->cur, sizeof(completion_status));
+		rb->decoder(&completion_status, rb->cur, sizeof(completion_status));
+		rb->cur = ((guchar *)rb->cur) + sizeof(completion_status);
+
+		new=ORBit_alloc(sizeof(CORBA_SystemException), NULL, NULL);
+
+		if(new!=NULL) {
+			new->minor=minor;
+			new->completed=completion_status;
+			
+		/* XXX what should the repo ID be? */
+		CORBA_exception_set(ev, CORBA_SYSTEM_EXCEPTION,
+				    my_repoid,
+				    new);
+		}
+	} else if(rb->message.u.reply.reply_status == CORBA_USER_EXCEPTION) {
+		int i;
+
+		if(!user_exceptions) {
+			/* weirdness; they raised an exception that we don't
+			   know about */
+			CORBA_exception_set_system(ev, ex_CORBA_MARSHAL,
+						   CORBA_COMPLETED_MAYBE);
+		} else {
+			for(i = 0; user_exceptions[i].tc != CORBA_OBJECT_NIL;
+			    i++) {
+				if(!strcmp(user_exceptions[i].tc->repo_id,
+					   my_repoid))
+					break;
+			}
+
+			if(user_exceptions[i].tc == CORBA_OBJECT_NIL) {
+				/* weirdness; they raised an exception
+				   that we don't know about */
+				CORBA_exception_set_system(ev, ex_CORBA_MARSHAL,
+							   CORBA_COMPLETED_MAYBE);
+			} else {
+				user_exceptions[i].demarshal(rb, ev);
+			}
+		}
+	};
+
+	/* ignore LOCATION_FORWARD here, that gets handled in the stub */
+}
+
+void
+ORBit_send_system_exception(GIOPSendBuffer *send_buffer,
+			    CORBA_Environment *ev)
+{
+	CORBA_unsigned_long minor;
+	CORBA_unsigned_long completion_status;
+	CORBA_SystemException *se = ev->_params;
+
+	minor = se->minor;
+	completion_status = se->completed;
+
+	ENCODER_CALL(CORBA_char, ev->_repo_id);
+	giop_send_buffer_append_mem_indirect_a(send_buffer, &minor,
+					       sizeof(minor));
+	giop_send_buffer_append_mem_indirect_a(send_buffer,
+					       &completion_status,
+					       sizeof(completion_status));
+}
+
+void
+ORBit_send_user_exception(GIOPSendBuffer *send_buffer,
+			  CORBA_Environment *ev,
+			  const ORBit_exception_marshal_info *user_exceptions)
+{
+	int i;
+
+	for(i = 0; user_exceptions[i].tc != CORBA_OBJECT_NIL; i++) {
+		if(!strcmp(user_exceptions[i].tc->repo_id, ev->_repo_id))
+			break;
+	}
+
+	if(user_exceptions[i].tc == CORBA_OBJECT_NIL) {
+		CORBA_Environment fakeev;
+		CORBA_exception_init(&fakeev);
+		CORBA_exception_set_system(&fakeev, ex_CORBA_UNKNOWN,
+					   CORBA_COMPLETED_MAYBE);
+		ORBit_send_system_exception(send_buffer, &fakeev);
+		CORBA_exception_free(&fakeev);
+	} else {
+		ENCODER_CALL(CORBA_char, ev->_repo_id);
+
+		if(user_exceptions[i].marshal && ev->_params)
+			user_exceptions[i].marshal(send_buffer, ev);
+	}
+}
+
+void
+ORBit_handle_system_exception(CORBA_Environment *ev,
+			      CORBA_unsigned_long system_exception_minor,
+			      CORBA_unsigned_long completion_status,
+			      GIOPRecvBuffer *recv_buffer,
+			      GIOPSendBuffer *send_buffer)
+{
+	CORBA_exception_set_system(ev, system_exception_minor, completion_status);
+
+	if(send_buffer)
+		giop_send_buffer_unuse(send_buffer);
+
+	if(recv_buffer)
+		giop_recv_buffer_unuse(recv_buffer);
+}
diff -urN linux-2.4.1/net/korbit/orb/env.h linux-2.4.1-korbit/net/korbit/orb/env.h
--- linux-2.4.1/net/korbit/orb/env.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/env.h	Thu Feb  1 16:21:56 2001
@@ -0,0 +1,79 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998, 1999 Richard H. Porter, Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_ENV_H_
+#define _ORBIT_ENV_H_
+
+#include "orbit_types.h"
+
+extern void CORBA_exception_set(CORBA_Environment *ev,
+	CORBA_exception_type major, 
+	const CORBA_char *except_repos_id,
+	void *param);
+
+extern void CORBA_exception_set_system(CORBA_Environment *ev,
+	CORBA_unsigned_long ex_value,
+	CORBA_completion_status completed);
+
+extern void CORBA_exception_init(CORBA_Environment *ev);
+
+extern CORBA_char *CORBA_exception_id(CORBA_Environment *e);
+
+extern void *CORBA_exception_value(CORBA_Environment *ev);
+
+extern void CORBA_exception_free(CORBA_Environment *ev);
+
+#ifndef __KORBIT__
+extern CORBA_any *CORBA_exception_as_any(CORBA_Environment *ev);
+#endif /* !__KORBIT__ */
+
+typedef struct {
+	const CORBA_TypeCode tc;
+	void (*demarshal)(GIOPRecvBuffer *_ORBIT_recv_buffer, CORBA_Environment *ev);
+} ORBit_exception_demarshal_info;
+
+typedef struct {
+	const CORBA_TypeCode tc;
+	void (*marshal)(GIOPSendBuffer *_ORBIT_send_buffer, CORBA_Environment *ev);
+} ORBit_exception_marshal_info;
+
+/* ORBit-specific */
+void ORBit_handle_exception(GIOPRecvBuffer *rb, CORBA_Environment *ev,
+			    const ORBit_exception_demarshal_info *user_exceptions,
+			    CORBA_ORB orb);
+void ORBit_send_system_exception(GIOPSendBuffer *send_buffer,
+				 CORBA_Environment *ev);
+void ORBit_send_user_exception(GIOPSendBuffer *send_buffer,
+			       CORBA_Environment *ev,
+			       const ORBit_exception_marshal_info *user_exceptions);
+
+/* Used by stubs */
+void ORBit_handle_system_exception(CORBA_Environment *ev,
+				   CORBA_unsigned_long system_exception_minor,
+				   CORBA_unsigned_long completion_status,
+				   GIOPRecvBuffer *recv_buffer,
+				   GIOPSendBuffer *send_buffer);
+
+#endif /* !_ORBIT_ENV_H_ */
diff -urN linux-2.4.1/net/korbit/orb/genrand.c linux-2.4.1-korbit/net/korbit/orb/genrand.c
--- linux-2.4.1/net/korbit/orb/genrand.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/genrand.c	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,131 @@
+#include "genrand.h"
+#include "ORBitutil/util.h"
+#include <unistd.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <glib.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <limits.h>
+#include <stdio.h>
+#ifdef __KERNEL__
+#include <linux/random.h>
+#endif
+
+static gboolean
+genrand_dev(guchar *buffer, int buf_len)
+{
+#ifdef __KERNEL__
+  get_random_bytes(buffer, buf_len);
+#else /*! __KERNEL__*/
+  int fd;
+
+  fd = open("/dev/urandom", O_RDONLY);
+  if(fd < 0)
+    return FALSE;
+
+  if(read(fd, buffer, buf_len) < buf_len)
+    {
+      close(fd);
+      return FALSE;
+    }
+
+  close(fd);
+#endif /*! __KERNEL__*/
+
+  return TRUE;
+}
+
+#ifndef __KORBIT__
+static volatile int received_alarm = 0;
+
+static void
+handle_alarm(int signum)
+{
+  received_alarm = 1;
+}
+
+static inline guchar
+hashlong(long val)
+{
+  guchar retval, *ptr;
+  int i;
+
+  for(ptr = (guchar *)&val, i = 0; i < sizeof(val); i++)
+    retval ^= ptr[i];
+
+  return retval;
+}
+
+static gboolean
+genrand_unix(guchar *buffer, int buf_len)
+{
+  struct sigaction sa, oldsa;
+  struct itimerval it, oldit;
+  int i;
+  long min, max;
+  long *counts;
+  double diff;
+  long *uninit;
+
+  counts = alloca(buf_len * sizeof(long));
+
+  memset(&sa, 0, sizeof(sa));
+  sa.sa_handler = handle_alarm;
+  sigaction(SIGALRM, &sa, &oldsa);
+  memset(&it, 0, sizeof(it));
+  it.it_value.tv_usec = 1;
+  getitimer(ITIMER_REAL, &oldit);
+
+  for(i = 0, min = LONG_MAX, max = 0; i < buf_len; i++)
+    {
+      received_alarm = 0;
+      setitimer(ITIMER_REAL, &it, NULL);
+      for(counts[i] = 0; !received_alarm; counts[i]++);
+
+      max = MAX(counts[i], max);
+      min = MIN(counts[i], min);
+    }
+
+  if(!(max - min)) 
+  {
+          freeca(counts);
+          return FALSE;
+  }
+  
+  diff = max - min;
+
+  uninit = alloca(buf_len * sizeof(long)); /* Purposely not initialized */
+  for(i = 0; i < buf_len; i++)
+    {
+      long diffval;
+      diffval = counts[i] - min;
+
+      buffer[i] ^= (guchar)( ((double) (diffval*256)  / diff )) ^ hashlong(uninit[i]);
+    }
+
+  setitimer(ITIMER_REAL, &oldit, NULL);
+  sigaction(SIGALRM, &oldsa, NULL);
+
+  freeca(counts);
+  freeca(uninit);
+  
+  return TRUE;
+}
+#endif /* !__KORBIT__ */
+
+void
+orbit_genrand(guchar *buffer, int buf_len)
+{
+  g_return_if_fail(buf_len);
+
+  if(genrand_dev(buffer, buf_len))
+    return;
+#ifndef __KORBIT__
+  else if(genrand_unix(buffer, buf_len))
+    return;
+#endif
+  else
+    g_error("Couldn't generate random data!");
+}
+
diff -urN linux-2.4.1/net/korbit/orb/genrand.h linux-2.4.1-korbit/net/korbit/orb/genrand.h
--- linux-2.4.1/net/korbit/orb/genrand.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/genrand.h	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,8 @@
+#ifndef ORBIT_GENRAND_H
+#define ORBIT_GENRAND_H 1
+
+#include <glib.h>
+
+void orbit_genrand(guchar *buffer, int buf_len);
+
+#endif /* ORBIT_GENRAND_H */
diff -urN linux-2.4.1/net/korbit/orb/iop.h linux-2.4.1-korbit/net/korbit/orb/iop.h
--- linux-2.4.1/net/korbit/orb/iop.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/iop.h	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,207 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_IOP_H_
+#define _ORBIT_IOP_H_
+
+#include <ORBitutil/basic_types.h>
+
+#include <orb/corba_basic_sequences_type.h>
+
+#ifndef HAVE_CORBA_PRINCIPAL
+#define HAVE_CORBA_PRINCIPAL 1
+typedef CORBA_sequence_octet CORBA_Principal;
+#endif
+
+typedef CORBA_unsigned_long IOP_ProfileId;
+
+#define IOP_TAG_INTERNET_IOP 0
+#define IOP_TAG_MULTIPLE_COMPONENTS 1
+#define IOP_TAG_ORBIT_SPECIFIC 0xbadfaecal
+
+typedef struct IOP_TaggedProfile {
+	IOP_ProfileId tag;
+	CORBA_sequence_octet profile_data;
+} IOP_TaggedProfile;
+
+typedef struct CORBA_sequence_TaggedProfile {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	IOP_TaggedProfile *_buffer;
+} CORBA_sequence_TaggedProfile;
+
+typedef struct IOP_IOR {
+	CORBA_char *type_id;
+	CORBA_sequence_TaggedProfile profiles;
+} IOP_IOR;
+
+typedef CORBA_unsigned_long IOP_ComponentId;
+
+typedef struct IOP_TaggedComponent {
+	IOP_ComponentId tag;
+	CORBA_sequence_octet component_data;
+} IOP_TaggedComponent;
+
+typedef struct CORBA_sequence_TaggedComponent {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	IOP_TaggedComponent *_buffer;
+} CORBA_sequence_TaggedComponent;
+
+typedef struct CORBA_sequence_TaggedComponent IOP_MultipleComponentProfile;
+
+#define IOP_TAG_ORB_TYPE 0
+#define IOP_TAG_CODE_SETS 1
+#define IOP_TAG_SEC_NAME 14
+#define IOP_TAG_ASSOCIATION_OPTIONS 13
+#define IOP_TAG_GENERIC_SEC_MECH 12
+
+typedef CORBA_unsigned_long IOP_ServiceId;
+
+typedef struct IOP_ServiceContext {
+	IOP_ServiceId context_id;
+	CORBA_sequence_octet context_data;
+} IOP_ServiceContext;
+
+typedef struct CORBA_sequence_ServiceContext {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	IOP_ServiceContext *_buffer;
+} CORBA_sequence_ServiceContext;
+
+typedef struct CORBA_sequence_ServiceContext IOP_ServiceContextList;
+
+#define IOP_TransactionService 0
+#define IOP_CodeSets 1
+
+typedef CORBA_unsigned_long CONV_FRAME_CodeSetId;
+
+typedef struct CORBA_sequence_CodeSetId {
+	CORBA_unsigned_long _maximum;
+	CORBA_unsigned_long _length;
+	CONV_FRAME_CodeSetId *_buffer;
+} CORBA_sequence_CodeSetId;
+
+typedef struct CONV_FRAME_CodeSetComponent {
+	CONV_FRAME_CodeSetId native_code_set;
+	CORBA_sequence_CodeSetId conversion_code_sets;
+} CONV_FRAME_CodeSetComponent;
+
+typedef struct CONV_FRAME_CodeSetComponentInfo {
+	CONV_FRAME_CodeSetComponent ForCharData;
+	CONV_FRAME_CodeSetComponent ForWcharData;
+} CONV_FRAME_CodeSetComponentInfo;
+
+typedef struct CONV_FRAME_CodeSetContext {
+	CONV_FRAME_CodeSetId char_data;
+	CONV_FRAME_CodeSetId wchar_data;
+} CONV_FRAME_CodeSetContext;
+
+typedef struct GIOP_Version {
+	CORBA_octet major;
+	CORBA_octet minor;
+} GIOP_Version;
+
+typedef enum {
+	GIOP_Request=0,
+	GIOP_Reply,
+	GIOP_CancelRequest,
+	GIOP_LocateRequest,
+	GIOP_LocateReply,
+	GIOP_CloseConnection,
+	GIOP_MessageError
+} GIOP_MsgType_1_0;
+
+typedef struct GIOP_MessageHeader_1_0 {
+	CORBA_char magic[4];
+	GIOP_Version GIOP_version;
+	CORBA_boolean byte_order;
+	CORBA_octet message_type;
+	CORBA_unsigned_long message_size;
+} GIOP_MessageHeader_1_0;
+
+typedef struct GIOP_MessageHeader_1_1 {
+	CORBA_char magic[4];
+	GIOP_Version GIOP_version;
+	CORBA_octet flags;
+	CORBA_octet message_type;
+	CORBA_unsigned_long message_size;
+} GIOP_MessageHeader_1_1;
+
+typedef struct GIOP_RequestHeader_1_0 {
+	IOP_ServiceContextList service_context;
+	CORBA_unsigned_long request_id;
+	CORBA_boolean response_expected;
+	CORBA_sequence_octet object_key;
+	CORBA_char *operation;
+	CORBA_Principal requesting_principal;
+} GIOP_RequestHeader_1_0;
+
+typedef struct GIOP_RequestHeader_1_1 {
+	IOP_ServiceContextList service_context;
+	CORBA_unsigned_long request_id;
+	CORBA_boolean response_expected;
+	CORBA_octet reserved[3];
+	CORBA_sequence_octet object_key;
+	CORBA_char *operation;
+	CORBA_Principal requesting_principal;
+} GIOP_RequestHeader_1_1;
+
+typedef struct GIOP_SystemExceptionReplyBody {
+	CORBA_char *exception_id;
+	CORBA_unsigned_long minor_code_value;
+	CORBA_unsigned_long completion_status;
+} GIOP_SystemExceptionReplyBody;
+
+typedef struct GIOP_CancelRequestHeader {
+	CORBA_unsigned_long request_id;
+} GIOP_CancelRequestHeader;
+
+typedef struct GIOP_LocateRequestHeader {
+	CORBA_unsigned_long request_id;
+	CORBA_sequence_octet object_key;
+} GIOP_LocateRequestHeader;
+
+typedef struct IIOP_Version {
+	CORBA_octet major;
+	CORBA_octet minor;
+} IIOP_Version;
+
+typedef struct IIOP_ProfileBody_1_0 {
+	IIOP_Version iiop_version;
+	CORBA_char *host;
+	CORBA_unsigned_short port;
+	CORBA_sequence_octet object_key;
+} IIOP_ProfileBody_1_0;
+
+typedef struct IIOP_ProfileBody_1_1 {
+	IIOP_Version iiop_version;
+	CORBA_char *host;
+	CORBA_unsigned_short port;
+	CORBA_sequence_octet object_key;
+	CORBA_sequence_TaggedComponent components;
+} IIOP_ProfileBody_1_1;
+
+#endif /* !_ORBIT_IOP_H_ */
diff -urN linux-2.4.1/net/korbit/orb/ir.c linux-2.4.1-korbit/net/korbit/orb/ir.c
--- linux-2.4.1/net/korbit/orb/ir.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/ir.c	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,293 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+
+#include "orbit.h"
+
+/* FIXME: Right now this function doesn't record whether or not it has
+   already visited a given TypeCode.  I'm not sure if every recursive
+   type will have a tk_recursive node in it; if not, then this will
+   need to be reworked a bit.  */
+CORBA_boolean CORBA_TypeCode_equal(CORBA_TypeCode obj, CORBA_TypeCode tc, CORBA_Environment *ev)
+{
+	int i;
+
+	g_return_val_if_fail(obj!=NULL, CORBA_FALSE);
+	g_return_val_if_fail(tc!=NULL, CORBA_FALSE);
+
+	if (obj->kind != tc->kind) {
+		return CORBA_FALSE;
+	}
+
+	switch (obj->kind) {
+	case CORBA_tk_wstring:
+	case CORBA_tk_string:
+		return obj->length == tc->length;
+	case CORBA_tk_objref:
+		return ! strcmp (obj->repo_id, tc->repo_id);
+	case CORBA_tk_except:
+	case CORBA_tk_struct:
+		if (strcmp (obj->repo_id, tc->repo_id)
+		    || obj->sub_parts != tc->sub_parts)
+			return CORBA_FALSE;
+		for (i = 0; i < obj->sub_parts; ++i)
+			if (! CORBA_TypeCode_equal (obj->subtypes[i],
+						    tc->subtypes[i], ev))
+				return CORBA_FALSE;
+		break;
+	case CORBA_tk_union:
+		if (strcmp (obj->repo_id, tc->repo_id)
+		    || obj->sub_parts != tc->sub_parts
+		    || ! CORBA_TypeCode_equal (obj->discriminator,
+					       tc->discriminator, ev)
+		    || obj->default_index != tc->default_index)
+			return CORBA_FALSE;
+		for (i = 0; i < obj->sub_parts; ++i)
+
+			if (! CORBA_TypeCode_equal (obj->subtypes[i],
+						    tc->subtypes[i], ev)
+			    || ! ORBit_any_equivalent (obj->sublabels[i],
+						       tc->sublabels[i], ev))
+				return CORBA_FALSE;
+
+		break;
+	case CORBA_tk_enum:
+		if (obj->sub_parts != tc->sub_parts
+		    || strcmp (obj->repo_id, tc->repo_id))
+			return CORBA_FALSE;
+		for (i = 0; i < obj->sub_parts; ++i)
+			if (strcmp (obj->subnames[i], tc->subnames[i]))
+				return CORBA_FALSE;
+		break;
+	case CORBA_tk_sequence:
+	case CORBA_tk_array:
+		if (obj->length != tc->length)
+			return CORBA_FALSE;
+		g_assert (obj->sub_parts == 1);
+		g_assert (tc->sub_parts == 1);
+		return CORBA_TypeCode_equal (obj->subtypes[0], tc->subtypes[0],
+					     ev);
+	case CORBA_tk_alias:
+		if (strcmp (obj->repo_id, tc->repo_id))
+			return CORBA_FALSE;
+		
+		g_assert (obj->sub_parts == 1);
+		g_assert (tc->sub_parts == 1);
+
+		return CORBA_TypeCode_equal (obj->subtypes[0], tc->subtypes[0],
+					       ev);
+		break;
+	case CORBA_tk_recursive:
+		return obj->recurse_depth == tc->recurse_depth;
+	case CORBA_tk_fixed:
+		return obj->digits == tc->digits && obj->scale == tc->scale;
+
+	default:
+		/* Everything else is primitive.  */
+		break;
+	}
+
+	return CORBA_TRUE;
+}
+
+CORBA_TCKind CORBA_TypeCode_kind(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	return obj->kind;
+}
+
+static void bad_kind (CORBA_Environment *ev)
+{
+	CORBA_TypeCode_BadKind *err;
+	err = g_new (CORBA_TypeCode_BadKind, 1);
+	if (err == NULL) {
+		CORBA_exception_set_system (ev, ex_CORBA_NO_MEMORY,
+					    CORBA_COMPLETED_NO);
+	} else {
+		err->dummy = 23;
+		CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
+				     "IDL:omg.org/CORBA/TypeCode/BadKind/1.0",
+				     err);
+	}
+}
+
+CORBA_RepositoryId CORBA_TypeCode_id(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (! (obj->kind == CORBA_tk_objref || obj->kind == CORBA_tk_struct
+	       || obj->kind == CORBA_tk_enum || obj->kind == CORBA_tk_alias
+	       || obj->kind == CORBA_tk_except)) {
+		bad_kind (ev);
+		return NULL;
+	}
+	return obj->repo_id;
+}
+
+CORBA_Identifier CORBA_TypeCode_name(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (! (obj->kind == CORBA_tk_objref || obj->kind == CORBA_tk_struct
+	       || obj->kind == CORBA_tk_enum || obj->kind == CORBA_tk_alias
+	       || obj->kind == CORBA_tk_except)) {
+		bad_kind (ev);
+		return NULL;
+	}
+
+	return obj->name;
+}
+
+CORBA_unsigned_long CORBA_TypeCode_member_count(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (! (obj->kind == CORBA_tk_struct || obj->kind == CORBA_tk_union
+	       || obj->kind == CORBA_tk_enum)) {
+		bad_kind (ev);
+		return 0;
+	}
+	return obj->sub_parts;
+}
+
+static void bounds_error (CORBA_Environment *ev)
+{
+	CORBA_TypeCode_Bounds *err;
+	err = g_new (CORBA_TypeCode_Bounds, 1);
+	if (err == NULL) {
+		CORBA_exception_set_system (ev, ex_CORBA_NO_MEMORY,
+					    CORBA_COMPLETED_NO);
+	} else {
+		err->dummy = 23;
+		CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
+				     "IDL:omg.org/CORBA/TypeCode/Bounds/1.0",
+				     err);
+	}
+}
+
+CORBA_Identifier CORBA_TypeCode_member_name(CORBA_TypeCode obj, CORBA_unsigned_long index, CORBA_Environment *ev)
+{
+	if (! (obj->kind == CORBA_tk_struct || obj->kind == CORBA_tk_union
+	       || obj->kind == CORBA_tk_enum)) {
+		bad_kind (ev);
+		return NULL;
+	}
+	if (index > obj->sub_parts) {
+		bounds_error (ev);
+		return NULL;
+	}
+	return obj->subnames[index];
+}
+
+CORBA_TypeCode CORBA_TypeCode_member_type(CORBA_TypeCode obj, CORBA_unsigned_long index, CORBA_Environment *ev)
+{
+	if (! (obj->kind == CORBA_tk_struct || obj->kind == CORBA_tk_union
+	       || obj->kind == CORBA_tk_enum)) {
+		bad_kind (ev);
+		return NULL;
+	}
+	if (index > obj->sub_parts) {
+		bounds_error (ev);
+		return NULL;
+	}
+	return obj->subtypes[index];
+}
+
+CORBA_any *CORBA_TypeCode_member_label(CORBA_TypeCode obj, CORBA_unsigned_long index, CORBA_Environment *ev)
+{
+	if (obj->kind != CORBA_tk_union) {
+		bad_kind (ev);
+		return NULL;
+	}
+	if (index > obj->sub_parts) {
+		bounds_error (ev);
+		return NULL;
+	}
+	return &obj->sublabels[index];
+}
+
+CORBA_TypeCode CORBA_TypeCode_discriminator_type(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (obj->kind != CORBA_tk_union) {
+		bad_kind (ev);
+		return NULL;
+	}
+	return obj->discriminator;
+}
+
+CORBA_long CORBA_TypeCode_default_index(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (obj->kind != CORBA_tk_union) {
+		bad_kind (ev);
+		return 0;
+	}
+	return obj->default_index;
+}
+
+CORBA_unsigned_long CORBA_TypeCode_length(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (! (obj->kind == CORBA_tk_string || obj->kind == CORBA_tk_wstring
+	       || obj->kind == CORBA_tk_array)) {
+		bad_kind (ev);
+		return 0;
+	}
+	return obj->length;
+}
+
+CORBA_TypeCode CORBA_TypeCode_content_type(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (! (obj->kind == CORBA_tk_sequence || obj->kind == CORBA_tk_array
+	       || obj->kind == CORBA_tk_alias)) {
+		bad_kind (ev);
+		return NULL;
+	}
+	g_assert (obj->sub_parts == 1);
+	return obj->subtypes[0];
+}
+
+CORBA_unsigned_short CORBA_TypeCode_fixed_digits(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (obj->kind != CORBA_tk_fixed) {
+		bad_kind (ev);
+		return 0;
+	}
+	return obj->digits;
+}
+
+CORBA_short CORBA_TypeCode_fixed_scale(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	if (obj->kind != CORBA_tk_fixed) {
+		bad_kind (ev);
+		return 0;
+	}
+	return obj->scale;
+}
+
+CORBA_long CORBA_TypeCode_param_count(CORBA_TypeCode obj, CORBA_Environment *ev)
+{
+	g_assert(!"Deprecated");
+	return(0);
+}
+
+CORBA_any *CORBA_TypeCode_parameter(CORBA_TypeCode obj, CORBA_long index, CORBA_Environment *ev)
+{
+	g_assert(!"Deprecated");
+	return(NULL);
+}
diff -urN linux-2.4.1/net/korbit/orb/ir.h linux-2.4.1-korbit/net/korbit/orb/ir.h
--- linux-2.4.1/net/korbit/orb/ir.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/ir.h	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,100 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_IR_H_
+#define _ORBIT_IR_H_
+
+#include "orbit_types.h"
+
+extern CORBA_boolean CORBA_TypeCode_equal(
+	CORBA_TypeCode obj,
+	CORBA_TypeCode tc,
+	CORBA_Environment *ev);
+
+extern CORBA_TCKind CORBA_TypeCode_kind(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_RepositoryId CORBA_TypeCode_id(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_Identifier CORBA_TypeCode_name(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_unsigned_long CORBA_TypeCode_member_count(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_Identifier CORBA_TypeCode_member_name(
+	CORBA_TypeCode obj,
+	CORBA_unsigned_long index,
+	CORBA_Environment *ev);
+
+extern CORBA_TypeCode CORBA_TypeCode_member_type(
+	CORBA_TypeCode obj,
+	CORBA_unsigned_long index,
+	CORBA_Environment *ev);
+
+extern CORBA_any *CORBA_TypeCode_member_label(
+	CORBA_TypeCode obj,
+	CORBA_unsigned_long index,
+	CORBA_Environment *ev);
+
+extern CORBA_TypeCode CORBA_TypeCode_discriminator_type(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_long CORBA_TypeCode_default_index(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_unsigned_long CORBA_TypeCode_length(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_TypeCode CORBA_TypeCode_content_type(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_unsigned_short CORBA_TypeCode_fixed_digits(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_short CORBA_TypeCode_fixed_scale(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_long CORBA_TypeCode_param_count(
+	CORBA_TypeCode obj,
+	CORBA_Environment *ev);
+
+extern CORBA_any *CORBA_TypeCode_parameter(
+	CORBA_TypeCode obj,
+	CORBA_long index,
+	CORBA_Environment *ev);
+
+#endif /* !_ORBIT_IR_H_ */
diff -urN linux-2.4.1/net/korbit/orb/options.c linux-2.4.1-korbit/net/korbit/orb/options.c
--- linux-2.4.1/net/korbit/orb/options.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/options.c	Thu Feb  1 11:47:12 2001
@@ -0,0 +1,160 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+/*
+ * Option parsing
+ *
+ * All ORB options are stripped from the application's argv, and argc is
+ * adjusted accordingly
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+
+#include "options.h"
+
+#ifndef __KORBIT__
+void ORBit_option_set(ORBit_orb_options *option, const char *val)
+{
+	g_assert(option!=NULL);
+
+	if(option->type==no_arg && option->arg!=NULL) {
+		/* Treat as an int arg with val=1
+		*/
+		int *int_arg=(int *)option->arg;
+
+		*int_arg=1;
+	} else {
+		if(option->type==string_arg && option->arg!=NULL) {
+			char **str_arg=(char **)option->arg;
+
+			/* free any existing value */
+			if(*str_arg!=NULL) {
+				g_free(*str_arg);
+			}
+			*str_arg=g_strdup(val);
+		} else if(option->type==int_arg && option->arg!=NULL) {
+			int *int_arg=(int *)option->arg;
+
+			*int_arg=atoi(val);
+		}
+
+	}
+}
+
+void ORBit_option_parse(int *argc, char **argv, ORBit_orb_options *options)
+{
+	int i,j,numargs;
+	char name[1024], *val;
+	ORBit_orb_options *search=NULL;
+	int *erase;
+
+	numargs=*argc;
+
+	erase=g_new0(int, *argc);
+
+	for(i=1; i< *argc; i++) {
+		if(argv[i][0]!='-') {
+			if(search==NULL) {
+				/* Skip non-option */
+				continue;
+			} else {
+				/* an required option value has been found */
+				erase[i]=1;
+				numargs-=1;
+
+				if(search->arg==NULL) {
+					/* dont store any values, just strip
+					 * the argv
+					 */
+					search=NULL;
+					continue;
+				}
+
+				ORBit_option_set(search, argv[i]);
+
+				search=NULL;
+				continue;
+			}
+		} else {
+			if(search!=NULL &&
+			  (search->type==string_arg || search->type==int_arg)) {
+				fprintf(stderr, "Option %s requires an argument\n", search->name);
+			}
+		}
+
+		val=argv[i];
+		while(*val && *val=='-')
+			val++;
+
+		strncpy(name,val,1023);
+		name[1023]='\0';
+
+		val=strchr(name, '=');
+		if(val!=NULL) {
+			*val++='\0';
+		}
+
+		for(search=options;search->name!=NULL;search++) {
+			if(!strcmp(name, search->name)) {
+				break;
+			}
+		}
+
+		if(search->name==NULL) {
+			/* Didn't find it in our list of interesting options */
+			search=NULL;
+		} else {
+			/* Found it */
+			erase[i]=1;
+			numargs-=1;
+
+			if(search->type==no_arg || val!=NULL) {
+				ORBit_option_set(search, val);
+				search=NULL;
+			}
+		}
+	}
+
+	j=1;
+	for(i=1; i< *argc; i++) {
+		if(erase[i]==1) {
+			continue;
+		} else {
+			if(j<numargs) {
+				argv[j++]=argv[i];
+			} else {
+				argv[j++]='\0';
+			}
+		}
+	}
+
+	*argc=numargs;
+
+	g_free(erase);
+}
+#endif /* !__KORBIT__ */
diff -urN linux-2.4.1/net/korbit/orb/options.h linux-2.4.1-korbit/net/korbit/orb/options.h
--- linux-2.4.1/net/korbit/orb/options.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/options.h	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,46 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_OPTIONS_H_
+#define _ORBIT_OPTIONS_H_
+
+typedef enum {
+	no_arg=0,
+	string_arg,
+	int_arg
+} ORBit_opt_type;
+
+typedef struct {
+	char *name;
+	ORBit_opt_type type;
+	void *arg;
+} ORBit_orb_options;
+
+#ifndef __KORBIT__
+extern void ORBit_option_set(ORBit_orb_options *found, const char *val);
+extern void ORBit_option_parse(int *argc, char **argv, ORBit_orb_options *options);
+#endif
+
+#endif /* !_ORBIT_OPTIONS_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orb.c linux-2.4.1-korbit/net/korbit/orb/orb.c
--- linux-2.4.1/net/korbit/orb/orb.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orb.c	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,1700 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@acm.org>
+ *          Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+#define o_return_val_if_fail(expr, val) if(!(expr)) { CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM, CORBA_COMPLETED_NO); return (val); }
+#define o_return_if_fail(expr) if(!(expr)) { CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM, CORBA_COMPLETED_NO); return; }
+
+#include "config.h"
+
+#include <unistd.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <pwd.h>
+#include <time.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <utime.h>
+
+#include "../IIOP/iiop-endianP.h"
+#include "orbit.h"
+
+#include "orbit_poa.h"
+#include "orbit_object.h"
+#include "orbit_object_type.h"
+
+#ifndef __KERNEL__
+#define freeca(ptr)
+#endif
+
+#ifndef SUN_LEN
+/* This system is not POSIX.1g.  */
+#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path)  \
+                      + strlen ((ptr)->sun_path))
+#endif
+
+static void ORBit_ORB_release(CORBA_ORB orb, CORBA_Environment *ev);
+
+static const ORBit_RootObject_Interface CORBA_ORB_epv =
+{
+	(void (*)(gpointer, CORBA_Environment *))ORBit_ORB_release
+};
+
+
+static int ORBit_ORBid_setup(CORBA_ORB orb, CORBA_ORBid id)
+{
+	g_assert(orb!=NULL);
+	g_assert(id!=NULL);
+
+	if(strcmp(id, "orbit-local-orb")) {
+#ifdef __KORBIT__
+		printf("ORBit_ORBid_setup: Unknown ORB id: %s\n", id);
+#else
+		fprintf(stderr, "ORBit_ORBid_setup: Unknown ORB id: %s\n", id);
+#endif
+		return(0);
+	}
+
+	orb->orb_identifier=g_strdup(id);
+
+	return(1);
+}
+
+#ifndef __KORBIT__
+static gboolean
+free_key_and_data(gpointer key, gpointer data, gpointer user_data)
+{
+	g_free(key); g_free(data);
+
+	return TRUE;
+}
+
+static void ORBit_rc_load(const char *rcfile, ORBit_orb_options *options)
+{
+	FILE *fp;
+	GHashTable *read_options;
+	ORBit_orb_options *search;
+
+	fp=fopen(rcfile, "r");
+
+	if(fp==NULL)
+		return;
+
+	read_options=g_hash_table_new(g_str_hash, g_str_equal);
+
+	while(!feof(fp)) {
+		char buf[1024];
+
+		if(fgets(buf, 1024, fp)!=NULL) {
+			guchar *bptr, *tmp, *key, *data;
+			size_t start, len;
+
+			if(buf[0]=='#')
+				continue;
+			
+			bptr=buf;
+			tmp=strpbrk(bptr, " \t\n=");
+			if(tmp==NULL) continue;
+			*tmp++='\0';
+			key=g_strdup(bptr);
+			bptr=tmp;
+
+			start=0;
+			while(bptr+start != '\0' &&
+			     (isspace(bptr[start]) || bptr[start]=='='))
+				start++;
+			len=strcspn(bptr+start, " \t\n");
+			bptr[start+len]='\0';
+			if(len>0) {
+				data=g_strdup(bptr+start);
+			} else {
+				data=g_strdup("TRUE");
+			}
+
+			g_hash_table_insert(read_options, key, data);
+		}
+	}
+	fclose(fp);
+
+	for(search=options;search->name!=NULL;search++) {
+		char *read_val;
+
+		read_val=g_hash_table_lookup(read_options, search->name);
+		if(read_val!=NULL) {
+			ORBit_option_set(search, read_val);
+		}
+	}
+
+	g_hash_table_foreach_remove(read_options, free_key_and_data, NULL);
+	g_hash_table_destroy(read_options);
+}
+#endif /* !__KORBIT__ */
+
+static void ORBit_ORB_release(CORBA_ORB orb, CORBA_Environment *ev) 
+{
+	g_assert(orb!=NULL);
+
+	if(--(ORBIT_ROOT_OBJECT(orb)->refs))
+		return;
+
+	if(orb->orb_identifier!=NULL) {
+		g_free(orb->orb_identifier);
+	}
+	if(!CORBA_Object_is_nil(orb->imr, ev)) {
+		CORBA_Object_release(orb->imr, ev); 
+	}
+	if(!CORBA_Object_is_nil(orb->ir, ev)) {
+		CORBA_Object_release(orb->ir, ev); 
+	}
+	if(!CORBA_Object_is_nil(orb->naming, ev)) {
+		CORBA_Object_release(orb->naming, ev);
+	}
+	if(!CORBA_Object_is_nil(orb->root_poa, ev)) {
+		CORBA_Object_release(orb->root_poa, ev);
+	}
+	if(orb->cnx.ipv4)
+		giop_connection_unref(orb->cnx.ipv4);
+	if(orb->cnx.ipv6)
+		giop_connection_unref(orb->cnx.ipv6);
+#ifndef __KORBIT__
+	if(orb->cnx.usock)
+		giop_connection_unref(orb->cnx.usock);
+#endif
+
+	g_free(orb);
+}
+
+#ifndef __KORBIT__
+static GIOPConnection*
+ORBit_ORB_make_usock_connection(void)
+{
+	GIOPConnection *retval = NULL;
+	GString *tmpstr;
+	struct stat statbuf;
+
+	tmpstr = g_string_new(NULL);
+
+	g_string_sprintf(tmpstr, "/tmp/orbit-%s", g_get_user_name());
+		
+	if(mkdir(tmpstr->str, 0700) != 0) {
+		int e = errno;
+			
+		switch (e) {
+		case 0:
+		case EEXIST:
+			if (stat(tmpstr->str, &statbuf) != 0)
+				g_error ("Can not stat %s\n", tmpstr->str);
+
+			if (statbuf.st_uid != getuid ())
+				g_error ("Owner of %s is not the current user\n",
+					 tmpstr->str);
+
+			if((statbuf.st_mode & (S_IRWXG|S_IRWXO))
+			   || !S_ISDIR(statbuf.st_mode))
+				g_error ("Wrong permissions for %s\n",
+					 tmpstr->str);
+			break;
+				
+		default:
+			g_error("Unknown error on directory creation of %s (%s)\n",
+				tmpstr->str, g_strerror (e));
+		}
+	}
+
+	{
+		struct utimbuf utb;
+		memset(&utb, 0, sizeof(utb));
+		utime(tmpstr->str, &utb);
+	}
+
+
+#ifdef WE_DONT_CARE_ABOUT_STUPID_2DOT0DOTX_KERNELS
+	g_string_sprintf(tmpstr, "/tmp/orbit-%s",
+			 g_get_user_name());
+	dirh = opendir(tmpstr->str);
+	while(!retval && (dent = readdir(dirh))) {
+		int usfd, ret;
+		struct sockaddr_un saddr;
+
+		saddr.sun_family = AF_UNIX;
+
+		if(strncmp(dent->d_name, "orb-", 4))
+			continue;
+
+		g_snprintf(saddr.sun_path, sizeof(saddr.sun_path),
+			   "/tmp/orbit-%s/%s",
+			   g_get_user_name(), dent->d_name);
+
+		usfd = socket(AF_UNIX, SOCK_STREAM, 0);
+		g_assert(usfd >= 0);
+
+		ret = connect(usfd, &saddr, SUN_LEN(&saddr));
+		close(usfd);
+
+		if(ret >= 0)
+			continue;
+
+		unlink(saddr.sun_path);
+	}
+	closedir(dirh);
+#endif /* WE_DONT_CARE_ABOUT_STUPID_2DOT0DOTX_KERNELS */
+
+	srand(time(NULL));
+	while(!retval) {
+		g_string_sprintf(tmpstr, "/tmp/orbit-%s/orb-%d%d",
+				 g_get_user_name(), rand(), rand());
+		retval =
+			GIOP_CONNECTION(iiop_connection_server_unix(tmpstr->str));
+	}
+
+	g_string_free(tmpstr, TRUE);
+
+	return retval;
+}
+#endif /* !__KORBIT__ */
+
+
+// Synchronize between the user process starting up the orb and the ORB thread
+// this mutex gets released when the orb is all fired up and ready to go.
+static DECLARE_MUTEX(StartupSem);
+static CORBA_ORB TheOneTrueOrb = 0;
+
+struct CORBA_ORB_init_args {  // A pointer to this struct is passed to
+	int *argc;            // __CORBA_ORB_init
+	char **argv;
+	CORBA_ORBid orb_identifier;
+	CORBA_Environment *ev;
+};
+
+
+CORBA_ORB __CORBA_ORB_init(struct CORBA_ORB_init_args *Args) {
+	int *argc = Args->argc;
+	char **argv = Args->argv;
+	CORBA_ORBid orb_identifier = Args->orb_identifier;
+	CORBA_Environment *ev = Args->ev;
+
+	int no_iiop_server=0;
+	int no_iiop_proxy=0;
+#ifdef __KORBIT__
+	int use_ipv4=1;
+#else
+	int use_ipv4=0;
+#endif
+	int use_ipv6=0;
+	int use_usock=1;
+	int debug_level=0;
+	int debug_modules=0;
+	int nosysrc=0;
+	int nouserrc=0;
+	char *imr_ior=NULL, *imr_addr=NULL;
+	char *ir_ior=NULL, *ir_addr=NULL;
+	char *naming_ior=NULL, *naming_addr=NULL;
+	char *root_poa_ior=NULL, *root_poa_addr=NULL;
+	char *orb_id_opt=NULL;
+#ifndef __KORBIT__
+	char *ctmp;
+#endif
+	CORBA_ORB orb = 0;
+
+	/* The variable addresses in these structs need to be assigned at
+	 * run-time if you want to compile with -pedantic
+	 *
+	 * (You will also get scads of warnings about "long long" too)
+	 */
+
+	ORBit_orb_options pre_rc_options[]={
+		{"ORBNoSystemRC", no_arg, NULL},
+		{"ORBNoUserRC", no_arg, NULL},
+		{NULL, 0, NULL},
+	};
+
+	/* These options are compatible with MICO */
+	ORBit_orb_options options[]={
+		{"ORBNoIIOPServer", no_arg, NULL},
+		{"ORBNoIIOPProxy", no_arg, NULL},
+		{"ORBid", string_arg, NULL},
+		{"ORBImplRepoIOR", string_arg, NULL},
+		{"ORBImplRepoAddr", string_arg, NULL},
+		{"ORBIfaceRepoIOR", string_arg, NULL},
+		{"ORBIfaceRepoAddr", string_arg, NULL},
+		{"ORBNamingIOR", string_arg, NULL},
+		{"ORBNamingAddr", string_arg, NULL},
+		{"ORBDebugLevel", int_arg, NULL},
+		{"ORBBindAddr", string_arg, NULL}, /* XXX need to make
+						      libIIOP support this */
+		{"ORBIIOPAddr", string_arg, NULL},
+
+	/* These options aren't */
+		{"ORBDebugModules", int_arg, NULL},
+		{"ORBRootPOAIOR", string_arg, NULL},
+		{"ORBRootPOAAddr", string_arg, NULL},
+		{"ORBIIOPUSock", int_arg, NULL},
+		{"ORBIIOPIPv4", int_arg, NULL},
+		{"ORBIIOPIPv6", int_arg, NULL},
+		{NULL,0,NULL},
+	};
+
+	if (ev == NULL || !argc || !argv || !orb_identifier) {
+		if (ev) {
+			CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM, 
+						   CORBA_COMPLETED_NO);
+		}
+		up(&StartupSem);   // Okay, let the insmod thread continue...
+		return 0;
+	}
+
+	pre_rc_options[0].arg = (void *) &nosysrc;
+	pre_rc_options[1].arg = (void *) &nouserrc;
+	options[0].arg = (void *) &no_iiop_server;
+	options[1].arg = (void *) &no_iiop_proxy;
+	options[2].arg = (void *) &orb_id_opt;
+	options[3].arg = (void *) &imr_ior;
+	options[4].arg = (void *) &imr_addr;
+	options[5].arg = (void *) &ir_ior;
+	options[6].arg = (void *) &ir_addr;
+	options[7].arg = (void *) &naming_ior;
+	options[8].arg = (void *) &naming_addr;
+	options[9].arg = (void *) &debug_level;
+	options[12].arg = (void *) &debug_modules;
+	options[13].arg = (void *) &root_poa_ior;
+	options[14].arg = (void *) &root_poa_addr;
+	options[15].arg = (void *) &use_usock;
+	options[16].arg = (void *) &use_ipv4;
+	options[17].arg = (void *) &use_ipv6;
+
+#ifndef __KORBIT__
+	ORBit_option_parse(argc, argv, pre_rc_options);
+
+	if(!nosysrc) {
+		ORBit_rc_load(ORBit_SYSRC, options);
+	}
+
+	if(!nouserrc) {
+		char *buf;
+
+		ctmp = g_get_home_dir();
+
+		buf = alloca(strlen(ctmp) + sizeof("/.orbitrc"));
+		sprintf(buf, "%s/.orbitrc", ctmp);
+		ORBit_rc_load(buf, options);
+		freeca(buf);
+	}
+
+	ORBit_option_parse(argc, argv, options);
+#endif /* !__KORBIT__ */
+
+	ORBit_Trace_setLevel(debug_level);
+	ORBit_Trace_setModules(debug_modules);
+
+	CORBA_exception_init(ev);
+
+	ORBit_chunks_init();
+
+	giop_init(argv[0]);
+
+	orb=g_new0(struct CORBA_ORB_type, 1);
+
+	if(orb==NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+		goto error;
+	}
+
+	ORBit_pseudo_object_init(ORBIT_PSEUDO_OBJECT(orb), ORBIT_PSEUDO_ORB, ev);
+
+	ORBit_RootObject_set_interface(ORBIT_ROOT_OBJECT(orb),
+				       (gpointer)&CORBA_ORB_epv, ev);
+
+	ORBIT_ROOT_OBJECT(orb)->refs = 1;
+
+	if(orb_id_opt!=NULL) {
+		if(!ORBit_ORBid_setup(orb, orb_id_opt))
+			goto error;
+		g_free(orb_id_opt);
+	} else if(orb_identifier!=NULL) {
+		if(!ORBit_ORBid_setup(orb, orb_identifier))
+			goto error;
+	} else {
+		orb->orb_identifier=g_strdup("orbit-local-orb");
+	}
+
+	if(orb->orb_identifier==NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+		goto error;
+	}
+
+	if(use_ipv4) {
+		orb->cnx.ipv4 = GIOP_CONNECTION(iiop_connection_server());
+
+		giop_connection_ref(orb->cnx.ipv4);
+		GIOP_CONNECTION(orb->cnx.ipv4)->orb_data = orb;
+	}
+
+	if(use_ipv6) {
+		orb->cnx.ipv6 = GIOP_CONNECTION(iiop_connection_server_ipv6());
+		giop_connection_ref(orb->cnx.ipv6);
+		GIOP_CONNECTION(orb->cnx.ipv6)->orb_data = orb;
+	}
+
+#ifndef __KORBIT__
+	if(use_usock) {
+		orb->cnx.usock = ORBit_ORB_make_usock_connection();
+
+		giop_connection_ref(orb->cnx.usock);
+		GIOP_CONNECTION(orb->cnx.usock)->orb_data = orb;
+	}
+#endif
+
+	orb->objrefs = g_hash_table_new((GHashFunc)g_CORBA_Object_hash,
+					(GCompareFunc)g_CORBA_Object_equal);
+	orb->poas = g_ptr_array_new();
+
+	/* when I figure out what MICO is doing with the iiop_proxy and
+	 * iiop_server stuff, it'll get handled here.
+	 */
+
+	/*
+	 * Connect to / create implementation repository
+	 */
+
+	{
+		CORBA_Object imr=NULL;
+
+		if(imr_ior!=NULL) {
+			imr=CORBA_ORB_string_to_object(orb, imr_ior, ev);
+			g_free(imr_ior);
+		} else if(imr_addr!=NULL) {
+			/*imr=CORBA_ORB_bind(orb, "IDL:omg.org/CORBA/ImplRepository:1.0", imr_addr, ev);*/
+			g_free(imr_addr);
+		}
+
+		if(!CORBA_Object_is_nil(imr, ev)) {
+			CORBA_ORB_set_initial_reference(orb, "ImplementationRepository", imr, ev);
+		}
+	}
+
+	/*
+	 * Connect to / create interface repository
+	 */
+
+	{
+		CORBA_Object ir=NULL;
+
+		if(ir_ior!=NULL) {
+			ir=CORBA_ORB_string_to_object(orb, ir_ior, ev);
+			g_free(ir_ior);
+		} else if(ir_addr!=NULL) {
+			/*ir=CORBA_ORB_bind(orb, "IDL:omg.org/CORBA/Repository:1.0", ir_addr, ev);*/
+			g_free(ir_addr);
+		}
+
+		if(!CORBA_Object_is_nil(ir, ev)) {
+			CORBA_ORB_set_initial_reference(orb, "InterfaceRepository", ir, ev);
+		}
+	}
+
+	/*
+	 * Connect to naming service
+	 */
+
+	{
+		CORBA_Object naming=NULL;
+
+		if(naming_ior!=NULL) {
+			naming=CORBA_ORB_string_to_object(orb, naming_ior, ev);
+			g_free(naming_ior);
+		} else if(naming_addr!=NULL) {
+			/*CORBA_ORB_ObjectTag tag=CORBA_ORB_string_to_tag(orb, "root", ev);*/
+
+			/*naming=CORBA_ORB_bind_tag(orb, "IDL:omg.org/CosNaming/NamingContext:1.0", tag, naming_addr, ev);*/
+			g_free(naming_addr);
+		}
+
+		if(!CORBA_Object_is_nil(naming, ev)) {
+			CORBA_ORB_set_initial_reference(orb, "NameService", naming, ev);
+		}
+	}
+
+	/*
+	 * Connect to / create RootPOA
+	 */
+
+	{
+		PortableServer_POA root_poa=CORBA_OBJECT_NIL;
+	  
+		if(root_poa_ior!=NULL) {
+			root_poa=(PortableServer_POA)
+				CORBA_ORB_string_to_object(orb,
+							   root_poa_ior, ev);
+			g_free(root_poa_ior);
+		}
+		       
+		/* And attatch it to the orb */
+
+		if(!CORBA_Object_is_nil((CORBA_Object)root_poa, ev)) {
+			CORBA_ORB_set_initial_reference((CORBA_ORB)orb,
+							"RootPOA",
+							(CORBA_Object)root_poa,
+							ev);
+		}
+	}
+
+	ORBit_custom_run_setup(orb, ev);
+
+	if (!strcmp("server", argv[0]))  // Only do this for servers.
+		TheOneTrueOrb = orb;
+	up(&StartupSem);   // Okay, let the insmod thread continue...
+	return orb;
+
+error:
+	if(orb!=NULL) {
+		ORBit_ORB_release(orb, ev);
+		orb = NULL;
+	}
+	g_free(imr_ior);
+	g_free(imr_addr);
+	g_free(ir_ior);
+	g_free(ir_addr);
+	g_free(naming_ior);
+	g_free(naming_addr);
+	g_free(root_poa_ior);
+	g_free(root_poa_addr);
+	g_free(orb_id_opt);
+
+	TheOneTrueOrb = 0;
+	up(&StartupSem);   // Okay, let the insmod thread continue...
+	return 0;
+}
+
+
+#if __KERNEL__
+#include <linux/smp_lock.h>
+#include <linux/proc_fs.h>
+
+// This is the main corba thread function...
+//
+void __CORBA_ORB_run(CORBA_ORB orb, CORBA_Environment *ev);
+int MainCORBAThread(void *Args) {
+	// Make a directory in /proc... yaay...
+	proc_mkdir("corba", 0);
+
+	__CORBA_ORB_init((struct CORBA_ORB_init_args*)Args);
+	if (TheOneTrueOrb == 0) return 0;
+
+	strcpy(current->comm, "korbit"); // Set the thread name...
+
+	lock_kernel();   /* This seems to be required for exit_mm */
+	exit_mm(current);
+
+	__CORBA_ORB_run(TheOneTrueOrb, 
+			((struct CORBA_ORB_init_args*)Args)->ev);
+	return 0;
+}
+#endif
+
+
+/* Section 4.4
+ *
+ * Adjusts argc and argv appropriately
+ */
+
+CORBA_ORB CORBA_ORB_init(int *argc, char **argv, CORBA_ORBid orb_identifier, 
+			 CORBA_Environment *ev) {
+
+	struct CORBA_ORB_init_args Args;
+	Args.argc = argc;
+	Args.argv = argv;
+	Args.orb_identifier = orb_identifier;
+	Args.ev = ev;
+
+#ifdef __KERNEL__
+	if (!strcmp(argv[0], "server")) {             // Are we a server?
+		down(&StartupSem);  // Grab the semaphore...
+		if (TheOneTrueOrb) {
+			CORBA_exception_init(ev);
+			goto out_success;
+		}
+
+		// This releases the semaphore when it is done initializing.
+		(void)kernel_thread(MainCORBAThread, &Args, 
+				    CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
+
+		// This will block until the semaphore is released by the 
+		// ORB thread.
+		down(&StartupSem);
+	} else {       // If we are a corba client, like CorbaFS...
+		return __CORBA_ORB_init(&Args);
+	}
+
+ out_success:
+	up(&StartupSem);   // Okay, we're now here. 
+#else
+	__CORBA_ORB_init(&Args);
+#endif
+	if (TheOneTrueOrb) 
+		return (CORBA_ORB)CORBA_Object_duplicate((CORBA_Object)TheOneTrueOrb, ev);
+	return 0;
+}
+
+
+
+
+typedef struct {
+	CORBA_Object obj;
+	CDR_Codec *codec;
+	gboolean emit_active;
+} profile_user_data;
+
+static void ORBit_emit_profile(gpointer item, gpointer userdata)
+{
+	ORBit_Object_info *profile=(ORBit_Object_info *)item;
+	profile_user_data *data=(profile_user_data *)userdata;
+	CORBA_Object obj=data->obj;
+	CDR_Codec encaps_codec_d;
+	CDR_Codec *codec=data->codec, *encaps = &encaps_codec_d;
+	gboolean emit_active=data->emit_active;
+	static const CORBA_octet iiopversion[] = {1,0};
+	CORBA_octet codecbuf[2048];
+
+	g_assert(obj!=NULL);
+	g_assert(codec!=NULL);
+	g_assert(profile!=NULL);
+
+	if((profile == obj->active_profile) && (emit_active == FALSE))
+		return;			/* we already did this one */
+
+	switch(profile->profile_type) {
+	case IOP_TAG_INTERNET_IOP:
+		CDR_codec_init_static(encaps);
+		encaps->buffer = codecbuf;
+		encaps->release_buffer = CORBA_FALSE;
+		encaps->buf_len = 2048;
+		encaps->readonly = CORBA_FALSE;
+		encaps->host_endian = encaps->data_endian = FLAG_ENDIANNESS;
+
+		CDR_put_ulong(codec, IOP_TAG_INTERNET_IOP);
+		CDR_put_octet(encaps, FLAG_ENDIANNESS);
+		CDR_put_octets(encaps, (gpointer)iiopversion, sizeof(iiopversion));
+		CDR_put_string(encaps, profile->tag.iopinfo.host);
+		CDR_put_ushort(encaps, profile->tag.iopinfo.port);
+		CDR_put_ulong(encaps, profile->object_key._length);
+		CDR_put_octets(encaps, profile->object_key._buffer,
+			       profile->object_key._length);
+		CDR_put_ulong(codec, encaps->wptr);
+		CDR_put_octets(codec, encaps->buffer, encaps->wptr);
+		break;
+
+	case IOP_TAG_ORBIT_SPECIFIC:
+		CDR_codec_init_static(encaps);
+		encaps->buffer = codecbuf;
+		encaps->release_buffer = CORBA_FALSE;
+		encaps->buf_len = 2048;
+		encaps->readonly = CORBA_FALSE;
+		encaps->host_endian = encaps->data_endian = FLAG_ENDIANNESS;
+
+		CDR_put_ulong(codec, IOP_TAG_ORBIT_SPECIFIC);
+		CDR_put_octet(encaps, FLAG_ENDIANNESS);
+		CDR_put_octets(encaps, (gpointer)iiopversion, sizeof(iiopversion));
+		CDR_put_string(encaps, profile->tag.orbitinfo.unix_sock_path);
+		CDR_put_ushort(encaps, profile->tag.orbitinfo.ipv6_port);
+		CDR_put_ulong(encaps, profile->object_key._length);
+		CDR_put_octets(encaps, profile->object_key._buffer,
+			profile->object_key._length);
+		CDR_put_ulong(codec, encaps->wptr);
+		CDR_put_octets(codec, encaps->buffer, encaps->wptr);
+		break;
+
+	default:
+		g_warning("Skipping tag %d", profile->profile_type);
+		break;
+	}
+}
+
+CORBA_char *CORBA_ORB_object_to_string(CORBA_ORB orb,
+				       CORBA_Object obj,
+				       CORBA_Environment *ev)
+{
+  int i;
+  CDR_Codec codec_d;
+  CDR_Codec *codec = &codec_d;
+  CORBA_char *rc = NULL;
+  CORBA_unsigned_long ntags;
+  profile_user_data data;
+  CORBA_octet codecbuf[2048];
+  char *ctmp;
+
+  g_return_val_if_fail(ev, NULL);
+  o_return_val_if_fail(orb && obj, NULL);
+
+  if(!obj || !orb) {
+	  CORBA_exception_set_system(ev,
+				     ex_CORBA_BAD_PARAM,
+				     CORBA_COMPLETED_NO);
+	  return NULL;
+  }
+
+  if(ORBIT_ROOT_OBJECT(obj)->is_pseudo_object) {
+	  CORBA_exception_set_system(ev,
+				     ex_CORBA_MARSHAL,
+				     CORBA_COMPLETED_NO);
+	  return NULL;
+  }
+
+  CDR_codec_init_static(codec);
+
+  codec->buffer = codecbuf;
+  codec->release_buffer = CORBA_FALSE;
+  codec->buf_len = 2048;
+  codec->readonly = CORBA_FALSE;
+  codec->host_endian = codec->data_endian = FLAG_ENDIANNESS;
+
+  CDR_put_octet(codec, FLAG_ENDIANNESS);
+
+  CDR_put_string(codec, obj->object_id);
+  ntags = g_slist_length(obj->profile_list);
+  CDR_put_ulong(codec, ntags);
+
+  data.obj=obj;
+  data.codec=codec;
+  data.emit_active=TRUE;
+  if(obj->active_profile != NULL)
+	  ORBit_emit_profile(obj->active_profile, &data); /* do this one first */
+
+  data.emit_active=FALSE;
+  g_slist_foreach(obj->profile_list, ORBit_emit_profile, &data);
+
+  rc = CORBA_string_alloc(4 + (codec->wptr * 2) + 1);
+  strcpy(rc, "IOR:");
+
+#define hexdigit(n) (((n)>9)?(n+'a'-10):(n+'0'))
+
+  for(i = 0, ctmp = rc + strlen("IOR:"); i < codec->wptr; i++) {
+	  *(ctmp++) = hexdigit((((codec->buffer[i]) & 0xF0) >> 4));
+	  *(ctmp++) = hexdigit(((codec->buffer[i]) & 0xF));
+  }
+  *ctmp = '\0';
+
+  {
+	  /* Debug check */
+	  CORBA_Object obj;
+	  CORBA_Environment myev;
+
+	  CORBA_exception_init(&myev);
+
+	  obj = CORBA_ORB_string_to_object(orb, rc, &myev);
+
+	  if (CORBA_Object_is_nil(obj, &myev)) {
+		  g_warning("Bug in %s, created bad IOR `%s'\n",
+			    __FUNCTION__, rc);
+		  CORBA_free(rc);
+		  return NULL;
+	  }
+			  
+	  CORBA_Object_release(obj, &myev);
+  }
+  
+  return rc;
+}
+
+/* Quote from the GNU libc manual:
+
+   "If you try to allocate more storage than the machine can provide,
+    you don't get a clean error message. Instead you get a fatal
+    signal like the one you would get from an infinite recursion;
+    probably a segmentation violation (see section Program Error
+    Signals)."
+
+   The man page claims alloca() returns NULL on failure; this appears
+   to be a load of shit on Linux where you just get flaming death, but
+   we check anyway in case other systems work that way.
+
+   On Linux we check that the size is less than MAX_STACK_ALLOC
+
+   Note that the CORBA_alloc() calls in here can still cause
+   program abort, and really that should be fixed in a similar
+   way since our lengths are coming in from unpredictable sources
+   like files or the network.
+*/
+
+#define MAX_STACK_ALLOC 8192
+
+CORBA_Object CORBA_ORB_string_to_object(CORBA_ORB orb, CORBA_char *str,
+					CORBA_Environment *ev)
+{
+	GSList *profiles=NULL;
+	CORBA_Object retval = NULL;
+	CORBA_char *type_id;
+	ORBit_Object_info *object_info;
+	CDR_Codec codec_d, encaps_codec_d;
+	CDR_Codec *codec = &codec_d, *encaps_codec = &encaps_codec_d;
+	CORBA_octet *buffer, endian;
+	int i, j;
+	CORBA_unsigned_long len, seq_len, misclen;
+
+	g_return_val_if_fail(ev, CORBA_OBJECT_NIL);
+	o_return_val_if_fail(orb && str, CORBA_OBJECT_NIL);
+
+	if(strncmp(str, "IOR:", 4)) {
+		CORBA_exception_set_system(ev, ex_CORBA_MARSHAL,
+					   CORBA_COMPLETED_NO);
+		return(CORBA_OBJECT_NIL);
+	}
+
+	CDR_codec_init_static(codec);
+	len = strlen(str);
+
+	if((len % 2) || len <= 4) {
+		CORBA_exception_set_system(ev, ex_CORBA_MARSHAL,
+					   CORBA_COMPLETED_NO);
+		return(CORBA_OBJECT_NIL);
+	}
+
+	codec->buf_len = (len-4)/2;
+	buffer = alloca(codec->buf_len);
+
+	codec->buffer=buffer;
+	codec->release_buffer = CORBA_FALSE;
+	codec->readonly = TRUE;
+
+	for(j = 0, i = 4; i < len; i+=2) {
+		buffer[j++] = HEXOCTET(str[i], str[i+1]);
+	};
+
+	CDR_get_octet(codec, &endian);
+
+	codec->data_endian = endian;
+	codec->host_endian = FLAG_ENDIANNESS;
+
+	CDR_get_string_static(codec, &type_id);
+
+	CDR_get_seq_begin(codec, &seq_len);
+
+	for(i = 0; i < seq_len; i++) {
+		IOP_ProfileId tag;
+
+		object_info=g_new0(ORBit_Object_info, 1);
+
+		if (!CDR_get_ulong(codec, &tag))
+			goto error_out;
+
+		switch(tag) {
+		case IOP_TAG_INTERNET_IOP:
+			if (!CDR_get_ulong(codec, &misclen))
+				goto error_out;
+			
+			CDR_codec_init_static(encaps_codec);
+
+			if (misclen > MAX_STACK_ALLOC)
+				goto error_out;
+			
+			encaps_codec->buffer = alloca(misclen);
+			if (encaps_codec->buffer == NULL)
+				/* misclen was probably junk */
+				goto error_out;
+			
+			encaps_codec->release_buffer = FALSE;
+			if(!CDR_buffer_gets(codec, encaps_codec->buffer, misclen))
+				goto error_out;
+
+			encaps_codec->buf_len = misclen;
+			encaps_codec->readonly = CORBA_TRUE;
+			if(!CDR_get_octet(encaps_codec, &endian))
+				goto error_out;
+			encaps_codec->data_endian = endian;
+			encaps_codec->host_endian = FLAG_ENDIANNESS;
+
+			if (encaps_codec->data_endian > 1)
+				goto error_out;
+			
+			object_info->profile_type = IOP_TAG_INTERNET_IOP;
+			if(!CDR_get_octet(encaps_codec, &object_info->iiop_major))
+				goto error_out;
+			if(object_info->iiop_major != 1)
+				goto error_out;
+			if(!CDR_get_octet(encaps_codec, &object_info->iiop_minor))
+				goto error_out;
+			if(!CDR_get_string(encaps_codec, &object_info->tag.iopinfo.host))
+				goto error_out;
+			if(!CDR_get_ushort(encaps_codec, &object_info->tag.iopinfo.port))
+				goto error_out;
+			if(!CDR_get_seq_begin(encaps_codec, &object_info->object_key._length))
+				goto error_out;
+
+			object_info->object_key._maximum = 0;
+
+			/* The POA gives out ORBit_alloc()d profiles, so we have to too */
+			object_info->object_key._buffer = ORBit_alloc(object_info->object_key._length, NULL, NULL);
+			if(!CDR_buffer_gets(encaps_codec, object_info->object_key._buffer,
+					    object_info->object_key._length))
+				goto error_out;
+
+			ORBit_set_object_key(object_info);
+			profiles=g_slist_append(profiles, object_info);
+			break;
+
+		case IOP_TAG_MULTIPLE_COMPONENTS:
+			/* Just skip any multiple_components data, for now */
+			if(!CDR_get_ulong(codec, &misclen))
+				goto error_out;
+
+			CDR_codec_init_static(encaps_codec);
+
+			if (misclen > MAX_STACK_ALLOC)
+				goto error_out;
+			
+			encaps_codec->buf_len = misclen;
+			encaps_codec->buffer = alloca(misclen);
+			if (encaps_codec->buffer == NULL)
+				/* misclen was probably junk */
+				goto error_out;
+
+			encaps_codec->release_buffer = FALSE;
+			encaps_codec->readonly = CORBA_TRUE;
+			if(!CDR_buffer_gets(codec, encaps_codec->buffer, misclen))
+				goto error_out;
+			break;
+
+		case IOP_TAG_ORBIT_SPECIFIC:
+			if(!CDR_get_ulong(codec, &misclen))
+				goto error_out;
+
+			CDR_codec_init_static(encaps_codec);
+
+			if (misclen > MAX_STACK_ALLOC)
+				goto error_out;
+			
+			encaps_codec->buffer = alloca(misclen);
+			if (encaps_codec->buffer == NULL)
+				/* misclen was probably junk */
+				goto error_out;
+			
+			encaps_codec->release_buffer = FALSE;
+			if(!CDR_buffer_gets(codec, encaps_codec->buffer, misclen))
+				goto error_out;
+
+			encaps_codec->buf_len = misclen;
+			encaps_codec->readonly = CORBA_TRUE;
+
+			if(!CDR_get_octet(encaps_codec, &endian))
+				goto error_out;
+
+			encaps_codec->data_endian = endian;
+			encaps_codec->host_endian = FLAG_ENDIANNESS;
+
+			if (encaps_codec->data_endian > 1)
+				goto error_out;
+			
+			object_info->profile_type=IOP_TAG_ORBIT_SPECIFIC;
+			if(!CDR_get_octet(encaps_codec, &object_info->iiop_major))
+				goto error_out;
+
+			if(object_info->iiop_major != 1)
+				goto error_out;
+			if(!CDR_get_octet(encaps_codec, &object_info->iiop_minor))
+				goto error_out;
+
+			if(!CDR_get_string(encaps_codec, &object_info->tag.orbitinfo.unix_sock_path))
+				goto error_out;
+
+			if(!CDR_get_ushort(encaps_codec, &object_info->tag.orbitinfo.ipv6_port))
+				goto error_out;
+			if(!CDR_get_seq_begin(encaps_codec, &object_info->object_key._length))
+				goto error_out;
+			object_info->object_key._maximum = 0;
+
+			/* The POA gives out ORBit_alloc()d profiles, so we have to too */
+			object_info->object_key._buffer = ORBit_alloc(object_info->object_key._length, NULL, NULL);
+			if(!CDR_buffer_gets(encaps_codec, object_info->object_key._buffer,
+					    object_info->object_key._length))
+				goto error_out;
+
+			ORBit_set_object_key(object_info);
+			profiles=g_slist_append(profiles, object_info);
+			break;
+		default:
+			g_warning("Unknown tag 0x%x", tag);
+
+			/* Skip it */
+			if(!CDR_get_ulong(codec, &misclen))
+				goto error_out;
+
+			CDR_codec_init_static(encaps_codec);
+
+			if (misclen > MAX_STACK_ALLOC)
+				goto error_out;
+			
+			encaps_codec->buf_len = misclen;
+			encaps_codec->buffer = alloca(misclen);
+			if (encaps_codec->buffer == NULL)
+				/* misclen was probably junk */
+				goto error_out;
+
+			encaps_codec->release_buffer = FALSE;
+			encaps_codec->readonly = CORBA_TRUE;
+			if(!CDR_buffer_gets(codec, encaps_codec->buffer, misclen))
+				goto error_out;
+
+			break;
+		}
+	}
+
+	freeca(buffer); /* Same as codec->buffer */
+	freeca(encaps_codec->buffer);
+	
+	return ORBit_create_object_with_info(profiles, type_id, orb, ev);
+
+ error_out:
+
+	if(object_info) {
+		CORBA_free(object_info->object_key._buffer);
+		g_free(object_info);
+		ORBit_delete_profiles(profiles);
+	}
+
+	freeca(buffer); /* Same as codec->buffer */
+	freeca(encaps_codec->buffer);
+
+	return retval;
+}
+
+/* Section 4.1.2 */
+CORBA_boolean CORBA_ORB_get_service_information(CORBA_ORB orb, CORBA_ServiceType service_type, CORBA_ServiceInformation *service_information, CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(CORBA_FALSE);
+}
+
+CORBA_Current *CORBA_ORB_get_current(CORBA_ORB orb, CORBA_Environment *ev)
+{
+	g_return_val_if_fail(ev, NULL);
+	o_return_val_if_fail(orb, NULL);
+
+	/* XXX check this over */
+	return (CORBA_Current *)GET_THREAD_DATA();
+}
+
+/* Section 4.5 */
+CORBA_ORB_ObjectIdList *CORBA_ORB_list_initial_services(CORBA_ORB orb, CORBA_Environment *ev)
+{
+	static const char *services[] = {"RootPOA"};
+	CORBA_ORB_ObjectIdList *list;
+
+	g_return_val_if_fail(ev, NULL);
+	o_return_val_if_fail(orb, NULL);
+
+	list = (CORBA_ORB_ObjectIdList *)CORBA_sequence_octet__alloc();
+	list->_maximum=list->_length= 1;
+	list->_buffer = (CORBA_ORB_ObjectId *)services;
+	CORBA_sequence_set_release((void *)list, CORBA_FALSE);
+
+	/* defined reserved references are:
+	 *	RootPOA
+	 *	POACurrent
+	 *	InterfaceRepository
+	 *	NameService
+	 *	TradingService
+	 *	SecurityCurrent
+	 *	TransactionCurrent
+	 */
+
+	return list;
+}
+
+/* Section 4.5
+ *
+ * raises InvalidName
+ */
+CORBA_Object CORBA_ORB_resolve_initial_references(CORBA_ORB orb, CORBA_ORB_ObjectId identifier, CORBA_Environment *ev)
+{
+	g_return_val_if_fail(ev, CORBA_OBJECT_NIL);
+	o_return_val_if_fail(orb, CORBA_OBJECT_NIL);
+
+	if(!strcmp(identifier, "ImplementationRepository"))
+		return CORBA_Object_duplicate(orb->imr, ev);
+	else if(!strcmp(identifier, "InterfaceRepository"))
+		return CORBA_Object_duplicate(orb->ir, ev);
+	else if(!strcmp(identifier, "NameService"))
+		return CORBA_Object_duplicate(orb->naming, ev);
+	else if(!strcmp(identifier, "RootPOA")) {
+		if(CORBA_Object_is_nil(orb->root_poa, ev)) {
+			CORBA_PolicyList policies = {0,0,NULL,CORBA_FALSE};
+			PortableServer_POAManager poa_mgr;
+			/* Create a poa manager */
+			poa_mgr = ORBit_POAManager_new(ev);
+			poa_mgr->orb = orb;
+
+			/* Create the root poa */
+			orb->root_poa = (CORBA_Object)
+				ORBit_POA_new(orb,
+					      "RootPOA",
+					      poa_mgr,
+					      &policies,
+					      ev);
+			CORBA_Object_duplicate(orb->root_poa, ev);
+		}
+
+		return CORBA_Object_duplicate(orb->root_poa, ev);
+	}
+
+	/* throw user exception: InvalidName */
+	CORBA_exception_set(ev,CORBA_USER_EXCEPTION,
+			    ex_CORBA_ORB_InvalidName,
+			    NULL);
+
+	goto error;
+error:
+	return(NULL);
+}
+
+/* This is a MICO extension
+ *
+ * raises InvalidName
+ */
+void CORBA_ORB_set_initial_reference(CORBA_ORB orb, CORBA_ORB_ObjectId identifier, CORBA_Object obj, CORBA_Environment *ev)
+{
+	g_return_if_fail(ev);
+	o_return_if_fail(orb && identifier && obj);
+
+	if(!strcmp(identifier, "ImplementationRepository")) {
+		if(!CORBA_Object_is_nil(orb->imr, ev)) {
+			CORBA_Object_release(orb->imr, ev);
+		}
+		orb->imr=CORBA_Object_duplicate(obj, ev);
+	} else if(!strcmp(identifier, "InterfaceRepository")) {
+		if(!CORBA_Object_is_nil(orb->ir, ev)) {
+			CORBA_Object_release(orb->ir, ev);
+		}
+		orb->ir=CORBA_Object_duplicate(obj, ev);
+	} else if(!strcmp(identifier, "NameService")) {
+		if(!CORBA_Object_is_nil(orb->naming, ev)) {
+			CORBA_Object_release(orb->naming, ev);
+		}
+		orb->naming=CORBA_Object_duplicate(obj, ev);
+	} else if(!strcmp(identifier, "RootPOA")) {
+		if(!CORBA_Object_is_nil(orb->root_poa, ev)) {
+			CORBA_Object_release(orb->root_poa, ev);
+		}
+		orb->root_poa=CORBA_Object_duplicate(obj, ev);
+	} else {
+		/* throw user exception: InvalidName */
+		CORBA_exception_set(ev,CORBA_USER_EXCEPTION,ex_CORBA_ORB_InvalidName,NULL);	
+		goto error;
+	}
+
+	return;
+error:
+	return;
+}
+
+/* Section 4.9.1 */
+CORBA_boolean CORBA_ORB_work_pending(CORBA_ORB orb, CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(CORBA_FALSE);
+}
+
+/* Section 4.9.2 */
+void CORBA_ORB_perform_work(CORBA_ORB orb, CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return;
+}
+
+/* Section 4.9.4 */
+void
+CORBA_ORB_shutdown(CORBA_ORB orb,
+		   CORBA_boolean wait_for_completion,
+		   CORBA_Environment *ev)
+{
+	g_return_if_fail(ev);
+	o_return_if_fail(orb);
+
+	/* XXX implement on a per-ORB basis, and also
+	   handle whatever wait_for_completion means */
+
+	if(orb->cnx.ipv4)
+		giop_connection_unref(orb->cnx.ipv4);
+	if(orb->cnx.ipv6)
+		giop_connection_unref(orb->cnx.ipv6);
+#ifndef __KORBIT__
+	if(orb->cnx.usock)
+		giop_connection_unref(orb->cnx.usock);
+#endif
+
+	giop_main_quit();
+}
+
+/* Section 4.9.3 */
+/* CORBA_ORB_run is in server.c */
+
+/* Section 4.7 */
+CORBA_PolicyType
+CORBA_Policy__get_policy_type(CORBA_Policy obj, CORBA_Environment *ev)
+{
+	g_return_val_if_fail(ev, 0);
+	o_return_val_if_fail(obj, 0);
+
+	return obj->policy_type;
+}
+
+/* Section 4.7 */
+CORBA_Policy CORBA_Policy_copy(CORBA_Policy obj, CORBA_Environment *ev)
+{
+	g_return_val_if_fail(ev, CORBA_OBJECT_NIL);
+	o_return_val_if_fail(obj, CORBA_OBJECT_NIL);
+
+	ORBIT_ROOT_OBJECT_REF(obj);
+
+	return obj;
+}
+
+/* Section 4.7
+ *
+ * raises CORBA_NO_PERMISSION
+ */
+void CORBA_Policy_destroy(CORBA_Policy obj, CORBA_Environment *ev)
+{
+	g_return_if_fail(ev);
+	o_return_if_fail(obj);
+
+	ORBIT_ROOT_OBJECT_UNREF(obj);
+	if(ORBIT_ROOT_OBJECT(obj)->refs <= 0)
+		ORBIT_ROOT_OBJECT_release(obj, ev);
+}
+
+#ifndef __KORBIT__
+/* Section 4.8.2 */
+CORBA_Policy CORBA_DomainManager_get_domain_policy(CORBA_DomainManager obj, CORBA_PolicyType policy_type, CORBA_Environment *ev)
+{
+	g_return_val_if_fail(ev, CORBA_OBJECT_NIL);
+	o_return_val_if_fail(obj, CORBA_OBJECT_NIL);
+
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+/* Section 4.8.2 */
+void CORBA_ConstructionPolicy_make_domain_manager(CORBA_ConstructionPolicy obj, CORBA_InterfaceDef object_type, CORBA_boolean constr_policy, CORBA_Environment *
+ev)
+{
+	g_return_if_fail(ev);
+	o_return_if_fail(obj && object_type);
+
+	g_assert(!"Not yet implemented");
+	return;
+}
+
+/* Section 4.2.8 */
+CORBA_DomainManagerList *CORBA_Object_get_domain_managers(CORBA_Object obj, CORBA_Environment *ev)
+{
+	g_return_val_if_fail(ev, NULL);
+	o_return_val_if_fail(obj, NULL);
+
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+CORBA_TypeCode CORBA_ORB_create_struct_tc(CORBA_ORB obj, CORBA_RepositoryId id, CORBA_Identifier name, CORBA_StructMemberSeq members, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+	int i;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc == NULL)
+	  goto tc_alloc_failed;
+
+	tc->subtypes=g_new0(CORBA_TypeCode, members._length);
+	if(tc->subtypes == NULL)
+	  goto subtypes_alloc_failed;
+
+	tc->subnames=g_new0(char *, members._length);
+	if(tc->subnames == NULL)
+	  goto subnames_alloc_failed;
+
+	tc->kind=CORBA_tk_struct;
+	tc->name=g_strdup(name);
+	tc->repo_id=g_strdup(id);
+	tc->sub_parts=members._length;
+	tc->length=members._length;
+
+	for(i=0;i<members._length;i++) {
+		CORBA_StructMember *mem=(CORBA_StructMember *)&(members._buffer[i]);
+
+		g_assert(&(mem->type)!=NULL);
+
+		tc->subtypes[i] = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+		memcpy(tc->subtypes[i], mem->type, (size_t)sizeof(struct CORBA_TypeCode_struct));
+		tc->subnames[i]=g_strdup(mem->name);
+	}
+
+	return(tc);
+
+ subnames_alloc_failed:
+	g_free(tc->subtypes);
+ subtypes_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+ tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return NULL;
+}
+
+CORBA_TypeCode 
+CORBA_ORB_create_union_tc(CORBA_ORB obj, CORBA_RepositoryId id,
+			  CORBA_Identifier name,
+			  CORBA_TypeCode discriminator_type,
+			  CORBA_UnionMemberSeq members,
+			  CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+	int i;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+
+	if(tc == NULL)
+	  goto tc_alloc_failed;
+
+	tc->discriminator = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+
+	if(tc->discriminator == NULL)
+	  goto discriminator_alloc_failed;
+
+	memcpy(tc->discriminator, discriminator_type, (size_t)sizeof(CORBA_TypeCode));
+
+	tc->subtypes=g_new0(CORBA_TypeCode, members._length);
+	if(tc->subtypes==NULL)
+	  goto subtypes_alloc_failed;
+
+	tc->subnames=g_new0(char *, members._length);
+	if(tc->subnames==NULL)
+	  goto subnames_alloc_failed;
+
+	tc->sublabels=g_new0(CORBA_any, members._length);
+	if(tc->sublabels == NULL)
+	  goto sublabels_alloc_failed;
+
+	tc->kind=CORBA_tk_union;
+	tc->name=g_strdup(name);
+	tc->repo_id=g_strdup(id);
+	tc->sub_parts=members._length;
+	tc->length=members._length;
+	tc->default_index=-1;
+
+	for(i=0;i<members._length;i++) {
+		CORBA_UnionMember *mem=(CORBA_UnionMember *)&(members._buffer[i]);
+
+		g_assert(&(mem->label)!=NULL);
+		memcpy(&(tc->sublabels[i]), &(mem->label), (size_t)sizeof(CORBA_any));
+		g_assert(&(mem->type)!=NULL);
+		tc->subtypes[i] = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+		memcpy(tc->subtypes[i], mem->type, (size_t)sizeof(struct CORBA_TypeCode_struct));
+		tc->subnames[i]=g_strdup(mem->name);
+
+		if(mem->label._type->kind==CORBA_tk_octet) {
+			tc->default_index=i;
+		}
+	}
+
+	return(tc);
+
+sublabels_alloc_failed:
+	g_free(tc->sublabels);
+subnames_alloc_failed:
+	g_free(tc->subtypes);
+subtypes_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc->discriminator);
+discriminator_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+ tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return NULL;
+}
+
+CORBA_TypeCode CORBA_ORB_create_enum_tc(CORBA_ORB obj, CORBA_RepositoryId id, CORBA_Identifier name, CORBA_EnumMemberSeq members, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+	int i;
+
+	tc = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc == NULL)
+	  goto tc_alloc_failed;
+
+	tc->subnames=g_new0(char *, members._length);
+	if(tc->subnames==NULL)
+	  goto subnames_alloc_failed;
+
+	tc->kind = CORBA_tk_enum;
+	tc->name = g_strdup(name);
+	tc->repo_id = g_strdup(id);
+	tc->sub_parts = members._length;
+	tc->length = members._length;
+
+	for(i=0;i<members._length;i++) {
+		tc->subnames[i]=g_strdup(members._buffer[i]);
+	}
+
+	return(tc);
+
+ subnames_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+ tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return(NULL);
+}
+
+CORBA_TypeCode CORBA_ORB_create_alias_tc(CORBA_ORB obj, CORBA_RepositoryId id, CORBA_Identifier name, CORBA_TypeCode original_type, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL)
+	  goto tc_alloc_failed;
+	
+	/* Can't use chunks here, because it's sometimes an array. Doh! */
+	tc->subtypes=g_new0(CORBA_TypeCode, 1);
+	if(tc->subtypes==NULL)
+	  goto subtypes_alloc_failed;
+
+	tc->kind=CORBA_tk_alias;
+	tc->name=g_strdup(name);
+	tc->repo_id=g_strdup(id);
+	tc->sub_parts=1;
+	tc->length=1;
+
+	tc->subtypes[0] = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	memcpy(tc->subtypes[0], original_type, (size_t)sizeof(struct CORBA_TypeCode_struct));
+
+	return(tc);
+ subtypes_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return NULL;
+}
+
+CORBA_TypeCode CORBA_ORB_create_exception_tc(CORBA_ORB obj, CORBA_RepositoryId id, CORBA_Identifier name, CORBA_StructMemberSeq members, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+	int i;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL)
+	  goto tc_alloc_failed;
+
+	tc->subtypes=g_new0(CORBA_TypeCode, members._length);
+	if(tc->subtypes==NULL)
+	  goto subtypes_alloc_failed;
+
+	tc->subnames=g_new0(char *, members._length);
+	if(tc->subnames==NULL)
+	  goto subnames_alloc_failed;
+
+	tc->kind=CORBA_tk_except;
+	tc->name=g_strdup(name);
+	tc->repo_id=g_strdup(id);
+	tc->sub_parts=members._length;
+	tc->length=members._length;
+
+	for(i=0;i<members._length;i++) {
+		CORBA_StructMember *mem=(CORBA_StructMember *)&(members._buffer[i]);
+
+		g_assert(mem->type != NULL);
+		tc->subtypes[i] = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+		memcpy(tc->subtypes[i], mem->type, (size_t)sizeof(struct CORBA_TypeCode_struct));
+		tc->subnames[i]=g_strdup(mem->name);
+	}
+
+	return(tc);
+
+ subnames_alloc_failed:
+	g_free(tc->subtypes);
+ subtypes_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+ tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return(NULL);
+}
+
+CORBA_TypeCode CORBA_ORB_create_interface_tc(CORBA_ORB obj, CORBA_RepositoryId id, CORBA_Identifier name, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY,
+					   CORBA_COMPLETED_NO);
+		return(NULL);
+	}
+
+	tc->kind=CORBA_tk_objref;
+	tc->name=g_strdup(name);
+	tc->repo_id=g_strdup(id);
+
+	return(tc);
+}
+
+CORBA_TypeCode CORBA_ORB_create_string_tc(CORBA_ORB obj, CORBA_unsigned_long bound, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+		return(NULL);
+	}
+
+	tc->kind=CORBA_tk_string;
+	tc->length=bound;
+
+	return(tc);
+}
+
+CORBA_TypeCode CORBA_ORB_create_wstring_tc(CORBA_ORB obj, CORBA_unsigned_long bound, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+		return(NULL);
+	}
+
+	tc->kind=CORBA_tk_wstring;
+	tc->length=bound;
+
+	return(tc);
+}
+
+CORBA_TypeCode CORBA_ORB_create_fixed_tc(CORBA_ORB obj, CORBA_unsigned_short digits, CORBA_short scale, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+		return(NULL);
+	}
+
+	tc->kind=CORBA_tk_fixed;
+	tc->digits=digits;
+	tc->scale=scale;
+
+	return(tc);
+}
+
+CORBA_TypeCode CORBA_ORB_create_sequence_tc(CORBA_ORB obj, CORBA_unsigned_long bound, CORBA_TypeCode element_type, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL)
+	  goto tc_alloc_failed;
+
+	/* Can't use chunks here because we can only be sure of getting
+	   one consecutive chunk from glib */
+	tc->subtypes=g_new0(CORBA_TypeCode, 1);
+	if(tc->subtypes==NULL)
+	  goto subtypes_alloc_failed;
+
+	tc->kind=CORBA_tk_sequence;
+	tc->sub_parts=1;
+	tc->length=bound;
+
+	tc->subtypes[0] = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	memcpy(tc->subtypes[0], element_type,
+	       (size_t)sizeof(struct CORBA_TypeCode_struct));
+
+	return(tc);
+
+ subtypes_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+ tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return(NULL);
+}
+
+CORBA_TypeCode CORBA_ORB_create_recursive_sequence_tc(CORBA_ORB obj, CORBA_unsigned_long bound, CORBA_unsigned_long offset, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL)
+	  goto tc_alloc_failed;
+
+	tc->subtypes=g_new0(CORBA_TypeCode, 1);
+	if(tc->subtypes==NULL)
+	  goto subtypes_alloc_failed;
+
+	tc->kind=CORBA_tk_sequence;
+	tc->sub_parts=1;
+	tc->length=bound;
+
+	tc->subtypes[0] = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	tc->subtypes[0]->kind=CORBA_tk_recursive;
+	tc->subtypes[0]->recurse_depth=offset;
+
+	return(tc);
+
+ subtypes_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+ tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return(NULL);
+}
+
+CORBA_TypeCode CORBA_ORB_create_array_tc(CORBA_ORB obj, CORBA_unsigned_long length, CORBA_TypeCode element_type, CORBA_Environment *ev)
+{
+	CORBA_TypeCode tc;
+
+	tc=ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	if(tc==NULL)
+	  goto tc_alloc_failed;
+
+	tc->subtypes=g_new0(CORBA_TypeCode, 1);
+	if(tc->subtypes==NULL)
+	  goto subtypes_alloc_failed;
+
+	tc->kind=CORBA_tk_array;
+	tc->sub_parts=1;
+	tc->length=length;
+
+	tc->subtypes[0] = ORBIT_CHUNK_ALLOC(CORBA_TypeCode);
+	memcpy(tc->subtypes[0], element_type, (size_t)sizeof(CORBA_TypeCode));
+
+	return(tc);
+
+ subtypes_alloc_failed:
+	ORBIT_CHUNK_FREE(CORBA_TypeCode, tc);
+ tc_alloc_failed:
+	CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+	return(NULL);
+}
+#endif /* !__KORBIT__ */
diff -urN linux-2.4.1/net/korbit/orb/orb.h linux-2.4.1-korbit/net/korbit/orb/orb.h
--- linux-2.4.1/net/korbit/orb/orb.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orb.h	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,231 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_ORB_H_
+#define _ORBIT_ORB_H_
+
+#include "orb/orbit_types.h"
+#ifndef __KORBIT__
+#include "orb/interface_repository.h"
+#endif /* !__KORBIT__ */
+
+extern CORBA_ORB CORBA_ORB_init(
+	int *argc,
+	char **argv,
+	CORBA_ORBid orb_identifier,
+	CORBA_Environment *ev);
+
+extern CORBA_char *CORBA_ORB_object_to_string(
+	CORBA_ORB orb,
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+
+extern CORBA_Object CORBA_ORB_string_to_object(
+	CORBA_ORB orb,
+	CORBA_char *str,
+	CORBA_Environment *ev);
+
+extern CORBA_Status CORBA_ORB_get_default_context(
+	CORBA_ORB orb,
+	CORBA_Context *ctx,
+	CORBA_Environment *ev);
+
+extern CORBA_boolean CORBA_ORB_get_service_information(
+	CORBA_ORB orb,
+	CORBA_ServiceType service_type,
+	CORBA_ServiceInformation *service_information,
+	CORBA_Environment *ev);
+
+extern CORBA_Current *CORBA_ORB_get_current(
+	CORBA_ORB orb,
+	CORBA_Environment *ev);
+
+extern CORBA_ORB_ObjectIdList* CORBA_ORB_list_initial_services(
+	CORBA_ORB orb,
+	CORBA_Environment *ev);
+
+extern CORBA_Object CORBA_ORB_resolve_initial_references(
+	CORBA_ORB orb,
+	CORBA_ORB_ObjectId identifier,
+	CORBA_Environment *ev);
+
+extern void CORBA_ORB_set_initial_reference(
+	CORBA_ORB orb,
+	CORBA_ORB_ObjectId identifier,
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+
+extern CORBA_boolean CORBA_ORB_work_pending(
+	CORBA_ORB orb,
+	CORBA_Environment *ev);
+
+extern void CORBA_ORB_perform_work(
+	CORBA_ORB orb,
+	CORBA_Environment *ev);
+
+extern void CORBA_ORB_shutdown(
+	CORBA_ORB orb,
+	CORBA_boolean wait_for_completion,
+	CORBA_Environment *ev);
+
+extern void CORBA_ORB_run(
+	CORBA_ORB orb,
+	CORBA_Environment *ev);
+
+extern CORBA_PolicyType CORBA_Policy__get_policy_type(
+	CORBA_Policy obj,
+	CORBA_Environment *ev);
+
+extern CORBA_Policy CORBA_Policy_copy(
+	CORBA_Policy obj,
+	CORBA_Environment *ev);
+
+extern void CORBA_Policy_destroy(
+	CORBA_Policy obj,
+	CORBA_Environment *ev);
+
+#ifndef __KORBIT__
+extern CORBA_InterfaceDef CORBA_Object_get_interface(
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+#endif /* !__KORBIT__ */
+
+extern CORBA_boolean CORBA_Object_is_nil(
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+
+extern CORBA_Object CORBA_Object_duplicate(
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+
+extern void CORBA_Object_release(
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+
+extern CORBA_boolean CORBA_Object_non_existent(
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+
+extern CORBA_boolean CORBA_Object_is_equivalent(
+	CORBA_Object obj,
+	CORBA_Object other_object,
+	CORBA_Environment *ev);
+
+extern CORBA_unsigned_long CORBA_Object_hash(
+	CORBA_Object obj,
+	CORBA_unsigned_long maximum,
+	CORBA_Environment *ev);
+
+extern CORBA_Policy CORBA_Object_get_policy(
+	CORBA_Object obj,
+	CORBA_PolicyType policy_type,
+	CORBA_Environment *ev);
+
+#ifndef __KORBIT__
+extern CORBA_DomainManagerList *CORBA_Object_get_domain_managers(
+	CORBA_Object obj,
+	CORBA_Environment *ev);
+
+extern CORBA_Policy CORBA_DomainManager_get_domain_policy(
+	CORBA_DomainManager obj,
+	CORBA_PolicyType policy_type,
+	CORBA_Environment *ev);
+
+extern void CORBA_ConstructionPolicy_make_domain_manager(
+	CORBA_ConstructionPolicy obj,
+	CORBA_Object /*CORBA_InterfaceDef*/ object_type,
+	CORBA_boolean constr_policy,
+	CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_struct_tc(CORBA_ORB obj,
+					  CORBA_RepositoryId id,
+					  CORBA_Identifier name,
+					  CORBA_StructMemberSeq members,
+					  CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_union_tc(CORBA_ORB obj,
+					 CORBA_RepositoryId id,
+					 CORBA_Identifier name,
+					 CORBA_TypeCode discriminator_type,
+					 CORBA_UnionMemberSeq members,
+					 CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_enum_tc(CORBA_ORB obj,
+					CORBA_RepositoryId id,
+					CORBA_Identifier name,
+					CORBA_EnumMemberSeq members,
+					CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_alias_tc(CORBA_ORB obj,
+					 CORBA_RepositoryId id,
+					 CORBA_Identifier name,
+					 CORBA_TypeCode original_type,
+					 CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_exception_tc(CORBA_ORB obj,
+					     CORBA_RepositoryId id,
+					     CORBA_Identifier name,
+					     CORBA_StructMemberSeq members,
+					     CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_interface_tc(CORBA_ORB obj,
+					     CORBA_RepositoryId id,
+					     CORBA_Identifier name,
+					     CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_string_tc(CORBA_ORB obj,
+					  CORBA_unsigned_long bound,
+					  CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_wstring_tc(CORBA_ORB obj,
+					   CORBA_unsigned_long bound,
+					   CORBA_Environment *ev);
+
+CORBA_TypeCode CORBA_ORB_create_fixed_tc(CORBA_ORB obj,
+					 CORBA_unsigned_short digits,
+					 CORBA_short scale,
+					 CORBA_Environment *ev);
+
+extern CORBA_TypeCode CORBA_ORB_create_sequence_tc(
+	CORBA_ORB obj,
+	CORBA_unsigned_long bound,
+	CORBA_TypeCode element_type,
+	CORBA_Environment *ev);
+
+extern CORBA_TypeCode CORBA_ORB_create_recursive_sequence_tc(
+	CORBA_ORB obj,
+	CORBA_unsigned_long bound,
+	CORBA_unsigned_long offset,
+	CORBA_Environment *ev);
+
+extern CORBA_TypeCode CORBA_ORB_create_array_tc(
+	CORBA_ORB obj,
+	CORBA_unsigned_long length,
+	CORBA_TypeCode element_type,
+	CORBA_Environment *ev);
+
+#endif /* !__KORBIT__ */
+
+#endif /* !_ORBIT_ORB_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orbit.c linux-2.4.1-korbit/net/korbit/orb/orbit.c
--- linux-2.4.1/net/korbit/orb/orbit.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit.c	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,387 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+/*
+ * This file is a repository for random functions that don't fit anywhere
+ * else, and for ORBit-specific stuff.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <math.h>
+
+#include "orbit.h"
+
+const guint orbit_major_version = ORBIT_MAJOR_VERSION,
+	orbit_minor_version = ORBIT_MINOR_VERSION,
+	orbit_micro_version = ORBIT_MICRO_VERSION;
+const char orbit_version[] = ORBIT_VERSION;
+
+typedef struct ORBitClassInfo ORBitClassInfo;
+
+typedef void (*ORBitObjectInitFunc)(CORBA_Object _handle_to_be, gpointer class_data);
+
+struct ORBitClassInfo {
+  char *name;
+  gulong id;
+  gpointer method_stubs, method_skels;
+  ORBitObjectInitFunc class_vtable_init_func;
+  ORBitClassInfo **parent_classes;
+};
+
+GHashTable *orbit_class_list = NULL, *orbit_class_byid;
+glong class_id_counter = -1;
+
+void CORBA_any_set_release(CORBA_any *any, CORBA_boolean flag)
+{
+	g_assert(any!=NULL);
+
+	if(flag==CORBA_TRUE) {
+		any->_release |= CORBA_ANYFLAGS_RELEASE;
+	} else {
+		any->_release &= ~CORBA_ANYFLAGS_RELEASE;
+	}
+
+}
+
+CORBA_boolean CORBA_any_get_release(CORBA_any *any)
+{
+	g_assert(any!=NULL);
+
+	if(any->_release & CORBA_ANYFLAGS_RELEASE)
+		return(CORBA_TRUE);
+	else
+		return(CORBA_FALSE);
+}
+
+void CORBA_sequence_set_release(void *seq, CORBA_boolean flag)
+{
+	struct CORBA_Sequence_type *sequence;
+
+	g_assert(seq!=NULL);
+
+	sequence=(struct CORBA_Sequence_type *)seq;
+
+	if(flag==CORBA_TRUE) {
+		sequence->_release |= CORBA_ANYFLAGS_RELEASE;
+	} else {
+		sequence->_release &= ~CORBA_ANYFLAGS_RELEASE;
+	}
+}
+
+CORBA_boolean CORBA_sequence_get_release(void *seq)
+{
+	struct CORBA_Sequence_type *sequence;
+
+	g_assert(seq!=NULL);
+
+	sequence=(struct CORBA_Sequence_type *)seq;
+
+	if(sequence->_release & CORBA_ANYFLAGS_RELEASE)
+		return(CORBA_TRUE);
+	else
+		return(CORBA_FALSE);
+}
+
+/*
+ * As far as I understand, values returned by CORBA_*_alloc() are supposed to be
+ * freeable by CORBA_free(), so we can't use memory chunks here in any reasonable
+ * fashion.
+ */
+gpointer
+CORBA_any__free(gpointer mem, gpointer func_data, CORBA_boolean free_strings)
+{
+	CORBA_any *aval = mem;
+
+	if(aval->_release)
+		ORBit_free(aval->_value, free_strings);
+	CORBA_Object_release((CORBA_Object)aval->_type, NULL);
+
+	return aval + 1;
+}
+
+CORBA_any *CORBA_any_alloc(void)
+{
+	CORBA_any *retval = ORBit_alloc(sizeof(CORBA_any), &CORBA_any__free,
+					GINT_TO_POINTER(1));
+
+	memset(retval, 0, sizeof(CORBA_any)); /* Make things easier on stubs */
+
+	return retval;
+}
+
+/*
+ * Compares the typecodes of each any
+ */
+CORBA_boolean ORBit_any_equivalent(CORBA_any obj, CORBA_any any, CORBA_Environment *ev)
+{
+	return(CORBA_FALSE);
+}
+
+/* This is needed by skels, that generate a __free function when they see
+   the TypeCode interface */
+gpointer
+CORBA_TypeCode__free(gpointer mem, gpointer func_data, CORBA_boolean free_strings)
+{
+	CORBA_Object_release(*(CORBA_Object *)mem, NULL);
+	return ((guchar *)mem) + sizeof(CORBA_TypeCode);
+}
+
+CORBA_char *CORBA_string_dup(const CORBA_char *string)
+{
+	if(!string)
+		return NULL;
+
+	return strcpy(ORBit_alloc(strlen(string)+1, NULL, NULL), string);
+}
+
+CORBA_char *CORBA_string_alloc(CORBA_unsigned_long len)
+{
+	return ORBit_alloc(len + 1, NULL, NULL);
+}
+
+CORBA_wchar *CORBA_wstring_alloc(CORBA_unsigned_long len)
+{
+	return ORBit_alloc(len + 1, NULL, NULL);
+}
+
+gpointer
+CORBA_string__free(gpointer str, gpointer dat, CORBA_boolean free_strings)
+{
+	if(free_strings)
+		CORBA_free(*((gpointer *)str));
+	return (gpointer)((guchar *)str + sizeof(CORBA_char *));
+}
+
+gpointer CORBA_Object__free(gpointer str, gpointer dat, CORBA_boolean free_strings)
+{
+	CORBA_Environment ev;
+	CORBA_exception_init(&ev);
+	CORBA_Object_release(*((gpointer *)str), &ev);
+	CORBA_exception_free(&ev);
+	return (gpointer)((guchar *)str + sizeof(CORBA_Object));
+}
+
+/* 19.14 */
+
+/* The big picture for fixeds.
+   We have to represent a number in memory.
+
+   1 2 3 . 4 5 6 7
+
+   There are three pieces of information in a fixed:
+
+   - Number of significant digits. (_digits)
+
+   - The scale. The number of places the decimal point is to the right
+   of the first significant digit. (_scale)
+
+   - The digits themselves (_value)
+
+ */
+CORBA_long CORBA_fixed_integer_part(const void *fp)
+{
+	CORBA_long retval = 0;
+	int i, power_of_ten, digit;
+	const CORBA_fixed_d_s *val = fp;
+
+	g_return_val_if_fail(fp != NULL, INT_MIN);
+
+	for(i = 0; i < (val->_digits - val->_scale); i++) {
+		power_of_ten = val->_digits - i - val->_scale - 1;
+		digit = val->_value[i];
+		retval += digit * ((int)pow(10, power_of_ten));
+	}
+
+	return retval;
+}
+
+CORBA_long CORBA_fixed_fraction_part(const void *fp)
+{
+	CORBA_long retval = 0;
+	int i, power_of_ten, digit;
+	const CORBA_fixed_d_s *val = fp;
+
+	g_return_val_if_fail(fp != NULL, INT_MIN);
+
+	for(i = val->_digits - val->_scale; i < val->_digits; i++){
+		power_of_ten = val->_digits - i - 1;
+		digit = val->_value[i];
+		retval += digit * ((int)pow(10, power_of_ten));
+	}
+
+	return retval;
+}
+
+static inline
+CORBA_long do_div (CORBA_long *n)
+{
+  int __res;
+
+  __res = (*n) % (unsigned) 10;
+  *n = (*n) / (unsigned) 10;
+
+  return __res;
+}
+
+void CORBA_fixed_set(void *rp, CORBA_long i, CORBA_long f)
+{
+	CORBA_fixed_d_s *val = rp;
+	CORBA_long left_to_eat, cur;
+	signed char sign = 1;
+
+	g_return_if_fail(rp != NULL);
+
+	memset(val->_value, 0, val->_digits);
+
+	if(i) sign = i/abs(i);
+	val->_sign = sign;
+	i = abs(i);
+	f = abs(f);
+
+	for(cur = 0, left_to_eat = i;
+	    left_to_eat != 0 && cur < val->_digits; cur++) {
+		val->_value[cur] = do_div(&left_to_eat) * sign;
+		sign = 1;
+	}
+
+	val->_scale = cur - 1;
+
+	for(left_to_eat = f;
+	    left_to_eat != 0 && cur < val->_digits; cur++) {
+		val->_value[cur] = do_div(&left_to_eat);
+	}
+}
+
+void CORBA_fixed_add(void *rp, const void *f1p, const void *f2p)
+{
+	g_assert(!"Not yet implemented");
+}
+
+void CORBA_fixed_sub(void *rp, const void *f1p, const void *f2p)
+{
+	g_assert(!"Not yet implemented");
+}
+
+void CORBA_fixed_mul(void *rp, const void *f1p, const void *f2p)
+{
+	g_assert(!"Not yet implemented");
+}
+
+void CORBA_fixed_div(void *rp, const void *f1p, const void *f2p)
+{
+	g_assert(!"Not yet implemented");
+}
+
+CORBA_fixed_d_s *CORBA_fixed_alloc(CORBA_unsigned_short d)
+{
+	return (CORBA_fixed_d_s *)
+		g_malloc(sizeof(CORBA_fixed_d_s) + d + 1);
+}
+
+void CORBA_free(void *storage)
+{
+	ORBit_free(storage, CORBA_TRUE);
+}
+
+int ORBit_parse_unixsock(CORBA_Object obj,
+			 char *sockpath,
+			 gboolean existing_only)
+{
+	if(!sockpath || !*sockpath)
+		return -1;
+	
+	obj->connection =
+		GIOP_CONNECTION(iiop_connection_unix_get(sockpath,
+							 existing_only));
+
+	if(!obj->connection)
+		return -1;
+
+	giop_connection_ref(obj->connection);
+	return 0;
+}
+
+int ORBit_parse_inet(CORBA_Object obj, char *hostname, unsigned short port,
+			 gboolean existing_only)
+{
+	obj->connection = GIOP_CONNECTION(iiop_connection_get(hostname, port, existing_only));
+
+	if(!obj->connection)
+		return -1;
+	giop_connection_ref(obj->connection);
+	return 0;
+}
+
+static const CORBA_unsigned_long zero_int = 0;
+struct iovec ORBit_default_principal_iovec = {(gpointer)&zero_int, sizeof(zero_int)};
+
+void ORBit_set_default_principal(CORBA_Principal *principal)
+{
+	gpointer t;
+
+	if((gpointer)ORBit_default_principal_iovec.iov_base != (gpointer)&zero_int)
+		g_free(ORBit_default_principal_iovec.iov_base);
+
+	ORBit_default_principal_iovec.iov_len = principal->_length
+		+ sizeof(CORBA_unsigned_long);
+
+	t = ORBit_default_principal_iovec.iov_base =
+		g_malloc(ORBit_default_principal_iovec.iov_len);
+
+	memcpy(t, &principal->_length, sizeof(principal->_length));
+
+	t = ((guchar *)t) + sizeof(principal->_length);
+	memcpy(t, principal->_buffer, principal->_length);
+}
+
+CORBA_unsigned_long ORBit_class_assignment_counter = 0;
+GHashTable *ORBit_class_assignments = NULL;
+
+/* XXX not thread-safe */
+CORBA_unsigned_long
+ORBit_register_class(const PortableServer_ClassInfo *class_info)
+{
+	CORBA_unsigned_long retval;
+
+	if(!ORBit_class_assignments)
+		ORBit_class_assignments = g_hash_table_new(g_str_hash, g_str_equal);
+
+	/* This needs to be pre-increment - we don't want to give out
+	   classid 0, because (a) that is reserved for the base Object class
+	   (b) all the routines allocate a new id if the variable
+	   storing their ID == 0 */
+	retval = ++ORBit_class_assignment_counter;
+
+	g_hash_table_insert(ORBit_class_assignments, (gpointer)class_info->class_name,
+			    GINT_TO_POINTER(retval));
+
+	return retval;
+}
diff -urN linux-2.4.1/net/korbit/orb/orbit.h linux-2.4.1-korbit/net/korbit/orb/orbit.h
--- linux-2.4.1/net/korbit/orb/orbit.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit.h	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,207 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@acm.org>
+ *	    Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+/* these two blocks are outside of the main header for good reason...
+   People may include headers from many different stubs, and we want to
+   have the version checked on all of them.
+ */
+#ifndef ORBIT_SERIAL
+#define ORBIT_SERIAL 9
+#endif
+
+#ifdef ORBIT_IDL_SERIAL
+#if ORBIT_IDL_SERIAL < 9
+#error "You need to rerun 'orbit-idl' on the .idl file whose stubs you are using. These stubs were generated with an older version of ORBit, and need to be regenerated."
+#endif
+#endif
+
+#ifndef _ORBIT_H_
+#define _ORBIT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <glib.h>
+
+#define BACKWARDS_COMPAT_0_4
+#undef NOT_BACKWARDS_COMPAT_0_4
+
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <IIOP/IIOP.h>
+#include <ORBitutil/util.h>
+#include <orb/orbit_config.h>
+#include <orb/orbit_types.h>
+#include <orb/allocators.h>
+#include <orb/cdr.h>
+#include <orb/dii.h>
+#ifndef __KORBIT__
+#include <orb/dynany.h>
+#endif
+#include <orb/env.h>
+#include <orb/iop.h>
+#include <orb/ir.h>
+#include <orb/options.h>
+#include <orb/orb.h>
+#include <orb/poa.h>
+#include <orb/sequences.h>
+#include <orb/orbit_typecode.h>
+#include <orb/typecode.h>
+
+#ifndef ORBIT_MAJOR_VERSION
+#define ORBIT_MAJOR_VERSION (0)
+#define ORBIT_MINOR_VERSION (5)
+#define ORBIT_MICRO_VERSION (3)
+#endif
+
+extern const guint orbit_major_version,
+	orbit_minor_version,
+	orbit_micro_version;
+extern const char orbit_version[];
+
+extern void CORBA_any_set_release(
+	CORBA_any *,
+	CORBA_boolean);
+
+extern CORBA_boolean CORBA_any_get_release(
+	CORBA_any *);
+
+extern void CORBA_sequence_set_release(
+	void *,
+	CORBA_boolean);
+
+extern CORBA_boolean CORBA_sequence_get_release(
+	void *);
+
+#define CORBA_any__alloc CORBA_any_alloc
+extern CORBA_any *CORBA_any_alloc(
+	void);
+
+extern gpointer CORBA_any__free(gpointer mem, gpointer func_data,
+				CORBA_boolean free_strings);
+extern gpointer CORBA_TypeCode__free(gpointer mem, gpointer func_data,
+				     CORBA_boolean free_strings);
+
+extern CORBA_boolean ORBit_any_equivalent(
+	CORBA_any obj,
+	CORBA_any any,
+	CORBA_Environment *ev);
+
+extern CORBA_char *CORBA_string_dup(const CORBA_char *string);
+extern CORBA_char *CORBA_string_alloc(CORBA_unsigned_long len);
+extern gpointer CORBA_string__free(gpointer str, gpointer dat, CORBA_boolean free_strings);
+
+gpointer CORBA_Object__free(gpointer str, gpointer dat, CORBA_boolean free_strings);
+
+extern CORBA_wchar *CORBA_wstring_alloc(CORBA_unsigned_long len);
+#define CORBA_wstring_free CORBA_string_free
+
+/* 19.14 */
+extern CORBA_long CORBA_fixed_integer_part(
+	const void *fp);
+
+extern CORBA_long CORBA_fixed_fraction_part(
+	const void *fp);
+
+extern void CORBA_fixed_set(
+	void *rp,
+	CORBA_long i,
+	CORBA_long f);
+
+extern void CORBA_fixed_add(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern void CORBA_fixed_sub(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern void CORBA_fixed_mul(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern void CORBA_fixed_div(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern CORBA_fixed_d_s *CORBA_fixed_alloc(
+	CORBA_unsigned_short d);
+
+extern void CORBA_free(
+	void *storage);
+
+extern int ORBit_parse_inet(
+	CORBA_Object obj,
+	char *hostname,
+	unsigned short port,
+	gboolean existing_only);
+
+extern int ORBit_parse_unixsock(CORBA_Object obj,
+				char *sockpath,
+				gboolean existing_only);
+
+/****
+     This function lets you use your own event loop, if you so wish.
+     Also see IIOP.h's IIOP{Add,Remove}ConnectionHandler function pointers,
+     which are app-settable (you should set them before CORBA_ORB_init,
+     if you want them to be useful)
+ ****/
+
+    /* needs to be called by your event loop when data comes in on one of the
+       GIOPConnection fd's */
+void ORBit_custom_run_setup(CORBA_ORB orb, CORBA_Environment *ev);
+	void ORBit_handle_incoming(GIOPConnection *connection);
+
+/* Returns CORBA_TRUE if the request is OK to proceed. */
+typedef enum {
+	ORBIT_MESSAGE_BAD,
+	ORBIT_MESSAGE_ALLOW,
+	ORBIT_MESSAGE_ALLOW_ALL /* Allow all subsequent messages on
+				   this connection with no checking */
+} ORBit_MessageValidationResult;
+typedef ORBit_MessageValidationResult (*ORBit_request_validate)
+	     (CORBA_unsigned_long request_id,
+	      CORBA_Principal *principal,
+	      CORBA_char *operation);
+void ORBit_set_request_validation_handler(ORBit_request_validate validator);
+
+extern struct iovec ORBit_default_principal_iovec;
+void ORBit_set_default_principal(CORBA_Principal *principal);
+
+extern CORBA_unsigned_long ORBit_class_assignment_counter;
+
+CORBA_unsigned_long ORBit_register_class(const PortableServer_ClassInfo *class_info);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif	/* !_ORBIT_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orbit.h.in linux-2.4.1-korbit/net/korbit/orb/orbit.h.in
--- linux-2.4.1/net/korbit/orb/orbit.h.in	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit.h.in	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,205 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@acm.org>
+ *	    Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+/* these two blocks are outside of the main header for good reason...
+   People may include headers from many different stubs, and we want to
+   have the version checked on all of them.
+ */
+#ifndef ORBIT_SERIAL
+#define ORBIT_SERIAL @ORBIT_SERIAL@
+#endif
+
+#ifdef ORBIT_IDL_SERIAL
+#if ORBIT_IDL_SERIAL < @ORBIT_SERIAL@
+#error "You need to rerun 'orbit-idl' on the .idl file whose stubs you are using. These stubs were generated with an older version of ORBit, and need to be regenerated."
+#endif
+#endif
+
+#ifndef _ORBIT_H_
+#define _ORBIT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <glib.h>
+
+#define BACKWARDS_COMPAT_0_4
+#undef NOT_BACKWARDS_COMPAT_0_4
+
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <IIOP/IIOP.h>
+#include <ORBitutil/util.h>
+#include <orb/orbit_config.h>
+#include <orb/orbit_types.h>
+#include <orb/allocators.h>
+#include <orb/cdr.h>
+#include <orb/dii.h>
+#include <orb/dynany.h>
+#include <orb/env.h>
+#include <orb/iop.h>
+#include <orb/ir.h>
+#include <orb/options.h>
+#include <orb/orb.h>
+#include <orb/poa.h>
+#include <orb/sequences.h>
+#include <orb/orbit_typecode.h>
+#include <orb/typecode.h>
+
+#ifndef ORBIT_MAJOR_VERSION
+#define ORBIT_MAJOR_VERSION (@ORBIT_MAJOR_VERSION@)
+#define ORBIT_MINOR_VERSION (@ORBIT_MINOR_VERSION@)
+#define ORBIT_MICRO_VERSION (@ORBIT_MICRO_VERSION@)
+#endif
+
+extern const guint orbit_major_version,
+	orbit_minor_version,
+	orbit_micro_version;
+extern const char orbit_version[];
+
+extern void CORBA_any_set_release(
+	CORBA_any *,
+	CORBA_boolean);
+
+extern CORBA_boolean CORBA_any_get_release(
+	CORBA_any *);
+
+extern void CORBA_sequence_set_release(
+	void *,
+	CORBA_boolean);
+
+extern CORBA_boolean CORBA_sequence_get_release(
+	void *);
+
+#define CORBA_any__alloc CORBA_any_alloc
+extern CORBA_any *CORBA_any_alloc(
+	void);
+
+extern gpointer CORBA_any__free(gpointer mem, gpointer func_data,
+				CORBA_boolean free_strings);
+extern gpointer CORBA_TypeCode__free(gpointer mem, gpointer func_data,
+				     CORBA_boolean free_strings);
+
+extern CORBA_boolean ORBit_any_equivalent(
+	CORBA_any obj,
+	CORBA_any any,
+	CORBA_Environment *ev);
+
+extern CORBA_char *CORBA_string_dup(const CORBA_char *string);
+extern CORBA_char *CORBA_string_alloc(CORBA_unsigned_long len);
+extern gpointer CORBA_string__free(gpointer str, gpointer dat, CORBA_boolean free_strings);
+
+gpointer CORBA_Object__free(gpointer str, gpointer dat, CORBA_boolean free_strings);
+
+extern CORBA_wchar *CORBA_wstring_alloc(CORBA_unsigned_long len);
+#define CORBA_wstring_free CORBA_string_free
+
+/* 19.14 */
+extern CORBA_long CORBA_fixed_integer_part(
+	const void *fp);
+
+extern CORBA_long CORBA_fixed_fraction_part(
+	const void *fp);
+
+extern void CORBA_fixed_set(
+	void *rp,
+	CORBA_long i,
+	CORBA_long f);
+
+extern void CORBA_fixed_add(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern void CORBA_fixed_sub(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern void CORBA_fixed_mul(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern void CORBA_fixed_div(
+	void *rp,
+	const void *f1p,
+	const void *f2p);
+
+extern CORBA_fixed_d_s *CORBA_fixed_alloc(
+	CORBA_unsigned_short d);
+
+extern void CORBA_free(
+	void *storage);
+
+extern int ORBit_parse_inet(
+	CORBA_Object obj,
+	char *hostname,
+	unsigned short port,
+	gboolean existing_only);
+
+extern int ORBit_parse_unixsock(CORBA_Object obj,
+				char *sockpath,
+				gboolean existing_only);
+
+/****
+     This function lets you use your own event loop, if you so wish.
+     Also see IIOP.h's IIOP{Add,Remove}ConnectionHandler function pointers,
+     which are app-settable (you should set them before CORBA_ORB_init,
+     if you want them to be useful)
+ ****/
+
+    /* needs to be called by your event loop when data comes in on one of the
+       GIOPConnection fd's */
+void ORBit_custom_run_setup(CORBA_ORB orb, CORBA_Environment *ev);
+	void ORBit_handle_incoming(GIOPConnection *connection);
+
+/* Returns CORBA_TRUE if the request is OK to proceed. */
+typedef enum {
+	ORBIT_MESSAGE_BAD,
+	ORBIT_MESSAGE_ALLOW,
+	ORBIT_MESSAGE_ALLOW_ALL /* Allow all subsequent messages on
+				   this connection with no checking */
+} ORBit_MessageValidationResult;
+typedef ORBit_MessageValidationResult (*ORBit_request_validate)
+	     (CORBA_unsigned_long request_id,
+	      CORBA_Principal *principal,
+	      CORBA_char *operation);
+void ORBit_set_request_validation_handler(ORBit_request_validate validator);
+
+extern struct iovec ORBit_default_principal_iovec;
+void ORBit_set_default_principal(CORBA_Principal *principal);
+
+extern CORBA_unsigned_long ORBit_class_assignment_counter;
+
+CORBA_unsigned_long ORBit_register_class(const PortableServer_ClassInfo *class_info);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif	/* !_ORBIT_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orbit_config.h linux-2.4.1-korbit/net/korbit/orb/orbit_config.h
--- linux-2.4.1/net/korbit/orb/orbit_config.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_config.h	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,9 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+#ifndef ORB_CONFIG_H
+#define ORB_CONFIG_H 1
+
+/* When creating a memory pool for a particular type, how many chunks
+   do we want to pre-allocated? */
+#define ORBIT_CHUNKS_PREALLOC 2
+
+#endif /* ORB_CONFIG_H */
diff -urN linux-2.4.1/net/korbit/orb/orbit_object.c linux-2.4.1-korbit/net/korbit/orb/orbit_object.c
--- linux-2.4.1/net/korbit/orb/orbit_object.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_object.c	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,699 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Phil Dawes <philipd@parallax.co.uk>
+ *          Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+/*
+ *   ORBit specific CORBA_Object functions.
+ *
+ */
+
+#include <string.h>
+#include "config.h"
+#include "../IIOP/iiop-endianP.h"
+#include "orbit_object_type.h"
+#include "corba_object_type.h"
+#include "allocators.h"
+#include "iop.h"
+#include <IIOP/IIOP.h>
+
+static void ORBit_object_try_existing_connections(CORBA_Object obj);
+static void CORBA_Object_release_fn(CORBA_Object obj, CORBA_Environment *ev);
+
+static ORBit_RootObject_Interface CORBA_Object_epv =
+{
+	(void (*)(gpointer, CORBA_Environment *))CORBA_Object_release_fn,
+};
+
+void ORBit_pseudo_object_init(ORBit_PseudoObject obj,
+			      ORBit_PseudoObject_type obj_type,
+			      CORBA_Environment *ev)
+{
+	ORBIT_ROOT_OBJECT(obj)->is_pseudo_object = TRUE;
+	ORBIT_ROOT_OBJECT(obj)->refs = 0;
+	ORBIT_PSEUDO_OBJECT(obj)->pseudo_object_type = obj_type;
+}
+
+static const ORBit_RootObject_Interface CORBA_Policy__epv =
+{
+	(void (*)(gpointer, CORBA_Environment *))CORBA_Policy_destroy
+};
+
+void ORBit_policy_object_init(CORBA_Policy obj,
+			      CORBA_PolicyType obj_type,
+			      CORBA_Environment *ev)
+{
+	ORBit_pseudo_object_init(ORBIT_PSEUDO_OBJECT(obj),
+				 ORBIT_PSEUDO_POLICY, ev);
+
+	obj->policy_type = obj_type;
+
+	ORBit_RootObject_set_interface(ORBIT_ROOT_OBJECT(obj),
+				       (gpointer)&CORBA_Policy__epv,
+				       ev);
+}
+
+void ORBit_object_reference_init(CORBA_Object obj, CORBA_Environment *ev)
+{
+	/* set the interface up */
+	ORBit_RootObject_set_interface(ORBIT_ROOT_OBJECT(obj),&CORBA_Object_epv,ev);
+	/* initialise the reference count */
+	ORBIT_ROOT_OBJECT(obj)->refs = 0; 
+	ORBIT_ROOT_OBJECT(obj)->is_pseudo_object = FALSE;
+}
+
+CORBA_Object 
+ORBit_CORBA_Object_new(CORBA_Environment *ev)
+{
+	CORBA_Object obj;
+	/* Create the object */
+	obj = ORBIT_CHUNK_ALLOC(CORBA_Object);
+	memset(obj, '\0', sizeof(struct CORBA_Object_struct));
+
+	ORBit_object_reference_init(obj, ev);
+
+	return obj;
+
+}
+
+void
+ORBit_set_object_key(ORBit_Object_info *info)
+{
+	g_assert(info);
+
+	g_assert(info->object_key._length);
+
+	info->object_key_data = g_malloc(sizeof(CORBA_unsigned_long) + info->object_key._length);
+	info->object_key_data->_length = info->object_key._length;
+	memcpy(info->object_key_data->_buffer, info->object_key._buffer, info->object_key._length);
+
+	info->object_key_vec.iov_base =
+		(gpointer)info->object_key_data;
+	info->object_key_vec.iov_len = sizeof(CORBA_unsigned_long) + info->object_key._length;
+}
+
+static void ORBit_free_profile(gpointer item, gpointer data)
+{
+	ORBit_Object_info *info=(ORBit_Object_info *)item;
+
+	g_assert(info);
+
+	g_free(info->object_key_data);
+	CORBA_free(info->object_key._buffer);
+
+	if(info->profile_type == IOP_TAG_INTERNET_IOP) {
+		g_free(info->tag.iopinfo.host);
+	} else if(info->profile_type == IOP_TAG_ORBIT_SPECIFIC) {
+		g_free(info->tag.orbitinfo.unix_sock_path);
+	} else {
+		g_warning("ORBit_free_profile asked to free type %d", info->profile_type);
+	}
+
+	g_free(info);	/* Check its safe to free the item within a foreach func */
+}
+
+void ORBit_delete_profiles(GSList *profile_list)
+{
+	g_slist_foreach(profile_list, ORBit_free_profile, NULL);
+	g_slist_free(profile_list);
+}
+
+/* this function is wired up to the RootObject interface */
+void 
+CORBA_Object_release_fn(CORBA_Object obj, CORBA_Environment *ev)
+{
+
+	g_assert(obj!=NULL);
+
+	ORBIT_ROOT_OBJECT_UNREF(obj);
+
+	if(ORBIT_ROOT_OBJECT(obj)->refs <= 0) {
+		g_hash_table_remove(obj->orb->objrefs, obj);
+		
+		if(obj->connection)
+			giop_connection_unref(obj->connection);
+
+		g_free(obj->object_id);
+		ORBit_delete_profiles(obj->profile_list);
+		ORBit_delete_profiles(obj->forward_locations);
+
+		ORBIT_CHUNK_FREE(CORBA_Object, obj);
+	}
+}
+
+
+/* Sets the interface member in the RootObject to the epv specified*/
+void
+ORBit_RootObject_set_interface(ORBit_RootObject obj,
+			       ORBit_RootObject_Interface* epv,
+			       CORBA_Environment *ev)
+{
+	g_assert(obj!=NULL);
+	g_assert(epv!=NULL);
+
+	obj->interface = epv;
+}
+
+#define GET_ATOM(x) G_STMT_START{ GIOP_RECV_BUFFER(recv_buffer)->decoder(&x, (GIOP_RECV_BUFFER(recv_buffer)->cur), sizeof(x)); \
+GIOP_RECV_BUFFER(recv_buffer)->cur = ((guchar *)GIOP_RECV_BUFFER(recv_buffer)->cur) + sizeof(x); \
+}G_STMT_END
+#define ALIGNFOR(x) recv_buffer->cur = ALIGN_ADDRESS(recv_buffer->cur, sizeof(x))
+
+CORBA_Object
+ORBit_create_object_with_info(GSList *profiles,
+			      const CORBA_char *type_id,
+			      CORBA_ORB orb,
+			      CORBA_Environment *ev)
+{
+	CORBA_Object new;
+	struct CORBA_Object_struct refcheck;
+
+	if(!type_id || !*type_id) {
+		g_warning("Failing object creation because object has no type");
+		CORBA_exception_set_system(ev, ex_CORBA_MARSHAL,
+					   CORBA_COMPLETED_MAYBE);
+		return CORBA_OBJECT_NIL;
+	}
+
+	if(g_slist_length(profiles) < 1) {
+		g_warning("Failing object creation because object has no profiles");
+		CORBA_exception_set_system(ev, ex_CORBA_MARSHAL,
+					   CORBA_COMPLETED_MAYBE);
+		return CORBA_OBJECT_NIL;
+	}
+
+	/* XXX badhack :) */
+	refcheck.object_id = type_id;
+	refcheck.profile_list = profiles;
+
+	new = g_hash_table_lookup(orb->objrefs, &refcheck);
+	if(new) {
+		ORBit_delete_profiles(profiles);
+		return CORBA_Object_duplicate(new, ev);
+	}
+
+	new = ORBit_CORBA_Object_new(ev);
+	new->connection = NULL;
+ 	new->object_id = g_strdup(type_id);
+	new->orb = (CORBA_ORB)CORBA_Object_duplicate((CORBA_Object)orb, ev);
+	new->profile_list = profiles;
+	new->active_profile = NULL;
+
+	ORBit_object_try_existing_connections(new);
+
+	g_hash_table_insert(orb->objrefs, new, new);
+	
+	return CORBA_Object_duplicate(new, ev);
+}
+
+static ORBit_Object_info *
+ORBit_demarshal_profile(GIOPRecvBuffer *recv_buffer, IOP_ProfileId profile_id)
+{
+	ORBit_Object_info *object_info;
+	CORBA_unsigned_long subpart_len;
+	CORBA_octet o;
+	CDR_Codec codec_d;
+	CDR_Codec *codec=&codec_d;
+
+	object_info = g_new0(ORBit_Object_info, 1);
+
+	switch(profile_id) {
+	case IOP_TAG_INTERNET_IOP:
+		GET_ATOM(subpart_len); /* The length of the embedded sequence */
+		CDR_codec_init_static(codec);
+		codec->buffer = recv_buffer->cur;
+		codec->release_buffer = CORBA_FALSE;
+		recv_buffer->cur = ((guchar *)recv_buffer->cur) + subpart_len;
+
+		codec->readonly = CORBA_TRUE;
+		codec->host_endian = codec->data_endian = FLAG_ENDIANNESS;
+		codec->buf_len = subpart_len;
+
+		CDR_get_octet(codec, &o);
+		codec->data_endian = o;
+
+		object_info->profile_type = IOP_TAG_INTERNET_IOP;
+		CDR_get_octet(codec, &object_info->iiop_major);
+
+		if(object_info->iiop_major != 1)
+			goto error_exit;
+		/* XXX should we check for a specific minor version? */
+		CDR_get_octet(codec, &object_info->iiop_minor);
+
+		CDR_get_string(codec, &object_info->tag.iopinfo.host);
+
+		CDR_get_ushort(codec, &object_info->tag.iopinfo.port);
+
+		CDR_get_seq_begin(codec, &object_info->object_key._length);
+		object_info->object_key._buffer =
+			ORBit_alloc(object_info->object_key._length, NULL, NULL);
+		CDR_buffer_gets(codec, object_info->object_key._buffer,
+				object_info->object_key._length);
+		object_info->object_key._maximum = object_info->object_key._release = 0;
+
+		ORBit_set_object_key(object_info);
+
+		return(object_info);
+		break;
+
+	case IOP_TAG_MULTIPLE_COMPONENTS:
+	default:
+		GET_ATOM(subpart_len);
+		g_warning("IOP_TAG_MULTIPLE_COMPONENTS decoding needs finishing");
+		object_info->profile_type = IOP_TAG_MULTIPLE_COMPONENTS;
+		recv_buffer->cur = ((guchar *)recv_buffer->cur) + subpart_len;
+		return(object_info);
+		break;
+
+	case IOP_TAG_ORBIT_SPECIFIC:
+		GET_ATOM(subpart_len);
+		CDR_codec_init_static(codec);
+		codec->buffer = recv_buffer->cur;
+		codec->release_buffer = CORBA_FALSE;
+		recv_buffer->cur = ((guchar *)recv_buffer->cur) + subpart_len;
+
+		codec->readonly = CORBA_TRUE;
+		codec->host_endian = codec->data_endian = FLAG_ENDIANNESS;
+		codec->buf_len = subpart_len;
+
+		CDR_get_octet(codec, &o);
+		codec->data_endian = o;
+
+		object_info->profile_type = IOP_TAG_ORBIT_SPECIFIC;
+		CDR_get_octet(codec, &object_info->iiop_major);
+
+		if(object_info->iiop_major != 1)
+			goto error_exit;
+		/* XXX should we check for a specific minor version? */
+		CDR_get_octet(codec, &object_info->iiop_minor);
+
+		CDR_get_string(codec, &object_info->tag.orbitinfo.unix_sock_path);
+		CDR_get_ushort(codec, &object_info->tag.orbitinfo.ipv6_port);
+
+		CDR_get_seq_begin(codec, &object_info->object_key._length);
+		object_info->object_key._buffer =
+			ORBit_alloc(object_info->object_key._length, NULL, NULL);
+		CDR_buffer_gets(codec, object_info->object_key._buffer,
+				object_info->object_key._length);
+		object_info->object_key._maximum = object_info->object_key._release = 0;
+
+		ORBit_set_object_key(object_info);
+
+		return(object_info);
+		break;
+	}
+
+error_exit:
+	g_message("demarshal_profile(): IIOP major is %d",
+		  object_info->iiop_major);
+	g_free(object_info);
+
+	return(NULL);
+}
+
+GSList *ORBit_demarshal_IOR(GIOPRecvBuffer *recv_buffer)
+{
+	GSList *profiles=NULL;
+	ORBit_Object_info *object_info;
+	CORBA_unsigned_long len, seq_len;
+	IOP_ProfileId profile_id;
+	int i;
+
+	/* Get type_id */
+	ALIGNFOR(CORBA_unsigned_long);
+	GET_ATOM(len);
+
+	if(len == 0)
+		return(NULL);
+
+	recv_buffer->cur = ((guchar *)recv_buffer->cur) + len;
+
+	/* Decode the sequence<TaggedProfile> */
+	ALIGNFOR(CORBA_unsigned_long);
+	GET_ATOM(seq_len);
+	for(i = 0; i < seq_len; i++) {
+		ALIGNFOR(CORBA_unsigned_long);
+		GET_ATOM(profile_id);
+		object_info=ORBit_demarshal_profile(recv_buffer, profile_id);
+		if(object_info==NULL) {
+			goto error_exit;
+		} else {
+			profiles=g_slist_append(profiles, object_info);
+		}
+	}
+
+	return(profiles);
+
+error_exit:
+	ORBit_delete_profiles(profiles);
+	return(NULL);
+}
+
+CORBA_Object
+ORBit_demarshal_object(GIOPRecvBuffer *recv_buffer, CORBA_ORB orb)
+{
+	GSList *profiles=NULL;
+	ORBit_Object_info *object_info;
+	CORBA_char *type_id;
+	CORBA_unsigned_long len, seq_len;
+	IOP_ProfileId profile_id;
+	int i;
+	CORBA_Environment ev;
+	CORBA_Object retval;
+
+	CORBA_exception_init(&ev);
+
+	/* Get type_id */
+	ALIGNFOR(CORBA_unsigned_long);
+	GET_ATOM(len);
+
+	type_id = recv_buffer->cur;
+	recv_buffer->cur = ((guchar *)recv_buffer->cur) + len;
+
+	/* Decode the sequence<TaggedProfile> */
+	ALIGNFOR(CORBA_unsigned_long);
+	GET_ATOM(seq_len);
+
+	if(!seq_len)
+		return CORBA_OBJECT_NIL;
+
+	for(i = 0; i < seq_len; i++) {
+		ALIGNFOR(CORBA_unsigned_long);
+		GET_ATOM(profile_id);
+		object_info=ORBit_demarshal_profile(recv_buffer, profile_id);
+		if(object_info)
+			profiles=g_slist_append(profiles, object_info);
+	}
+
+	if(!profiles)
+		goto error_exit;
+
+	retval = ORBit_create_object_with_info(profiles, type_id, orb, &ev);
+
+	return retval;
+
+ error_exit:
+	ORBit_delete_profiles(profiles);
+
+	CORBA_exception_set_system(&ev, ex_CORBA_MARSHAL,
+				   CORBA_COMPLETED_MAYBE);
+	return CORBA_OBJECT_NIL;
+}
+
+static void ORBit_marshal_profile(gpointer item, gpointer data)
+{
+	ORBit_Object_info *info = (ORBit_Object_info *)item;
+	GIOPSendBuffer *send_buffer = (GIOPSendBuffer *)data;
+	static const CORBA_unsigned_long ioptag = IOP_TAG_INTERNET_IOP,
+		orbittag = IOP_TAG_ORBIT_SPECIFIC;
+	CDR_Codec codec_d;
+	CDR_Codec *codec = &codec_d;
+	CORBA_unsigned_long len;
+	CORBA_octet codecbuf[2048];
+	static const CORBA_octet oc_endian = FLAG_ENDIANNESS;
+	static const CORBA_octet iiopversion[] = {1,0};
+
+	g_assert(info);
+	g_assert(send_buffer);
+
+	if(info->profile_type == IOP_TAG_INTERNET_IOP) {
+		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(send_buffer),
+					       &ioptag, sizeof(ioptag));
+
+		CDR_codec_init_static(codec);
+		codec->buffer = codecbuf;
+		codec->buf_len = 2048;
+		codec->release_buffer = CORBA_FALSE;
+		codec->readonly = CORBA_FALSE;
+		codec->data_endian = codec->host_endian = FLAG_ENDIANNESS;
+		CDR_put_octet(codec, oc_endian);
+		CDR_put_octet(codec, iiopversion[0]);
+		CDR_put_octet(codec, iiopversion[1]);
+		CDR_put_string(codec, info->tag.iopinfo.host);
+		CDR_put_ushort(codec, info->tag.iopinfo.port);
+		CDR_put_ulong(codec, info->object_key._length);
+		CDR_put_octets(codec, info->object_key._buffer,
+			       info->object_key._length);
+		len = codec->wptr;
+		giop_send_buffer_append_mem_indirect_a(send_buffer,
+						       &len, sizeof(len));
+		giop_send_buffer_append_mem_indirect(send_buffer,
+						     codec->buffer, codec->wptr);
+	} else if(info->profile_type==IOP_TAG_ORBIT_SPECIFIC) {
+		giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(send_buffer),
+						 &orbittag, sizeof(orbittag));
+		CDR_codec_init_static(codec);
+		codec->buffer = codecbuf;
+		codec->release_buffer = CORBA_FALSE;
+		codec->buf_len = 2048;
+		codec->readonly = CORBA_FALSE;
+		codec->data_endian = codec->host_endian = FLAG_ENDIANNESS;
+		CDR_put_octet(codec, oc_endian);
+		CDR_put_octets(codec, (gpointer)iiopversion, sizeof(iiopversion));
+		CDR_put_string(codec, info->tag.orbitinfo.unix_sock_path);
+		CDR_put_ushort(codec, info->tag.orbitinfo.ipv6_port);
+		CDR_put_ulong(codec, info->object_key._length);
+		CDR_put_octets(codec, info->object_key._buffer,
+			       info->object_key._length);
+		len = codec->wptr;
+		giop_send_buffer_append_mem_indirect_a(send_buffer,
+						       &len, sizeof(len));
+		giop_send_buffer_append_mem_indirect(send_buffer,
+						     codec->buffer, codec->wptr);
+	} else {
+		g_warning("ORBit_marshal_profile ask to marshal type %d\n", info->profile_type);
+	}
+}
+
+void
+ORBit_marshal_object(GIOPSendBuffer *send_buffer, CORBA_Object obj)
+{
+	CORBA_unsigned_long len;
+
+
+	if(!obj) {
+		static const CORBA_unsigned_long zero = 0, one = 1;
+		/* zero-length typename */
+		giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(send_buffer),
+						 &one, sizeof(one));
+		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(send_buffer),
+					       &zero, 1);
+
+		/* zero profiles */
+		giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(send_buffer),
+						 &zero, sizeof(zero));
+		return;
+	}
+	g_return_if_fail(ORBIT_ROOT_OBJECT(obj)->refs > 0);
+
+	len = strlen(obj->object_id) + 1;
+	giop_send_buffer_append_mem_indirect_a(send_buffer, &len,
+					       sizeof(len));
+	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(send_buffer),
+				       obj->object_id, len);
+
+	len = g_slist_length(obj->profile_list);
+	giop_send_buffer_append_mem_indirect_a(GIOP_SEND_BUFFER(send_buffer),
+					       &len, sizeof(len));
+
+	/* Marshal active first? */
+	g_slist_foreach(obj->profile_list, ORBit_marshal_profile, send_buffer);
+}
+
+static void ORBit_test_profile(gpointer item, gpointer data)
+{
+	ORBit_Object_info *info = (ORBit_Object_info *)item;
+	CORBA_Object obj = (CORBA_Object)data;
+
+	if(obj->active_profile != NULL)
+		return;		/* we already have a good profile */
+
+	if(info->profile_type == IOP_TAG_ORBIT_SPECIFIC) {
+		if(!ORBit_parse_unixsock(obj, info->tag.orbitinfo.unix_sock_path, TRUE)) {
+			/* success */
+			obj->active_profile=info;
+		}
+	} else if(info->profile_type == IOP_TAG_INTERNET_IOP) {
+		if(!ORBit_parse_inet(obj, info->tag.iopinfo.host, info->tag.iopinfo.port, TRUE)) {
+			/* success */
+			obj->active_profile=info;
+		}
+	}
+}
+
+static void
+ORBit_object_try_existing_connections(CORBA_Object obj)
+{
+	g_slist_foreach(obj->profile_list, ORBit_test_profile, obj);
+}
+
+static void ORBit_activate_profile(gpointer item, gpointer data)
+{
+	ORBit_Object_info *info = (ORBit_Object_info *)item;
+	CORBA_Object obj = (CORBA_Object)data;
+
+	if(obj->active_profile != NULL)
+		return;		/* we already have a good profile */
+
+	if(info->profile_type == IOP_TAG_ORBIT_SPECIFIC) {
+		if(!ORBit_parse_unixsock(obj, info->tag.orbitinfo.unix_sock_path, FALSE)) {
+			/* success */
+			obj->active_profile=info;
+		}
+	} else if(info->profile_type == IOP_TAG_INTERNET_IOP) {
+		if(!ORBit_parse_inet(obj, info->tag.iopinfo.host, info->tag.iopinfo.port, FALSE)) {
+			/* success */
+			obj->active_profile=info;
+		}
+	}
+}
+
+GIOPConnection *
+_ORBit_object_get_connection(CORBA_Object obj)
+{
+	g_return_val_if_fail(obj, NULL);
+
+	if (obj->connection) {
+		giop_connection_unref(obj->connection);
+		obj->connection = NULL;
+		obj->active_profile = NULL;
+	}
+
+	g_slist_foreach(obj->profile_list, ORBit_activate_profile, obj);
+
+	if(obj->active_profile == NULL || !obj->connection)
+		return NULL;
+
+	obj->connection->orb_data = obj->orb;
+
+	return obj->connection;
+}
+
+GIOPConnection *
+ORBit_object_get_forwarded_connection(CORBA_Object obj)
+{
+	g_return_val_if_fail(obj, NULL);
+
+	if (obj->connection) {
+		giop_connection_unref(obj->connection);
+		obj->connection = NULL;
+		obj->active_profile = NULL;
+	}
+
+	g_slist_foreach(obj->forward_locations, ORBit_activate_profile, obj);
+
+	if(obj->active_profile == NULL || !obj->connection)
+		return NULL;
+
+	obj->connection->orb_data = obj->orb;
+
+	return obj->connection;
+}
+
+/* This function is heavily based on the idl stubs output. Any changes there
+   will probably have to be reflected here also. */
+
+void ORBit_object_locate(CORBA_Object obj, CORBA_Environment *ev)
+{
+	GIOPConnection *cnx;
+	GIOPSendBuffer *send_buffer;
+	GIOPRecvBuffer *recv_buffer;
+	GIOP_unsigned_long request_id;
+
+	g_return_if_fail(obj!=NULL);
+	g_return_if_fail(ev!=NULL);
+
+	/* Send a LOCATE_REQUEST, wait for a LOCATE_REPLY. The reply will
+	   either say "Object here", or will carry a new location. We set
+	   obj->active_profile appropriately */
+
+	cnx=ORBit_object_get_connection(obj);
+	if((cnx==NULL) || (obj->active_profile==NULL)) {
+		CORBA_exception_set_system(ev, ex_CORBA_COMM_FAILURE, CORBA_COMPLETED_NO);
+		return;
+	}
+	request_id=giop_get_request_id();
+	send_buffer=giop_send_locate_request_buffer_use(cnx, request_id, &(obj->active_profile->object_key_vec));
+	if(!send_buffer) {
+		CORBA_exception_set_system(ev, ex_CORBA_COMM_FAILURE, CORBA_COMPLETED_NO);
+		return;
+	}
+
+	giop_send_buffer_write(send_buffer);
+	giop_send_buffer_unuse(send_buffer);
+
+	recv_buffer=giop_recv_locate_reply_buffer_use(request_id, TRUE);
+	if(recv_buffer==NULL || recv_buffer->message_buffer.message_header.message_type!=GIOP_LOCATEREPLY) {
+		CORBA_exception_set_system(ev, ex_CORBA_COMM_FAILURE, CORBA_COMPLETED_MAYBE);
+		if(recv_buffer)
+			giop_recv_buffer_unuse(recv_buffer);
+		
+		return;
+	}
+
+	ev->_major=CORBA_NO_EXCEPTION;
+	switch(recv_buffer->message.u.locate_reply.locate_status) {
+	case GIOP_UNKNOWN_OBJECT:
+		CORBA_exception_set_system(ev, ex_CORBA_OBJECT_NOT_EXIST, CORBA_COMPLETED_NO);
+		break;
+
+	case GIOP_OBJECT_HERE:
+		/* No further processing necessary */
+		break;
+
+	case GIOP_OBJECT_FORWARD:
+		/* We've been forwarded onto somewhere else. The message body
+		   contains the new IOR */
+		if(obj->forward_locations != NULL) {
+			ORBit_delete_profiles(obj->forward_locations);
+		}
+		obj->forward_locations=ORBit_demarshal_IOR(recv_buffer);
+
+		/* This will adjust obj->active_profile */
+		cnx=ORBit_object_get_forwarded_connection(obj);
+		break;
+
+	default:
+		g_message("Bad Reply in ORBit_locate_object()\n");
+		break;
+
+	}
+
+	giop_recv_buffer_unuse(recv_buffer);
+}
+
+GIOPConnection *
+ORBit_handle_location_forward(GIOPRecvBuffer *rb, CORBA_Object obj)
+{
+	GIOPConnection *retval;
+
+	if(obj->forward_locations)
+		ORBit_delete_profiles(obj->forward_locations);
+	obj->forward_locations = ORBit_demarshal_IOR(rb);
+
+	retval = ORBit_object_get_forwarded_connection(obj);
+	giop_recv_buffer_unuse(rb);
+
+	return retval;
+}
diff -urN linux-2.4.1/net/korbit/orb/orbit_object.h linux-2.4.1-korbit/net/korbit/orb/orbit_object.h
--- linux-2.4.1/net/korbit/orb/orbit_object.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_object.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,114 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Phil Dawes <philipd@parallax.co.uk>
+ *
+ */
+
+/*
+ *   ORBit specific CORBA_Object funcitons.
+ *
+ */
+#ifndef _ORBIT_ORBIT_OBJECT_H_
+#define _ORBIT_ORBIT_OBJECT_H_
+
+#include <IIOP/IIOP.h>
+#include "corba_object.h"
+
+extern CORBA_Object ORBit_CORBA_Object_new(CORBA_Environment *ev);
+extern void ORBit_CORBA_Object_free(CORBA_Object obj, CORBA_Environment *ev);
+
+
+typedef enum {
+	ORBIT_PSEUDO_ORB,
+	ORBIT_PSEUDO_POA,
+	ORBIT_PSEUDO_POAMANAGER,
+	ORBIT_PSEUDO_POLICY,
+	ORBIT_PSEUDO_TYPECODE,
+	ORBIT_PSEUDO_REQUEST,
+	ORBIT_PSEUDO_SERVERREQUEST,
+	ORBIT_PSEUDO_CONTEXT
+} ORBit_PseudoObject_type;
+typedef struct ORBit_PseudoObject_struct *ORBit_PseudoObject;
+
+void ORBit_pseudo_object_init(ORBit_PseudoObject obj,
+			      ORBit_PseudoObject_type obj_type,
+			      CORBA_Environment *ev);
+void ORBit_policy_object_init(CORBA_Policy obj,
+			      CORBA_PolicyType obj_type,
+			      CORBA_Environment *ev);
+
+/* Use ORBit_CORBA_Object_new() */
+void ORBit_object_reference_init(CORBA_Object obj, CORBA_Environment *ev);
+
+typedef struct {
+	CORBA_char *host;
+	CORBA_unsigned_short port;
+} TAG_INTERNET_IOP_info;
+
+typedef struct {
+	CORBA_char *unix_sock_path;
+	CORBA_unsigned_short ipv6_port;
+} TAG_ORBIT_SPECIFIC_info;
+
+typedef struct {
+	int fill_me_in;
+} TAG_MULTIPLE_COMPONENTS_info;
+
+typedef struct {
+	CORBA_octet iiop_major, iiop_minor;
+	IOP_ProfileId profile_type;
+	union {
+		TAG_INTERNET_IOP_info iopinfo;
+		TAG_ORBIT_SPECIFIC_info orbitinfo;
+		TAG_MULTIPLE_COMPONENTS_info mcinfo;
+	} tag;
+
+	/* If the object key is invariant wrt to the various profiles, then
+	   this should probably go in CORBA_Object_struct
+	 */
+	CORBA_sequence_octet object_key;
+	struct { CORBA_unsigned_long _length; char _buffer[1]; } *object_key_data;
+	struct iovec object_key_vec;
+} ORBit_Object_info;
+
+void ORBit_set_object_key(ORBit_Object_info *info);
+
+CORBA_Object ORBit_create_object_with_info(GSList *profiles,
+					   const CORBA_char *type_id,
+					   CORBA_ORB orb,
+					   CORBA_Environment *ev);
+
+#define ORBit_object_get_connection(obj) \
+     ((obj)->connection && (obj)->connection->is_valid)?((obj)->connection):_ORBit_object_get_connection(obj)
+GIOPConnection *_ORBit_object_get_connection(CORBA_Object obj);
+GIOPConnection *ORBit_object_get_forwarded_connection(CORBA_Object obj);
+void ORBit_object_locate(CORBA_Object obj, CORBA_Environment *ev);
+
+void ORBit_marshal_object(GIOPSendBuffer *send_buffer, CORBA_Object obj);
+CORBA_Object ORBit_demarshal_object(GIOPRecvBuffer *recv_buffer,
+				    CORBA_ORB orb);
+GSList *ORBit_demarshal_IOR(GIOPRecvBuffer *recv_buffer);
+
+extern void ORBit_delete_profiles(GSList *profile_list);
+GIOPConnection *ORBit_handle_location_forward(GIOPRecvBuffer *rb, CORBA_Object obj);
+
+#endif /* _ORBIT_ORBIT_OBJECT_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orbit_object_type.h linux-2.4.1-korbit/net/korbit/orb/orbit_object_type.h
--- linux-2.4.1/net/korbit/orb/orbit_object_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_object_type.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,87 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *	  Philip Dawes
+ *	  Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+#ifndef _ORBIT_ORBIT_OBJECT_TYPE_H_
+#define _ORBIT_ORBIT_OBJECT_TYPE_H_
+
+#include "orbit_object.h"
+
+
+/****** Root object **********/
+/*****************************/
+
+typedef struct ORBit_RootObject_Interface_struct ORBit_RootObject_Interface;
+struct ORBit_RootObject_Interface_struct
+{
+	void (*release)(gpointer obj, CORBA_Environment *ev);
+};
+
+
+
+#define ORBIT_ROOT_OBJECT(x) ((ORBit_RootObject)(x))
+
+
+typedef struct ORBit_RootObject_struct *ORBit_RootObject;
+struct ORBit_RootObject_struct {
+	ORBit_RootObject_Interface* interface; /* the interface */
+
+	guchar is_pseudo_object;
+	gint refs;
+};
+
+
+/* Reference counting interface */
+
+#define ORBIT_ROOT_OBJECT_REF(obj) (ORBIT_ROOT_OBJECT(obj)->refs++)
+#define ORBIT_ROOT_OBJECT_UNREF(obj) (ORBIT_ROOT_OBJECT(obj)->refs--)
+
+
+     /* Virtual function interface*/
+
+#define ORBIT_ROOT_OBJECT_release(obj,ev) \
+(ORBIT_ROOT_OBJECT(obj)->interface->release(obj,ev))
+
+
+
+extern void ORBit_RootObject_set_interface(ORBit_RootObject obj,
+					   ORBit_RootObject_Interface* epv,
+					   CORBA_Environment *ev);
+
+
+
+/****** Pseudo object --> RootObject ********/
+/*********************************************/
+
+#define ORBIT_PSEUDO_OBJECT(x) ((ORBit_PseudoObject)(x))
+
+struct ORBit_PseudoObject_struct {
+	struct ORBit_RootObject_struct parent;
+	ORBit_PseudoObject_type pseudo_object_type;
+};
+
+
+#endif /* !_ORBIT_CORBA_OBJECT_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orbit_poa.c linux-2.4.1-korbit/net/korbit/orb/orbit_poa.c
--- linux-2.4.1/net/korbit/orb/orbit_poa.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_poa.c	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,809 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Phil Dawes <philipd@parallax.co.uk>
+ *	    Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+/*
+ *   ORBit specific POA funcitons.
+ *
+ */
+
+#include <string.h>
+#include "orbit.h"
+#include "orbit_poa_type.h"
+#include "orbit_poa.h"
+#include "genrand.h"
+
+#define POA_KEY_LEN (sizeof(CORBA_unsigned_long) + ORBIT_RAND_KEY_LEN)
+#define OBJ_KEY_LEN (sizeof(CORBA_unsigned_long) + ORBIT_RAND_KEY_LEN)
+
+static void ORBit_POAManager_release(PortableServer_POAManager poa_mgr,
+				     CORBA_Environment *ev);
+
+static void ORBit_POA_release(PortableServer_POA poa,
+			      CORBA_Environment *ev);
+
+static PortableServer_Servant
+ORBit_POA_ServantManager_use_servant(PortableServer_POA poa,
+				     GIOPRecvBuffer *recv_buffer,
+				     PortableServer_ServantLocator_Cookie *the_cookie,
+				     PortableServer_ObjectId *oid,
+				     ORBit_POAObject *fake_obj_impl,
+				     CORBA_Environment *ev);
+static void
+ORBit_POA_ServantManager_unuse_servant(PortableServer_Servant servant,
+				       PortableServer_POA poa,
+				       GIOPRecvBuffer *recv_buffer,
+				       PortableServer_ServantLocator_Cookie cookie,
+				       PortableServer_ObjectId *oid,
+				       ORBit_POAObject *fake_obj_impl,
+				       CORBA_Environment *ev);
+
+static const ORBit_RootObject_Interface CORBA_POAManager_epv =
+{
+	(void (*)(gpointer, CORBA_Environment *))ORBit_POAManager_release,
+};
+
+static const ORBit_RootObject_Interface CORBA_POA_epv =
+{
+	(void (*)(gpointer, CORBA_Environment *))ORBit_POA_release,
+};
+
+guint
+g_sequence_octet_hash(CORBA_sequence_octet *so)
+{
+  const char *s = (char*)so->_buffer;
+  const char *p, *e = ((char *)so->_buffer) + so->_length;
+  guint h=0, g;
+
+  for(p = s; p < e; p ++) {
+    h = ( h << 4 ) + *p;
+    if ( ( g = h & 0xf0000000 ) ) {
+      h = h ^ (g >> 24);
+      h = h ^ g;
+    }
+  }
+
+  return h;
+}
+
+gint
+g_sequence_octet_compare(CORBA_sequence_octet *s1, CORBA_sequence_octet *s2)
+{
+	if(s2->_length != s1->_length)
+		return FALSE;
+
+	return !memcmp(s1->_buffer, s2->_buffer, s1->_length);
+}
+
+PortableServer_POAManager 
+ORBit_POAManager_new(CORBA_Environment *ev)
+{
+	PortableServer_POAManager poa_mgr;
+
+	poa_mgr = g_new0(struct PortableServer_POAManager_type, 1);
+
+	if(poa_mgr == NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+		goto error;
+	}
+
+	/* Initialise poa manager */
+
+	ORBit_pseudo_object_init(ORBIT_PSEUDO_OBJECT(poa_mgr),
+				 ORBIT_PSEUDO_POAMANAGER, ev);
+	ORBIT_ROOT_OBJECT(poa_mgr)->refs = 0;
+	ORBit_RootObject_set_interface(ORBIT_ROOT_OBJECT(poa_mgr),
+				       (gpointer)&CORBA_POAManager_epv, ev);
+
+	poa_mgr->poa_collection = NULL;
+	poa_mgr->state = PortableServer_POAManager_HOLDING;
+
+	return poa_mgr;
+
+error:
+	if(poa_mgr != NULL){
+		ORBit_POAManager_release(poa_mgr, ev);
+	}
+	return NULL;
+}
+
+static void
+ORBit_POAManager_release(PortableServer_POAManager poa_mgr,
+			 CORBA_Environment *ev)
+{
+
+	if(--(ORBIT_ROOT_OBJECT(poa_mgr)->refs) > 0)
+		return;
+
+	if(poa_mgr != NULL) {
+		if(poa_mgr->poa_collection != NULL)  {
+			g_slist_free(poa_mgr->poa_collection);
+			poa_mgr->poa_collection = NULL;
+		}
+		g_free(poa_mgr);
+		poa_mgr = NULL;
+	}
+}
+
+static void
+ORBit_POAManager_register_poa(PortableServer_POAManager poa_mgr, 
+			      PortableServer_POA poa,
+			      CORBA_Environment *ev)
+{
+	poa_mgr->poa_collection = g_slist_remove(poa_mgr->poa_collection, poa);
+	poa_mgr->poa_collection = 
+		g_slist_append(poa_mgr->poa_collection, poa);
+}
+
+static void
+ORBit_POAManager_unregister_poa(PortableServer_POAManager poa_mgr, 
+				PortableServer_POA poa,
+				CORBA_Environment *ev)
+{
+	poa_mgr->poa_collection = g_slist_remove(poa_mgr->poa_collection, poa);
+}
+
+static void
+ORBit_POA_set_policy(PortableServer_POA poa,
+		     CORBA_Policy policy,
+		     CORBA_Environment *ev)
+{
+	switch(policy->policy_type) {
+	case PortableServer_THREAD_POLICY_ID:
+		poa->thread = ((PortableServer_ThreadPolicy)policy)->value;
+		break;
+	case PortableServer_LIFESPAN_POLICY_ID:
+		poa->lifespan = ((PortableServer_LifespanPolicy)policy)->value;
+		break;
+	case PortableServer_ID_UNIQUENESS_POLICY_ID:
+		poa->id_uniqueness = ((PortableServer_IdUniquenessPolicy)policy)->value;
+		break;
+	case PortableServer_ID_ASSIGNMENT_POLICY_ID:
+		poa->id_assignment = ((PortableServer_IdAssignmentPolicy)policy)->value;
+		break;
+	case PortableServer_IMPLICIT_ACTIVATION_POLICY_ID:
+	  poa->implicit_activation = ((PortableServer_ImplicitActivationPolicy)policy)->value;
+		break;
+	case PortableServer_SERVANT_RETENTION_POLICY_ID:
+	  poa->servant_retention = ((PortableServer_ServantRetentionPolicy)policy)->value;
+		break;
+	case PortableServer_REQUEST_PROCESSING_POLICY_ID:
+		poa->request_processing = ((PortableServer_ServantRetentionPolicy)policy)->value;
+		break;
+	default:
+		g_warning("Unknown policy type, cannot set it on this POA");
+	}
+}
+
+
+static void
+ORBit_POA_check_policy_conflicts(PortableServer_POA poa,
+		     CORBA_Environment *ev)
+{
+
+  /* Check for those policy combinations that aren't allowed */
+  if ((poa->servant_retention == PortableServer_NON_RETAIN &&
+       poa->request_processing == PortableServer_USE_ACTIVE_OBJECT_MAP_ONLY) ||
+      
+      (poa->request_processing == PortableServer_USE_DEFAULT_SERVANT &&
+       poa->id_uniqueness == PortableServer_UNIQUE_ID) ||
+      
+      (poa->implicit_activation == PortableServer_IMPLICIT_ACTIVATION &&
+       (poa->id_assignment == PortableServer_USER_ID ||
+	poa->servant_retention == PortableServer_NON_RETAIN))
+      )
+    {
+      CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+			  ex_PortableServer_POA_InvalidPolicy,
+			  NULL);
+    }
+}
+      
+
+static void
+ORBit_POA_set_policylist(PortableServer_POA poa,
+			 CORBA_PolicyList *policies,
+			 CORBA_Environment *ev)
+{
+	CORBA_unsigned_long i;
+
+	for(i = 0; i < policies->_length; i++) {
+		if(ev->_major != CORBA_NO_EXCEPTION)
+			break;
+		ORBit_POA_set_policy(poa, policies->_buffer[i], ev);
+	}
+}
+
+PortableServer_POA 
+ORBit_POA_new(CORBA_ORB orb,
+	      CORBA_char *adapter_name,
+	      PortableServer_POAManager the_POAManager,
+	      CORBA_PolicyList *policies,
+	      CORBA_Environment *ev)
+{
+	PortableServer_POA poa;
+
+	/* Create the object */
+	poa = (PortableServer_POA) g_new0(struct PortableServer_POA_type, 1); 
+	if(poa == NULL) {
+		CORBA_exception_set_system(ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
+		goto error;
+	}
+
+	ORBit_pseudo_object_init(ORBIT_PSEUDO_OBJECT(poa), ORBIT_PSEUDO_POA, ev);
+
+	ORBIT_ROOT_OBJECT(poa)->refs = 0;
+	ORBit_RootObject_set_interface(ORBIT_ROOT_OBJECT(poa),
+				       (gpointer)&CORBA_POA_epv, ev);
+
+	if(ev->_major != CORBA_NO_EXCEPTION) goto error;
+
+	/* If no POAManager was specified, create one */
+	if(the_POAManager == NULL) {
+	  the_POAManager = ORBit_POAManager_new(ev);
+	}	  
+
+	/* Register this poa with the poa manager */
+	if(the_POAManager != NULL)
+		ORBit_POAManager_register_poa(the_POAManager,poa,ev);
+	if(ev->_major != CORBA_NO_EXCEPTION) goto error;
+
+	/* Wire up the poa_manager */
+	poa->the_POAManager = the_POAManager;
+
+	/* Initialise the child poas table */
+	poa->child_POAs = NULL;      /* initialise the slist */
+
+	poa->held_requests = NULL;
+
+	poa->poaID = orb->poas->len;
+	g_ptr_array_set_size(orb->poas, orb->poas->len + 1);
+	g_ptr_array_index(orb->poas, poa->poaID) = poa;
+
+	poa->orb = orb;
+
+	g_return_val_if_fail(ev->_major == CORBA_NO_EXCEPTION, NULL);
+
+	/* Need to initialise poa policies etc.. here */
+	poa->thread = PortableServer_ORB_CTRL_MODEL;
+	poa->lifespan = PortableServer_TRANSIENT;
+	poa->id_uniqueness = PortableServer_UNIQUE_ID;
+	poa->id_assignment = PortableServer_SYSTEM_ID;
+	poa->servant_retention = PortableServer_RETAIN;
+	poa->request_processing = PortableServer_USE_ACTIVE_OBJECT_MAP_ONLY;
+	poa->implicit_activation = PortableServer_NO_IMPLICIT_ACTIVATION;
+	if (policies) {
+	  ORBit_POA_set_policylist(poa, policies, ev);
+	  ORBit_POA_check_policy_conflicts(poa, ev);
+	  if(ev->_major != CORBA_NO_EXCEPTION) goto error;
+	}
+
+	/* copy the name  */
+	poa->the_name = CORBA_string_dup(adapter_name);
+
+	poa->active_object_map = g_hash_table_new((GHashFunc)g_sequence_octet_hash,
+						  (GCompareFunc)g_sequence_octet_compare);
+	poa->objnum_to_obj = g_ptr_array_new();
+	g_ptr_array_set_size(poa->objnum_to_obj, 1);
+	g_ptr_array_index(poa->objnum_to_obj, 0) = NULL;
+
+	orbit_genrand(poa->rand_data, ORBIT_RAND_KEY_LEN);
+
+	return poa;
+
+error:
+	if(poa && poa->the_name){
+		CORBA_free(poa->the_name);
+	}
+
+	if(poa != NULL){
+		ORBit_POA_release(poa, NULL);
+	}
+	return NULL;
+}
+
+static void
+ORBit_POA_release(PortableServer_POA poa,
+		  CORBA_Environment *ev)
+{
+	ORBIT_ROOT_OBJECT_UNREF(poa);
+
+	if(ORBIT_ROOT_OBJECT(poa)->refs <= 0) {
+		CORBA_free(poa->the_name);
+
+		g_slist_foreach(poa->child_POAs, (GFunc)CORBA_Object_release,
+				ev);
+
+		if(poa->parent_poa)
+			ORBit_POA_remove_child(poa->parent_poa, poa, ev);
+
+		ORBit_POAManager_unregister_poa(poa->the_POAManager, 
+						poa, ev);
+
+		g_ptr_array_index(poa->orb->poas, poa->poaID) = NULL;
+
+		g_free(poa);
+	}
+}
+
+void
+ORBit_POA_add_child(PortableServer_POA poa,
+		    PortableServer_POA child_poa,
+		    CORBA_Environment *ev)
+
+{
+	g_return_if_fail(poa != NULL);
+	g_return_if_fail(child_poa != NULL);
+
+	poa->child_POAs = g_slist_prepend(poa->child_POAs, child_poa);
+}
+
+void
+ORBit_POA_remove_child(PortableServer_POA poa,
+		       PortableServer_POA child_poa,
+		       CORBA_Environment *ev)
+{
+	g_return_if_fail(poa != NULL);
+	g_return_if_fail(child_poa != NULL);
+
+	poa->child_POAs = g_slist_remove(poa->child_POAs, child_poa);
+}
+
+extern ORBit_request_validate ORBIT_request_validator;
+
+gboolean
+ORBit_POA_handle_request(GIOPRecvBuffer *recv_buffer,
+			 PortableServer_POA poa)
+{
+	PortableServer_ServantBase *servant;
+	PortableServer_ServantLocator_Cookie cookie;
+	ORBit_POAObject *obj_impl = NULL, tmp_obj_impl;
+	ORBitSkeleton skel;
+	gpointer imp = NULL;
+	CORBA_Environment ev;
+	GIOPSendBuffer *send_buffer;
+	guchar *opname;
+	PortableServer_ObjectId *oid = NULL;
+
+	CORBA_exception_init(&ev);
+
+	switch(poa->the_POAManager->state) {
+	case PortableServer_POAManager_HOLDING:
+		poa->held_requests = g_slist_prepend(poa->held_requests,
+						     recv_buffer);
+		return FALSE;
+		break;
+	case PortableServer_POAManager_DISCARDING:
+		send_buffer = giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(recv_buffer)->connection,
+							 NULL,
+							 recv_buffer->message.u.request.request_id,
+							 CORBA_SYSTEM_EXCEPTION);
+		CORBA_exception_set_system(&ev,
+					    ex_CORBA_TRANSIENT,
+					    CORBA_COMPLETED_NO);
+		ORBit_send_system_exception(send_buffer, &ev);
+		giop_send_buffer_write(send_buffer);
+		giop_recv_buffer_unuse(recv_buffer);
+		giop_send_buffer_unuse(send_buffer);
+		CORBA_exception_free(&ev);
+		return TRUE;
+		break;
+	case PortableServer_POAManager_INACTIVE:
+		send_buffer = giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(recv_buffer)->connection,
+							 NULL,
+							 recv_buffer->message.u.request.request_id,
+							 CORBA_SYSTEM_EXCEPTION);
+		CORBA_exception_set_system(&ev,
+					    ex_CORBA_OBJ_ADAPTER,
+					    CORBA_COMPLETED_NO);
+		ORBit_send_system_exception(send_buffer, &ev);
+		giop_send_buffer_write(send_buffer);
+		giop_recv_buffer_unuse(recv_buffer);
+		giop_send_buffer_unuse(send_buffer);
+		CORBA_exception_free(&ev);
+		return TRUE;
+		break;
+	case PortableServer_POAManager_ACTIVE:
+	default:
+		break;
+	}
+
+	servant = NULL;
+
+	if(recv_buffer->message.u.request.object_key._length
+	   < (POA_KEY_LEN + sizeof(CORBA_unsigned_long))) {
+		CORBA_exception_set_system(&ev,
+					   ex_CORBA_OBJECT_NOT_EXIST,
+					   CORBA_COMPLETED_NO);
+		goto errout;
+	}
+
+	obj_impl = ORBit_POA_find_oid_for_object_key(poa, &(recv_buffer->message.u.request.object_key), &oid);
+
+	if(poa->servant_retention == PortableServer_RETAIN
+	   && obj_impl) {
+		servant = obj_impl->servant;
+		oid = obj_impl->object_id;
+	}
+
+	if(!servant) {
+		switch(poa->request_processing) {
+		case PortableServer_USE_SERVANT_MANAGER:
+			servant = ORBit_POA_ServantManager_use_servant(poa,
+								       recv_buffer,
+								       &cookie,
+								       oid,
+								       &tmp_obj_impl,
+								       &ev);
+			break;
+		case PortableServer_USE_DEFAULT_SERVANT:
+			servant = poa->default_servant;
+			if(servant == NULL) {
+				CORBA_exception_set_system(&ev,
+							   ex_CORBA_OBJ_ADAPTER,
+							   CORBA_COMPLETED_NO);
+				goto errout;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+
+	if(!poa || !servant || !servant->_private) {
+		CORBA_exception_set_system(&ev,
+					   ex_CORBA_OBJECT_NOT_EXIST,
+					   CORBA_COMPLETED_NO);
+		goto errout;
+	}
+
+	opname = recv_buffer->message.u.request.operation;
+
+	skel = ORBIT_OBJECT_KEY(servant->_private)->class_info->relay_call(servant, recv_buffer, &imp);
+	
+	if(!skel) {
+		if (opname[0] == '_' && strcmp(opname + 1, "is_a") == 0) {
+			skel = (gpointer)&ORBit_impl_CORBA_Object_is_a;
+		}
+		else {
+			CORBA_exception_set_system(&ev, ex_CORBA_BAD_OPERATION,
+						   CORBA_COMPLETED_NO);
+			goto errout;
+		}
+	}
+	else if (!imp) {
+		CORBA_exception_set_system(&ev, ex_CORBA_NO_IMPLEMENT,
+					   CORBA_COMPLETED_NO);
+		goto errout;
+	}
+
+	/* If it got through the random keys, and nobody else had the opportunity to say otherwise, it must be auth'd */
+
+	if(!ORBIT_request_validator)
+		GIOP_MESSAGE_BUFFER(recv_buffer)->connection->is_auth = TRUE;
+
+	skel(servant, recv_buffer, &ev, imp);
+
+	if(poa->request_processing == PortableServer_USE_SERVANT_MANAGER) {
+		ORBit_POA_ServantManager_unuse_servant(servant,
+						       poa,
+						       recv_buffer,
+						       cookie, oid,
+						       &tmp_obj_impl,
+						       &ev);
+	}
+
+	if(!obj_impl)
+		CORBA_free(oid);
+
+	CORBA_exception_free(&ev);
+
+	return TRUE;
+
+ errout:
+	if(ev._major == CORBA_SYSTEM_EXCEPTION) {
+		GIOPSendBuffer *reply_buf;
+
+		reply_buf =
+			giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(recv_buffer)->connection,
+						   NULL,
+						   recv_buffer->message.u.request.request_id,
+						   CORBA_SYSTEM_EXCEPTION);
+
+		 ORBit_send_system_exception(reply_buf, &ev);
+
+		 giop_send_buffer_write(reply_buf);
+		 giop_send_buffer_unuse(reply_buf);
+	} else /* User exceptions are handled in the skels! */
+		g_assert(ev._major == CORBA_NO_EXCEPTION);
+
+	if(!obj_impl)
+		CORBA_free(oid);
+
+	CORBA_exception_free(&ev);
+
+	return TRUE;
+}
+
+PortableServer_POA
+ORBit_POA_find_POA_for_object_key(PortableServer_POA root_poa,
+				  CORBA_sequence_octet *key)
+{
+	CORBA_unsigned_long pid;
+
+	if(key->_length < (sizeof(CORBA_unsigned_long) + ORBIT_RAND_KEY_LEN))
+		return NULL;
+
+	pid = *((CORBA_unsigned_long *)key->_buffer);
+
+	if(pid < root_poa->orb->poas->len) {
+		PortableServer_POA poa;
+		poa = g_ptr_array_index(root_poa->orb->poas, pid);
+		if(!poa)
+			return NULL;
+		if(memcmp(poa->rand_data, key->_buffer + sizeof(CORBA_unsigned_long), ORBIT_RAND_KEY_LEN))
+			return NULL;
+		return poa;
+	} else
+		return NULL;
+}
+
+void
+ORBit_POA_find_object_key_for_oid(PortableServer_POA poa,
+				  ORBit_POAObject *obj,
+				  PortableServer_ObjectId *oid,
+				  CORBA_sequence_octet *retval)
+{
+	CORBA_long *vptr;
+
+	g_return_if_fail(poa && (obj || oid));
+	g_return_if_fail(retval);
+
+	if(oid)
+		g_assert(!oid->_buffer[oid->_length - 1]);
+
+	if(obj)
+		retval->_length = POA_KEY_LEN + OBJ_KEY_LEN;
+	else
+		retval->_length = POA_KEY_LEN  + sizeof(CORBA_long) + oid->_length;
+	retval->_buffer = CORBA_octet_allocbuf(retval->_length);
+	CORBA_sequence_set_release(retval, CORBA_TRUE);
+
+	vptr = (CORBA_long *)retval->_buffer;
+	*vptr = poa->poaID;
+	memcpy(retval->_buffer + sizeof(CORBA_unsigned_long), poa->rand_data, ORBIT_RAND_KEY_LEN);
+
+	vptr = (CORBA_long *)(retval->_buffer + POA_KEY_LEN);
+	if(obj) {
+		*vptr = obj->objnum;
+		memcpy(retval->_buffer + POA_KEY_LEN + sizeof(CORBA_unsigned_long), obj->rand_data, ORBIT_RAND_KEY_LEN);
+	} else {
+		*vptr = -((CORBA_long)oid->_length);
+		memcpy(retval->_buffer + POA_KEY_LEN + sizeof(CORBA_unsigned_long), oid->_buffer, oid->_length);
+	}
+}
+
+ORBit_POAObject *
+ORBit_POA_find_oid_for_object_key(PortableServer_POA poa,
+				  CORBA_sequence_octet *object_key,
+				  PortableServer_ObjectId **oid)
+{
+	CORBA_long onum;
+	guchar *nptr;
+	ORBit_POAObject *objinfo;
+
+	*oid = NULL;
+	nptr = object_key->_buffer + POA_KEY_LEN;
+
+	if(object_key->_length < (POA_KEY_LEN + sizeof(CORBA_long))) {
+		return NULL;
+	}
+
+	onum = *((CORBA_long *)nptr);
+
+	if(onum < 0) {
+		/* onum will be the -strlen(ObjectId) */
+		if(object_key->_length < (POA_KEY_LEN + sizeof(CORBA_long) - onum))
+			return NULL;
+
+		*oid = (PortableServer_ObjectId *)CORBA_sequence_octet__alloc();
+		(*oid)->_length = -onum;
+		(*oid)->_buffer = CORBA_octet_allocbuf((*oid)->_length);
+		memcpy((*oid)->_buffer, object_key->_buffer + POA_KEY_LEN + sizeof(CORBA_long), (*oid)->_length);
+
+		return NULL;
+	}
+
+	if(onum >= poa->objnum_to_obj->len)
+		return NULL;
+
+	objinfo = g_ptr_array_index(poa->objnum_to_obj, onum);
+
+	if(GPOINTER_TO_UINT(objinfo) <= poa->objnum_to_obj->len)
+		return NULL;
+
+	if(object_key->_length < (POA_KEY_LEN + OBJ_KEY_LEN))
+		return NULL;
+
+	if(memcmp(object_key->_buffer + POA_KEY_LEN + sizeof(CORBA_long), objinfo->rand_data, ORBIT_RAND_KEY_LEN))
+		return NULL;
+
+	return objinfo;
+}
+
+DEFINE_LOCK(id_assignment_counter);
+static int id_assignment_counter = 0;
+
+PortableServer_ObjectId *
+ORBit_POA_allocate_oid(PortableServer_POA poa,
+		       const char *basis)
+{
+	PortableServer_ObjectId *new_objid;
+	char buf[512];
+	int len;
+
+	new_objid = (PortableServer_ObjectId *)CORBA_sequence_octet__alloc();
+
+	GET_LOCK(id_assignment_counter);
+	g_snprintf(buf, sizeof(buf), "%s%d", basis?basis:"Object",
+		   id_assignment_counter);
+	id_assignment_counter++;
+	RELEASE_LOCK(id_assignment_counter);
+
+	len = strlen(buf)+1;
+	new_objid->_buffer = CORBA_octet_allocbuf(len);
+	new_objid->_length = len;
+	new_objid->_maximum = len;
+	new_objid->_release = CORBA_TRUE;
+
+	strcpy((CORBA_char *)new_objid->_buffer, buf);
+
+	return new_objid;
+}
+
+static PortableServer_Servant
+ORBit_POA_ServantManager_use_servant(PortableServer_POA poa,
+				     GIOPRecvBuffer *recv_buffer,
+				     PortableServer_ServantLocator_Cookie *the_cookie,
+				     PortableServer_ObjectId *oid,
+				     ORBit_POAObject *fake_obj_impl,
+				     CORBA_Environment *ev)
+{
+	if(poa->servant_retention == PortableServer_RETAIN) {
+		POA_PortableServer_ServantActivator *sm;
+		POA_PortableServer_ServantActivator__epv *epv;
+		
+		sm = (POA_PortableServer_ServantActivator *)poa->servant_manager;
+		epv = sm->vepv->PortableServer_ServantActivator_epv;
+		return epv->incarnate(sm, oid, poa, ev);
+	} else {
+		POA_PortableServer_ServantLocator *sm;
+		POA_PortableServer_ServantLocator__epv *epv;
+		PortableServer_ServantBase *retval;
+
+		sm = (POA_PortableServer_ServantLocator *)poa->servant_manager;
+		epv = sm->vepv->PortableServer_ServantLocator_epv;
+		retval = epv->preinvoke(sm, oid,
+					poa, recv_buffer->message.u.request.operation,
+					the_cookie,
+					ev);
+
+		((ORBit_ObjectKey *)retval->_private)->object = fake_obj_impl;
+		fake_obj_impl->object_id = oid;
+		fake_obj_impl->poa = poa;
+		fake_obj_impl->orb = poa->orb;
+		fake_obj_impl->objnum = -1;
+#ifdef NOT_BACKWARDS_COMPAT_0_4
+		fake_obj_impl->use_count = NULL;
+		fake_obj_impl->death_callback = NULL;
+#endif
+
+		return retval;
+	}
+}
+
+static void
+ORBit_POA_ServantManager_unuse_servant(PortableServer_Servant servant,
+				       PortableServer_POA poa,
+				       GIOPRecvBuffer *recv_buffer,
+				       PortableServer_ServantLocator_Cookie cookie,
+				       PortableServer_ObjectId *oid,
+				       ORBit_POAObject *fake_obj_impl,
+				       CORBA_Environment *ev)
+{
+	POA_PortableServer_ServantLocator *sm;
+	POA_PortableServer_ServantLocator__epv *epv;
+
+	if(poa->servant_retention != PortableServer_NON_RETAIN)
+		return;
+
+	sm = (POA_PortableServer_ServantLocator *)poa->servant_manager;
+	epv = sm->vepv->PortableServer_ServantLocator_epv;
+	
+	((ORBit_ObjectKey *)((PortableServer_ServantBase *)servant)->_private)->object = NULL;
+	epv->postinvoke(sm, oid,
+			poa, recv_buffer->message.u.request.operation,
+			cookie, servant, ev);
+
+}
+
+typedef struct {
+	PortableServer_POA poa;
+	CORBA_Environment *ev;
+} EtherealizeInfo;
+
+void
+ORBit_POA_etherealize_object(PortableServer_ObjectId *oid,
+			     ORBit_POAObject *obj_impl,
+			     EtherealizeInfo *ei)
+{
+	POA_PortableServer_ServantActivator__epv *epv;
+	POA_PortableServer_ServantActivator *sm;
+
+	g_assert(ei->poa->servant_manager);
+
+	g_hash_table_remove(ei->poa->active_object_map,
+			    obj_impl->object_id);
+
+	sm = (POA_PortableServer_ServantActivator *)ei->poa->servant_manager;
+	epv = sm->vepv->PortableServer_ServantActivator_epv;
+	epv->etherealize(sm, obj_impl->object_id, ei->poa,
+			 obj_impl->servant,
+			 CORBA_TRUE, CORBA_FALSE, ei->ev);
+}
+
+void
+ORBit_POA_etherealize_objects(PortableServer_POA poa,
+			      CORBA_Environment *ev)
+{
+	EtherealizeInfo ei;
+
+	ei.poa = poa;
+	ei.ev = ev;
+
+	if(poa->servant_retention == PortableServer_RETAIN
+	   && poa->request_processing == PortableServer_USE_SERVANT_MANAGER) {
+
+		g_hash_table_foreach(poa->active_object_map,
+				     (GHFunc)ORBit_POA_etherealize_object,
+				     &ei);
+	}
+}
+
+#ifdef NOT_BACKWARDS_COMPAT_0_4
+void ORBit_servant_set_deathwatch(PortableServer_ServantBase *servant,
+				  int *use_count,
+                                  GFunc death_func,
+                                  gpointer user_data)
+{
+	ORBit_POAObject *pobj;
+
+	pobj = ORBIT_OBJECT_KEY(servant->_private)->object;
+
+	pobj->use_count = use_count;
+	pobj->death_callback = death_func;
+	pobj->user_data = user_data;
+}
+#endif
diff -urN linux-2.4.1/net/korbit/orb/orbit_poa.h linux-2.4.1-korbit/net/korbit/orb/orbit_poa.h
--- linux-2.4.1/net/korbit/orb/orbit_poa.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_poa.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,89 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Phil Dawes <philipd@parallax.co.uk>
+ *
+ */
+
+/*
+ *   ORBit specific POA funcitons.
+ *
+ */
+
+#ifndef _ORBIT_ORBIT_POA_H_
+#define _ORBIT_ORBIT_POA_H_
+
+#include "orbit_types.h"
+#include "orbit_poa_type.h"
+
+/*
+ * Creates a new POAManager
+ */
+
+extern PortableServer_POAManager ORBit_POAManager_new(CORBA_Environment *ev);
+
+extern void ORBit_POAManager_free(PortableServer_POAManager poa_mgr, 
+				  CORBA_Environment *ev);
+
+extern PortableServer_POA ORBit_POA_new(CORBA_ORB orb,
+					CORBA_char *adapter_name,
+					PortableServer_POAManager the_POAManager,
+					CORBA_PolicyList *policies,
+					CORBA_Environment *ev);
+
+extern void ORBit_POA_free(PortableServer_POA poa, CORBA_Environment *ev);
+
+extern void ORBit_POA_add_child(PortableServer_POA poa,
+				PortableServer_POA child_poa,
+				CORBA_Environment *ev);
+void ORBit_POA_remove_child(PortableServer_POA poa,
+			    PortableServer_POA child_poa,
+			    CORBA_Environment *ev);
+
+gboolean ORBit_POA_handle_request(GIOPRecvBuffer *recv_buffer,
+				  PortableServer_POA poa);
+PortableServer_POA
+ORBit_POA_find_POA_for_object_key(PortableServer_POA root_poa,
+				  CORBA_sequence_octet *key);
+void
+ORBit_POA_find_object_key_for_oid(PortableServer_POA poa,
+				  ORBit_POAObject *obj,
+				  PortableServer_ObjectId *oid,
+				  CORBA_sequence_octet *retval);
+ORBit_POAObject *
+ORBit_POA_find_oid_for_object_key(PortableServer_POA poa,
+				  CORBA_sequence_octet *object_key,
+				  PortableServer_ObjectId **oid);
+
+PortableServer_ObjectId *ORBit_POA_allocate_oid(PortableServer_POA poa,
+						const char *basis);
+
+void ORBit_POA_etherealize_objects(PortableServer_POA poa, CORBA_Environment *ev);
+
+#ifdef NOT_BACKWARDS_COMPAT_0_4
+/* Bad hack for shared libraries */
+void ORBit_servant_set_deathwatch(PortableServer_ServantBase *servant,
+				  int *use_count,
+				  GFunc death_func,
+				  gpointer user_data);
+#endif
+
+#endif /* !_ORBIT_ORBIT_POA_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orbit_poa_type.h linux-2.4.1-korbit/net/korbit/orb/orbit_poa_type.h
--- linux-2.4.1/net/korbit/orb/orbit_poa_type.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_poa_type.h	Thu Feb  1 11:47:13 2001
@@ -0,0 +1,112 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Phil Dawes <philipd@parallax.co.uk>
+ *
+ */
+
+/*
+ *   ORBit specific POA funcitons.
+ *
+ */
+
+#ifndef _ORBIT_ORBIT_POA_TYPE_H_
+#define _ORBIT_ORBIT_POA_TYPE_H_
+
+typedef void (*ORBitSkeleton)(PortableServer_ServantBase *_ORBIT_servant,
+			      gpointer _ORBIT_recv_buffer,
+			      CORBA_Environment *ev,
+			      gpointer implementation);
+typedef ORBitSkeleton (*ORBit_impl_finder)(PortableServer_ServantBase *servant,
+				    gpointer _ORBIT_recv_buffer,
+				    gpointer *implementation);
+typedef void (*ORBit_local_objref_init)(CORBA_Object obj,
+					PortableServer_ServantBase *servant);
+typedef struct {
+	ORBit_impl_finder relay_call;
+	const gchar *class_name;
+	ORBit_local_objref_init init_local_objref;
+} PortableServer_ClassInfo;
+
+#define ORBIT_RAND_KEY_LEN 8
+
+typedef struct {
+	PortableServer_ObjectId *object_id;
+	PortableServer_Servant servant;
+	PortableServer_POA poa;
+	CORBA_ORB orb;
+	CORBA_unsigned_long objnum;
+
+	/* Stuff for doing shared libraries nicely */
+	guchar rand_data[ORBIT_RAND_KEY_LEN];
+
+#ifdef NOT_BACKWARDS_COMPAT_0_4
+	int *use_count;
+	GFunc death_callback;
+	gpointer user_data;
+#endif
+} ORBit_POAObject;
+
+typedef struct {
+	PortableServer_ClassInfo *class_info;
+	ORBit_POAObject *object;
+} ORBit_ObjectKey;
+
+#define ORBIT_OBJECT_KEY(x) ((ORBit_ObjectKey *)(x))
+
+struct PortableServer_POA_type {
+	struct ORBit_PseudoObject_struct parent;
+
+	PortableServer_POA parent_poa;
+	CORBA_ORB orb;
+	CORBA_unsigned_long poaID;
+
+	GHashTable *active_object_map;
+	GPtrArray *objnum_to_obj; /* maps objnums to ORBit_POAObject's */
+	CORBA_long first_free_id;
+
+	/* Requests received while in a HOLDING state */
+	GSList *held_requests;
+
+	/* this'll be a hash table when I can be arsed to look up 
+	   how to implement efficient hash tables  - Phil.*/
+	GSList *child_POAs;     
+	
+	CORBA_char *the_name;
+	PortableServer_POAManager the_POAManager;
+
+	PortableServer_AdapterActivator the_activator;
+
+	PortableServer_ServantManager servant_manager;
+	PortableServer_Servant default_servant;
+
+	PortableServer_ThreadPolicyValue thread;
+	PortableServer_LifespanPolicyValue lifespan;
+	PortableServer_IdUniquenessPolicyValue id_uniqueness;
+	PortableServer_IdAssignmentPolicyValue id_assignment;
+	PortableServer_ImplicitActivationPolicyValue implicit_activation;
+	PortableServer_ServantRetentionPolicyValue servant_retention;
+	PortableServer_RequestProcessingPolicyValue request_processing;
+
+	guchar rand_data[ORBIT_RAND_KEY_LEN];
+};
+
+#endif /* !_ORBIT_ORBIT_POA_TYPE_H_ */
diff -urN linux-2.4.1/net/korbit/orb/orbit_typecode.c linux-2.4.1-korbit/net/korbit/orb/orbit_typecode.c
--- linux-2.4.1/net/korbit/orb/orbit_typecode.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_typecode.c	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,593 @@
+#include "orbit.h"
+#include "orbit_typecode.h"
+#include "cdr.h"
+#include "corba_typecode_type.h"
+#include <IIOP/giop-msg-buffer.h>
+#include "../IIOP/iiop-endianP.h"
+
+#if 0
+#define CORBA_Object_release(x, y) ({ g_message(__FILE__ ":%d Releasing object %#x from %d", __LINE__, \
+x, ORBIT_ROOT_OBJECT(x)->refs); CORBA_Object_release(x, y); })
+#define CORBA_Object_duplicate(x, y) ({ g_message(__FILE__ ":%d Duping object %#x from %d", __LINE__, \
+x, ORBIT_ROOT_OBJECT(x)->refs); CORBA_Object_duplicate(x, y); })
+#endif
+
+typedef struct{
+	CORBA_TypeCode tc;
+	guint index; 
+}TCRecursionNode;
+
+typedef struct{
+	GSList* prior_tcs; /* Could be a hash table by typecode */
+	guint current_idx; /* The "top-level" index of the start of the current codec */
+}TCEncodeContext;
+
+typedef struct{
+	GSList* prior_tcs; /* Could be a hash table by offset */
+	guint current_idx;
+}TCDecodeContext;
+
+
+
+static void tc_enc(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec(CORBA_TypeCode* t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_objref(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_objref(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_sequence(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_sequence(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_string(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_string(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_struct(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_struct(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_union(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_union(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_enum(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_enum(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_alias(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_alias(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_except(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_except(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_array(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_array(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_fixed(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_fixed(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+static void tc_enc_tk_wstring(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx);
+static void tc_dec_tk_wstring(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx);
+
+
+
+typedef void
+(*CORBA_TypeCodeEncoder)(CORBA_TypeCode t,
+		   CDR_Codec* c,
+		   TCEncodeContext* ctx);
+
+typedef void
+(*CORBA_TypeCodeDecoder)(CORBA_TypeCode t,
+		   CDR_Codec* c,
+		   TCDecodeContext* ctx);
+
+
+typedef enum{
+	TK_EMPTY,
+	TK_SIMPLE,
+	TK_COMPLEX
+} TkType;
+
+typedef struct{
+	TkType type;
+	CORBA_TypeCodeEncoder encoder;
+	CORBA_TypeCodeDecoder decoder;
+} TkInfo;
+
+static const TkInfo tk_info[CORBA_tk_last]={
+	{TK_EMPTY, NULL, NULL}, /* tk_null */
+	{TK_EMPTY, NULL, NULL}, /* tk_void */
+	{TK_EMPTY, NULL, NULL}, /* tk_short */
+	{TK_EMPTY, NULL, NULL}, /* tk_long */
+	{TK_EMPTY, NULL, NULL}, /* tk_ushort */
+	{TK_EMPTY, NULL, NULL}, /* tk_ulong */
+	{TK_EMPTY, NULL, NULL}, /* tk_float */
+	{TK_EMPTY, NULL, NULL}, /* tk_double */
+	{TK_EMPTY, NULL, NULL}, /* tk_boolean */
+	{TK_EMPTY, NULL, NULL}, /* tk_char */
+	{TK_EMPTY, NULL, NULL}, /* tk_octet */
+	{TK_EMPTY, NULL, NULL}, /* tk_any */
+	{TK_EMPTY, NULL, NULL}, /* tk_TypeCode */
+        {TK_EMPTY, NULL, NULL}, /* tk_Principal */
+	{TK_COMPLEX, tc_enc_tk_objref, tc_dec_tk_objref}, /* tk_objref */
+	{TK_COMPLEX, tc_enc_tk_struct, tc_dec_tk_struct}, /* tk_struct */
+        {TK_COMPLEX, tc_enc_tk_union, tc_dec_tk_union}, /* tk_union */
+        {TK_COMPLEX, tc_enc_tk_enum, tc_dec_tk_enum}, /* tk_enum */
+        {TK_SIMPLE, tc_enc_tk_string, tc_dec_tk_string}, /* tk_string */
+        {TK_COMPLEX, tc_enc_tk_sequence, tc_dec_tk_sequence}, /* tk_sequence */
+        {TK_COMPLEX, tc_enc_tk_array, tc_dec_tk_array}, /* tk_array */
+        {TK_COMPLEX, tc_enc_tk_alias, tc_dec_tk_alias}, /* tk_alias */
+        {TK_COMPLEX, tc_enc_tk_except, tc_dec_tk_except}, /* tk_except */
+        {TK_EMPTY, NULL, NULL}, /* tk_longlong */
+        {TK_EMPTY, NULL, NULL}, /* tk_ulonglong */
+        {TK_EMPTY, NULL, NULL}, /* tk_longdouble */
+        {TK_EMPTY, NULL, NULL}, /* tk_wchar */
+	{TK_SIMPLE, tc_enc_tk_wstring, tc_dec_tk_wstring}, /* tk_wstring */
+	{TK_SIMPLE, tc_enc_tk_fixed, tc_dec_tk_fixed} /* tk_fixed */
+};
+
+void ORBit_encode_CORBA_TypeCode(CORBA_TypeCode t, GIOPSendBuffer* buf)
+{
+        CDR_Codec codec_d;
+	CDR_Codec* codec = &codec_d;
+	TCEncodeContext ctx;
+	GSList* l;
+	CORBA_octet codecbuf[2048];
+
+	CDR_codec_init_static(codec);
+
+	codec->wptr = 0;
+	codec->buffer = codecbuf;
+	codec->release_buffer = FALSE;
+	codec->buf_len = 2048;
+	codec->data_endian=FLAG_ENDIANNESS;
+
+	ctx.current_idx=0;
+	ctx.prior_tcs=NULL;
+	tc_enc(t, codec, &ctx);
+	for(l=ctx.prior_tcs;l;l=l->next)
+		g_free(l->data);
+	g_slist_free(ctx.prior_tcs);
+	giop_send_buffer_append_mem_indirect(buf,
+					     codec->buffer,
+					     codec->wptr);
+}
+
+void ORBit_decode_CORBA_TypeCode(CORBA_TypeCode* t, GIOPRecvBuffer* buf)
+{
+        CDR_Codec codec_d;
+	CDR_Codec* codec = &codec_d;
+	TCDecodeContext ctx;
+	GSList* l;
+
+	CDR_codec_init_static(codec);
+	codec->buffer=buf->cur;
+	codec->release_buffer=CORBA_FALSE;
+	codec->readonly=CORBA_TRUE;
+	codec->buf_len =		/* hope this is correct */
+	  ((guchar *)buf->message_body) +
+	  GIOP_MESSAGE_BUFFER(buf)->message_header.message_size
+	  - ((guchar *)buf->cur);
+		
+	codec->data_endian=GIOP_MESSAGE_BUFFER(buf)->message_header.flags & 1;
+
+	ctx.current_idx=0;
+	ctx.prior_tcs=NULL;
+	tc_dec(t, codec, &ctx);
+	for(l=ctx.prior_tcs;l;l=l->next)
+		g_free(l->data);
+	g_slist_free(ctx.prior_tcs);
+	buf->cur = ((guchar *)buf->cur) + codec->rptr;
+}
+	
+
+/* Encode a typecode to a codec, possibly recursively */
+
+static void tc_enc(CORBA_TypeCode tc,
+	       CDR_Codec* codec,
+	       TCEncodeContext* ctx)
+{
+	TCRecursionNode* node;
+	const TkInfo* info;
+	GSList* l;
+	CORBA_octet codecbuf[2048];
+	CDR_Codec encaps_d;
+	CDR_Codec* encaps = &encaps_d;
+
+	g_assert(CLAMP(0, tc->kind, CORBA_tk_last) == tc->kind);
+
+	for(l=ctx->prior_tcs;l;l=l->next){
+		TCRecursionNode* node=l->data;
+		/* CORBA_CORBA_TypeCode_equal might save space, but is slow.. */
+		if(node->tc==tc){
+			CDR_put_ulong(codec, CORBA_tk_recursive);
+			CDR_put_long(codec,
+				     node->index
+				     -ctx->current_idx
+				     -codec->wptr);
+			return;
+		}
+	}
+
+	/* All right, this isn't a previously met type. So record it. */
+	/* NOTE: put kind before recording index so alignment is dealt with! */
+	CDR_put_ulong(codec, tc->kind);
+
+	node=g_new(TCRecursionNode, 1);
+	node->tc=tc;
+	node->index=ctx->current_idx+codec->wptr - 4; /* -4 for kind */
+	ctx->prior_tcs=g_slist_prepend(ctx->prior_tcs, node);
+	
+	info=&tk_info[tc->kind];
+	switch(info->type){
+		guint tmp_index;
+	case TK_EMPTY:
+		break;
+	case TK_COMPLEX:
+		tmp_index=ctx->current_idx;
+		ctx->current_idx+=codec->wptr+4; /* +4 for the length */
+		CDR_codec_init_static(encaps);
+		encaps->wptr = 0;
+		encaps->buffer = codecbuf;
+		encaps->release_buffer = FALSE;
+		encaps->buf_len = 2048;
+		encaps->data_endian=FLAG_ENDIANNESS;
+		CDR_put_octet(encaps, FLAG_ENDIANNESS);
+		(info->encoder)(tc, encaps, ctx);
+		CDR_put_ulong(codec, encaps->wptr);
+		/* Now this is a time hog */ 
+		CDR_put_octets(codec, encaps->buffer, encaps->wptr);
+		ctx->current_idx=tmp_index;
+		break;
+	case TK_SIMPLE:
+		(info->encoder)(tc, codec, ctx);
+	}
+}
+
+static void
+ORBit_TypeCode_release(gpointer obj, CORBA_Environment *ev)
+{
+  /* we will initialize the TC_ constants with a negative refcount */
+  if(ORBIT_ROOT_OBJECT(obj)->refs >= 0) {
+    ORBIT_ROOT_OBJECT_UNREF(obj);
+
+    if(ORBIT_ROOT_OBJECT(obj)->refs <= 0) {
+      CORBA_TypeCode tc = obj;
+      int i;
+
+      g_free(tc->name);
+      g_free(tc->repo_id);
+
+      for(i = 0; i < tc->sub_parts; i++) {
+	if(tc->subnames)
+	  g_free(tc->subnames[i]);
+
+	if(tc->subtypes)
+	  CORBA_Object_release((CORBA_Object)tc->subtypes[i], ev);
+
+	if(tc->sublabels)
+	  CORBA_any__free(&tc->sublabels[i], NULL, TRUE);
+      }
+
+      g_free(tc->subnames);
+      g_free(tc->subtypes);
+      g_free(tc->sublabels);
+
+      if(tc->discriminator)
+	CORBA_Object_release((CORBA_Object)tc->discriminator, ev);
+
+      g_free(obj);
+    }
+
+  }
+}
+
+const ORBit_RootObject_Interface ORBit_TypeCode_epv = {
+  &ORBit_TypeCode_release
+};
+
+static void tc_dec(CORBA_TypeCode* t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	CORBA_TCKind kind;
+	CORBA_TypeCode tc;
+	const TkInfo* info;
+	TCRecursionNode* node;
+	CDR_Codec encaps_d;
+	CDR_Codec* encaps = &encaps_d;
+
+	CDR_get_ulong(c, &kind);
+
+	g_assert(CLAMP(0, kind, CORBA_tk_last) == kind);
+
+	if(kind==CORBA_tk_recursive){
+		CORBA_long offset;
+		GSList* l;
+		CDR_get_ulong(c, &offset);
+		for(l=ctx->prior_tcs;l;l=l->next){
+			node=l->data;
+			/* NOTE: below, -4 is b/c we already read offset */
+			if(node->index==ctx->current_idx+c->rptr+offset-4){
+				*t=node->tc;
+				return;
+			}
+		}
+		ORBit_Trace(TraceMod_ORB, TraceLevel_Error,
+			    "tc_dec: Invalid CORBA_TypeCode recursion offset "
+			    "in input buffer\n");
+		g_assert_not_reached();
+	}
+		
+	ORBit_Trace(TraceMod_TC, TraceLevel_Debug, "codec->host_endian: %d, codec->data_endian: %d\n", c->host_endian, c->data_endian);
+	ORBit_Trace(TraceMod_TC, TraceLevel_Debug, "kind: %d, CORBA_tk_last: %d\n", kind, CORBA_tk_last);
+	g_assert(kind<CORBA_tk_last);
+
+	node=g_new(TCRecursionNode, 1);
+	node->index=ctx->current_idx+c->rptr-4; /* -4 for the TCKind */
+	info=&tk_info[kind];
+	
+	tc=g_new0(struct CORBA_TypeCode_struct, 1);
+
+	/* Passing in NULL for CORBA_Environment is patently dangerous. */
+	ORBit_pseudo_object_init((ORBit_PseudoObject)tc,
+				 ORBIT_PSEUDO_TYPECODE, NULL);
+	ORBit_RootObject_set_interface((ORBit_RootObject)tc,
+				       (ORBit_RootObject_Interface *)&ORBit_TypeCode_epv,
+				       NULL);
+
+	tc->kind=kind;
+	switch(info->type){
+		guint tmp_index;
+		CORBA_octet o;
+
+	case TK_EMPTY:
+		break;
+
+	case TK_COMPLEX:
+		tmp_index=ctx->current_idx;
+		CDR_codec_init_static(encaps);
+		CDR_get_ulong(c, &encaps->buf_len);
+		ctx->current_idx+=c->rptr;
+		encaps->buffer=&c->buffer[c->rptr];
+		encaps->release_buffer=CORBA_FALSE;
+		CDR_get_octet(encaps, &o);
+		encaps->data_endian=o;
+		(info->decoder)(tc, encaps, ctx);
+		c->rptr += encaps->buf_len;
+		ctx->current_idx=tmp_index;
+		break;
+	case TK_SIMPLE:
+		(info->decoder)(tc, c, ctx);
+		break;
+	}
+	node->tc=tc;
+	ctx->prior_tcs=g_slist_prepend(ctx->prior_tcs, node);
+	*t=tc;
+}
+
+
+
+static void tc_enc_tk_objref(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	CDR_put_string(c, t->repo_id);
+	CDR_put_string(c, t->name);
+}
+
+static void tc_dec_tk_objref(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	CDR_get_string(c, &t->repo_id);
+	CDR_get_string(c, &t->name);
+}
+
+static void tc_enc_tk_sequence(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	tc_enc(*t->subtypes, c, ctx);
+	CDR_put_ulong(c, t->length);
+}
+
+static void tc_dec_tk_sequence(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	t->subtypes=g_new(CORBA_TypeCode, 1);
+	tc_dec(&t->subtypes[0], c, ctx);
+	CORBA_Object_duplicate((CORBA_Object)t->subtypes[0], NULL);
+	CDR_get_ulong(c, &t->length);
+}
+
+static void tc_enc_tk_string(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	CDR_put_ulong(c, t->length);
+}
+
+static void tc_dec_tk_string(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	CDR_get_ulong(c, &t->length);
+}
+
+static void tc_enc_tk_struct(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	CORBA_unsigned_long i;
+	CDR_put_string(c, t->repo_id);
+	CDR_put_string(c, t->name);
+	CDR_put_ulong(c, t->sub_parts);
+	for(i=0;i<t->sub_parts;i++){
+		CDR_put_string(c, t->subnames[i]);
+		tc_enc(t->subtypes[i], c, ctx);
+	}
+}
+ 
+static void tc_dec_tk_struct(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	CORBA_unsigned_long i;
+	CDR_get_string(c, &t->repo_id);
+	CDR_get_string(c, &t->name);
+	CDR_get_ulong(c, &t->sub_parts);
+	t->subnames=g_new(gchar*, t->sub_parts);
+	t->subtypes=g_new(CORBA_TypeCode, t->sub_parts);
+	for(i=0;i<t->sub_parts;i++){
+		CDR_get_string(c, &t->subnames[i]);
+		tc_dec(&t->subtypes[i], c, ctx);
+		CORBA_Object_duplicate((CORBA_Object)t->subtypes[i], NULL);
+	}
+}	
+
+#define UNION_MEMBERS(dir)					\
+	MEMBER_LOOPER_##dir(ulong, long, long);			\
+    case CORBA_tk_enum: /* fall through */			\
+	MEMBER_LOOPER_##dir(ulong, unsigned_long, ulong);	\
+	MEMBER_LOOPER_##dir(octet, boolean, boolean);		\
+	MEMBER_LOOPER_##dir(octet, char, char);			\
+	MEMBER_LOOPER_##dir(ushort, short, short);		\
+	MEMBER_LOOPER_##dir(ushort, unsigned_short, ushort);	\
+	MEMBER_LOOPER_##dir(ulong_long, long_long, longlong);	\
+	MEMBER_LOOPER_##dir(ulong_long, unsigned_long_long, ulonglong);	\
+	/* MEMBER_LOOPER_##dir(wchar, wchar, wchar); */
+
+
+static void tc_enc_tk_union(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	CORBA_unsigned_long i;
+	CDR_put_string(c, t->repo_id);
+	CDR_put_string(c, t->name);
+	tc_enc(t->discriminator, c, ctx);
+	CDR_put_long(c, t->default_index);
+	CDR_put_ulong(c, t->sub_parts);
+	i=t->sub_parts;
+	/* Thank goodness the discriminator types are rather limited,
+	   we can do the marshalling inline.. */
+#define MEMBER_LOOPER_ENC(putname, typename, tkname) \
+	case CORBA_tk_##tkname: \
+		for(i=0;i<t->sub_parts;i++){ \
+			CDR_put_##putname(c, *(CORBA_##typename*) \
+				      (t->sublabels[i]._value)); \
+			CDR_put_string(c, t->subnames[i]); \
+			tc_enc(t->subtypes[i], c, ctx); \
+		} \
+		break
+
+	switch(t->discriminator->kind){
+	UNION_MEMBERS(ENC);
+	default:
+		ORBit_Trace(TraceMod_ORB, TraceLevel_Error,
+			    "tc_enc_tk_union: Illegal union discriminator "
+			    "type %s\n", t->discriminator->name);
+	}
+}
+
+static void tc_dec_tk_union(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	CORBA_unsigned_long i;
+	CDR_get_string(c, &t->repo_id);
+	CDR_get_string(c, &t->name);
+	tc_dec(&t->discriminator, c, ctx);
+	CORBA_Object_duplicate((CORBA_Object)t->discriminator, NULL);
+	CDR_get_ulong(c, &t->default_index);
+	CDR_get_ulong(c, &t->sub_parts);
+
+	t->sublabels=g_new(CORBA_any, t->sub_parts);
+	t->subnames=g_new(gchar*, t->sub_parts);
+	t->subtypes=g_new(CORBA_TypeCode, t->sub_parts);
+
+#define MEMBER_LOOPER_DEC(getname, typename, tkname) \
+    case CORBA_tk_##tkname: \
+	for(i=0;i<t->sub_parts;i++){ 	\
+	    t->sublabels[i]._type = 	\
+	      CORBA_Object_duplicate((CORBA_Object)t->discriminator, NULL); \
+	    t->sublabels[i]._value = g_new(CORBA_##typename,1); \
+	    t->sublabels[i]._release = CORBA_TRUE; \
+	    CDR_get_##getname(c, t->sublabels[i]._value); \
+	    CDR_get_string(c, &t->subnames[i]); \
+	    tc_dec(&t->subtypes[i], c, ctx); \
+	    CORBA_Object_duplicate((CORBA_Object)t->subtypes[i], NULL); \
+	} \
+	break
+
+	switch(t->discriminator->kind){
+	UNION_MEMBERS(DEC);
+	default:
+	    /* XXX: what is correct error handling */
+	    g_assert(!"Not yet implemented.");
+	}
+}
+
+static void tc_enc_tk_enum(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	CORBA_unsigned_long i;
+	CDR_put_string(c, t->repo_id);
+	CDR_put_string(c, t->name);
+	CDR_put_ulong(c, t->sub_parts);
+	for(i=0;i<t->sub_parts;i++)
+		CDR_put_string(c, t->subnames[i]);
+}
+
+static void tc_dec_tk_enum(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	CORBA_unsigned_long i;
+	CDR_get_string(c, &t->repo_id);
+	CDR_get_string(c, &t->name);
+	CDR_get_ulong(c, &t->sub_parts);
+	t->subnames=g_new(gchar*, t->sub_parts);
+	for(i=0;i<t->sub_parts;i++)
+		CDR_get_string(c, &t->subnames[i]);
+}
+
+static void tc_enc_tk_alias(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	CDR_put_string(c, t->repo_id);
+	CDR_put_string(c, t->name);
+	tc_enc(*t->subtypes, c, ctx);
+}
+
+static void tc_dec_tk_alias(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	CDR_get_string(c, &t->repo_id);
+	CDR_get_string(c, &t->name);
+	t->subtypes=g_new(CORBA_TypeCode, 1);
+	tc_dec(t->subtypes, c, ctx);
+	CORBA_Object_duplicate((CORBA_Object)t->subtypes[0], NULL);
+}
+
+
+static void tc_enc_tk_except(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	gulong i;
+	CDR_put_string(c, t->repo_id);
+	CDR_put_string(c, t->name);
+	CDR_put_ulong(c, t->sub_parts);
+	for(i=0;i<t->length;i++){
+		CDR_put_string(c, t->subnames[i]);
+		tc_enc(t->subtypes[i], c, ctx);
+	}
+}
+
+static void tc_dec_tk_except(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	gulong i;
+	CDR_get_string(c, &t->repo_id);
+	CDR_get_string(c, &t->name);
+	CDR_get_ulong(c, &t->sub_parts);
+	t->subtypes=g_new(CORBA_TypeCode, t->sub_parts);
+	t->subnames=g_new(gchar*, t->sub_parts);
+	for(i=0;i<t->length;i++){
+		CDR_get_string(c, &t->subnames[i]);
+		tc_dec(&t->subtypes[i], c, ctx);
+		CORBA_Object_duplicate((CORBA_Object)t->subtypes[i], NULL);
+	}
+}
+
+static void tc_enc_tk_array(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	tc_enc(*t->subtypes, c, ctx);
+	CDR_put_ulong(c, t->length);
+}
+
+static void tc_dec_tk_array(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	t->subtypes=g_new(CORBA_TypeCode, 1);
+	tc_dec(t->subtypes, c, ctx);
+	CORBA_Object_duplicate((CORBA_Object)t->subtypes[0], NULL);
+	CDR_get_ulong(c, &t->length);
+}
+
+static void tc_enc_tk_wstring(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	g_assert(!"Not yet implemented.");
+}
+
+static void tc_dec_tk_wstring(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	g_assert(!"Not yet implemented.");
+}
+
+static void tc_enc_tk_fixed(CORBA_TypeCode t, CDR_Codec* c, TCEncodeContext* ctx)
+{
+	g_assert(!"Not yet implemented.");
+}
+
+static void tc_dec_tk_fixed(CORBA_TypeCode t, CDR_Codec* c, TCDecodeContext* ctx)
+{
+	g_assert(!"Not yet implemented.");
+}
diff -urN linux-2.4.1/net/korbit/orb/orbit_typecode.h linux-2.4.1-korbit/net/korbit/orb/orbit_typecode.h
--- linux-2.4.1/net/korbit/orb/orbit_typecode.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_typecode.h	Thu Feb  1 16:21:53 2001
@@ -0,0 +1,10 @@
+#ifndef _ORBIT_ORBIT_TYPECODE_H_
+#define _ORBIT_ORBIT_TYPECODE_H_
+
+#include "orbit_types.h"
+
+extern const ORBit_RootObject_Interface ORBit_TypeCode_epv;
+void ORBit_encode_CORBA_TypeCode(CORBA_TypeCode tc, GIOPSendBuffer* buf);
+void ORBit_decode_CORBA_TypeCode(CORBA_TypeCode* tc, GIOPRecvBuffer* buf);
+
+#endif
diff -urN linux-2.4.1/net/korbit/orb/orbit_types.h linux-2.4.1-korbit/net/korbit/orb/orbit_types.h
--- linux-2.4.1/net/korbit/orb/orbit_types.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/orbit_types.h	Thu Feb  1 16:20:50 2001
@@ -0,0 +1,176 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_TYPES_H_
+#define _ORBIT_TYPES_H_
+
+#include <stddef.h>	/* for wchar_t */
+#include <sys/types.h>  /* for sysdep types */
+#include <netinet/in.h>	/* for sockaddr_in */
+#include <sys/uio.h> /* for struct iovec */
+
+#include <ORBitutil/basic_types.h>
+
+#define CORBA_TRUE 1
+#define CORBA_FALSE 0
+
+typedef CORBA_char *CORBA_ORBid;
+
+typedef CORBA_unsigned_long CORBA_ServiceOption;
+typedef CORBA_unsigned_long CORBA_ServiceDetailType;
+
+#include "corba_orb.h"
+
+/*
+ * CORBA_RepositoryId and CORBA_Identifier are defined in the Interface
+ * Repository, but are needed in other interfaces in the ORB itself.
+ */
+#if !defined(_CORBA_Identifier_defined)
+#define _CORBA_Identifier_defined 1
+typedef CORBA_char *CORBA_Identifier;
+#define CORBA_Identifier__free CORBA_string__free
+#endif
+
+#if !defined(_CORBA_RepositoryId_defined)
+#define _CORBA_RepositoryId_defined 1
+typedef CORBA_char *CORBA_RepositoryId;
+#define CORBA_RepositoryId__free CORBA_string__free
+#endif
+
+#include "corba_any.h"
+
+typedef struct CORBA_ServiceDetail_type CORBA_ServiceDetail;
+typedef struct CORBA_Request_type *CORBA_Request;
+typedef struct CORBA_ServerRequest_type *CORBA_ServerRequest;
+typedef struct CORBA_DynFixed_type *CORBA_DynFixed;
+typedef struct CORBA_Current_type *CORBA_Current;
+typedef void CORBA_Status;
+typedef CORBA_unsigned_long CORBA_enum;
+typedef CORBA_unsigned_long CORBA_Flags;
+
+typedef struct CORBA_NVList_type {
+	CORBA_Flags flags;
+	GArray *list;
+} CORBA_NVList;
+
+#include "corba_context.h"
+
+#include "corba_portableserver.h"
+
+#include "corba_env.h"
+
+#include "corba_sequences_type.h"
+
+#include "corba_basic_sequences_type.h"
+
+#include "corba_object.h"
+
+#include "orbit_object_type.h"
+
+#include "corba_object_type.h"
+
+#include "corba_orb_type.h"
+
+#include "corba_typecode.h"
+#include "corba_typecode_type.h"
+#include "corba_any_type.h"
+#include "corba_any_proto.h"
+
+#if !defined(TC_IMPL_TC_CORBA_Identifier_0)
+#define TC_IMPL_TC_CORBA_Identifier_0 '/'
+#define TC_CORBA_Identifier ((CORBA_TypeCode)&TC_CORBA_Identifier_struct)
+extern const struct CORBA_TypeCode_struct TC_CORBA_Identifier_struct;
+#endif
+
+#if !defined(TC_IMPL_TC_CORBA_RepositoryId_0)
+#define TC_IMPL_TC_CORBA_RepositoryId_0 '/'
+extern const struct CORBA_TypeCode_struct TC_CORBA_RepositoryId_struct;
+#define TC_CORBA_RepositoryId ((CORBA_TypeCode)&TC_CORBA_RepositoryId_struct)
+#endif
+
+/* 19.14 */
+
+/* XXX */
+typedef struct CORBA_fixed_d_s {
+	CORBA_unsigned_short _digits;
+	CORBA_short _scale;
+	signed char _sign;
+	signed char _value[1];
+} CORBA_fixed_d_s;
+
+#include "corba_env_type.h"
+
+
+typedef struct CORBA_WrongTransaction {
+	int dummy;
+} CORBA_WrongTransaction;
+
+#define CORBA_ARG_IN (1<<0)
+#define CORBA_ARG_OUT (1<<1)
+#define CORBA_ARG_INOUT (1<<2)
+#define CORBA_CTX_RESTRICT_SCOPE (1<<3)
+#define CORBA_CTX_DELETE_DESCENDENTS (1<<4)
+#define CORBA_OUT_LIST_MEMORY (1<<5)
+#define CORBA_IN_COPY_VALUE (1<<6)
+#define CORBA_DEPENDENT_LIST (1<<7)
+#define CORBA_INV_NO_RESPONSE (1<<8)
+#define CORBA_INV_TERM_ON_ERROR (1<<9)
+#define CORBA_RESP_NO_WAIT (1<<10)
+
+typedef struct CORBA_NamedValue {
+	CORBA_Identifier name;		/* argument name */
+	CORBA_any argument;		/* argument */
+	CORBA_long len;			/* length/count of argument value */
+	CORBA_Flags arg_modes;		/* argument mode flags */
+} CORBA_NamedValue;
+
+typedef CORBA_char *CORBA_FieldName;
+
+typedef struct CORBA_NameValuePair {
+	CORBA_FieldName id;
+	CORBA_any value;
+} CORBA_NameValuePair;
+
+struct CORBA_Current_type {
+	int fill_me_in;
+};
+
+#include "corba_portableserver_type.h"
+
+typedef CORBA_unsigned_short CORBA_ServiceType;
+
+#define CORBA_Security (1)
+
+struct CORBA_ServiceDetail_type {
+	CORBA_ServiceDetailType service_detail_type;
+	CORBA_sequence_octet service_detail;
+};
+
+typedef struct CORBA_ServiceInformation_struct {
+	CORBA_sequence_ServiceOption service_options;
+	CORBA_sequence_ServiceDetail service_details;
+} CORBA_ServiceInformation;
+
+#endif /* !_ORBIT_TYPES_H_ */
diff -urN linux-2.4.1/net/korbit/orb/poa.c linux-2.4.1-korbit/net/korbit/orb/poa.c
--- linux-2.4.1/net/korbit/orb/poa.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/poa.c	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,1387 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter, and Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *          Elliot Lee <sopwith@redhat.com>
+ *
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+#include "orbit.h"
+#include "orbit_poa.h"
+#include "genrand.h"
+
+PortableServer_ThreadPolicyValue
+PortableServer_ThreadPolicy__get_value(PortableServer_ThreadPolicy  obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		ev->_major = 2 ;
+		goto error_exit;
+	}
+	ev->_major = CORBA_NO_EXCEPTION;
+
+	return obj->value;
+
+error_exit:
+	CORBA_exception_set_system(ev, 0, CORBA_COMPLETED_NO);
+	return 0;
+}
+
+PortableServer_LifespanPolicyValue
+PortableServer_LifespanPolicy__get_value(PortableServer_LifespanPolicy  obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		ev->_major = 2 ;
+		goto error_exit;
+	}
+
+	ev->_major = CORBA_NO_EXCEPTION;
+	return obj->value;
+
+error_exit:
+	CORBA_exception_set_system(ev, 0, CORBA_COMPLETED_NO);
+	return 0;
+}
+
+PortableServer_IdUniquenessPolicyValue
+PortableServer_IdUniquenessPolicy__get_value(PortableServer_IdUniquenessPolicy  obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		ev->_major = 2 ;
+		goto error_exit;
+	}
+
+	ev->_major = CORBA_NO_EXCEPTION;
+	return obj->value;
+
+error_exit:
+	CORBA_exception_set_system(ev, 0, CORBA_COMPLETED_NO);
+	return 0;
+}
+
+PortableServer_IdAssignmentPolicyValue
+PortableServer_IdAssignmentPolicy__get_value(PortableServer_IdAssignmentPolicy  obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		ev->_major = 2 ;
+		goto error_exit;
+	}
+
+	ev->_major = CORBA_NO_EXCEPTION;
+	return obj->value;
+
+error_exit:
+	CORBA_exception_set_system(ev, 0, CORBA_COMPLETED_NO);
+	return 0;
+}
+
+PortableServer_ImplicitActivationPolicyValue
+PortableServer_ImplicitActivationPolicy__get_value(PortableServer_ImplicitActivationPolicy  obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		ev->_major = 2 ;
+		goto error_exit;
+	}
+
+	ev->_major = CORBA_NO_EXCEPTION;
+	return obj->value;
+
+error_exit:
+	CORBA_exception_set_system(ev, 0, CORBA_COMPLETED_NO);
+	return 0;
+}
+
+PortableServer_ServantRetentionPolicyValue
+PortableServer_ServantRetentionPolicy__get_value(PortableServer_ServantRetentionPolicy  obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		ev->_major = 2 ;
+		goto error_exit;
+	}
+
+	ev->_major = CORBA_NO_EXCEPTION;
+	return obj->value;
+
+error_exit:
+	CORBA_exception_set_system(ev, 0, CORBA_COMPLETED_NO);
+	return 0;
+}
+
+PortableServer_RequestProcessingPolicyValue
+PortableServer_RequestProcessingPolicy__get_value(PortableServer_RequestProcessingPolicy  obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		ev->_major = 2 ;
+		goto error_exit;
+	}
+
+	ev->_major = CORBA_NO_EXCEPTION;
+	return obj->value;
+
+error_exit:
+	CORBA_exception_set_system(ev, 0, CORBA_COMPLETED_NO);
+	return 0;
+}
+
+/* make emacs happy; */
+
+PortableServer_POAManager_State
+PortableServer_POAManager_get_state(PortableServer_POAManager obj,
+				    CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return -1;
+	}
+
+	ev->_major = CORBA_NO_EXCEPTION;
+	return obj->state;
+}
+
+/**** PortableServer_POAManager_activate
+      Inputs: 'obj' - a POAManager to activate
+      Outputs: '*ev' - result of the activate operation
+
+      Side effect: Clears the 'held_requests' lists for all POA's
+                   associated with the 'obj' POAManager.
+
+      Description: Sets the POAManager state to 'ACTIVE', then
+                   goes through all the POA's associated with this
+		   POAManager, and makes them re-process their
+		   'held_requests'
+ */
+void
+PortableServer_POAManager_activate(PortableServer_POAManager obj,
+				   CORBA_Environment *ev)
+{
+	GSList *todo;
+	GSList *curitem;
+	PortableServer_POA curpoa;
+
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	if(obj->state == PortableServer_POAManager_INACTIVE) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POAManager_AdapterInactive,
+				    NULL);
+		return;
+	}
+
+	obj->state = PortableServer_POAManager_ACTIVE;
+
+	for(curitem = obj->poa_collection; curitem;
+	    curitem = g_slist_next(curitem)) {
+		curpoa = (PortableServer_POA)curitem->data;
+
+		todo = curpoa->held_requests;
+		curpoa->held_requests = NULL;
+
+		g_slist_foreach(todo, (GFunc)ORBit_POA_handle_request,
+				curpoa);
+		g_slist_foreach(todo, (GFunc)giop_recv_buffer_unuse,
+				NULL);
+
+		g_slist_free(todo);
+	}
+	ev->_major = CORBA_NO_EXCEPTION;
+}
+
+void
+PortableServer_POAManager_hold_requests(PortableServer_POAManager obj,
+					CORBA_boolean wait_for_completion,
+					CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	if(obj->state == PortableServer_POAManager_INACTIVE) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POAManager_AdapterInactive,
+				    NULL);
+		return;
+	}
+
+	obj->state = PortableServer_POAManager_HOLDING;
+	if(!wait_for_completion)
+		g_warning("hold_requests not finished - don't know how to kill outstanding request fulfillments");
+
+	ev->_major = CORBA_NO_EXCEPTION;
+}
+
+void
+PortableServer_POAManager_discard_requests(PortableServer_POAManager obj,
+					   CORBA_boolean wait_for_completion,
+					   CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	if(obj->state == PortableServer_POAManager_INACTIVE) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POAManager_AdapterInactive,
+				    NULL);
+		return;
+	}
+
+	obj->state = PortableServer_POAManager_DISCARDING;
+	if(!wait_for_completion)
+		g_warning("discard_requests not finished - don't know how to kill outstanding request fulfillments");
+	ev->_major = CORBA_NO_EXCEPTION;
+}
+
+void
+PortableServer_POAManager_deactivate(PortableServer_POAManager obj,
+				     CORBA_boolean etherealize_objects,
+				     CORBA_boolean wait_for_completion,
+				     CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	if(obj->state == PortableServer_POAManager_INACTIVE) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POAManager_AdapterInactive,
+				    NULL);
+		return;
+	}
+
+	obj->state = PortableServer_POAManager_INACTIVE;
+
+	if(etherealize_objects)
+		g_slist_foreach(obj->poa_collection, (GFunc)ORBit_POA_etherealize_objects, ev);
+	ev->_major = CORBA_NO_EXCEPTION;
+}
+
+
+CORBA_boolean
+PortableServer_AdapterActivator_unknown_adapter(PortableServer_AdapterActivator obj,
+						PortableServer_POA parent,
+						CORBA_char *name,
+						CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(CORBA_FALSE);
+}
+
+
+/**** PortableServer_ServantActivator_incarnate
+ */
+PortableServer_Servant
+
+PortableServer_ServantActivator_incarnate
+(PortableServer_ServantActivator obj,
+ PortableServer_ObjectId *oid,
+ PortableServer_POA adapter,
+ CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+void
+PortableServer_ServantActivator_etherealize
+(PortableServer_ServantActivator obj,
+ PortableServer_ObjectId *oid, PortableServer_POA adapter,
+ PortableServer_Servant serv,
+ CORBA_boolean cleanup_in_progress,
+ CORBA_boolean remaining_activations,
+ CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return;
+}
+
+PortableServer_POA
+PortableServer_POA_create_POA
+               (PortableServer_POA poa,
+		CORBA_char *adapter_name,
+		PortableServer_POAManager a_POAManager,
+		CORBA_PolicyList* policies,
+		CORBA_Environment *ev)
+{
+	PortableServer_POA new_poa = NULL;
+	PortableServer_POA check_poa = NULL;
+	
+	/* Check for a child POA by the same name in parent */
+	check_poa = PortableServer_POA_find_POA(poa,adapter_name,
+						FALSE, ev);
+	CORBA_exception_free (ev);
+
+	if (!check_poa) {
+	  new_poa = ORBit_POA_new(poa->orb,
+				  adapter_name, a_POAManager, policies, ev);
+	} else {
+	  CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+			  ex_PortableServer_POA_AdapterAlreadyExists,
+			  NULL);
+	  new_poa = NULL;
+	}
+
+	if(ev->_major == CORBA_NO_EXCEPTION) {
+	  new_poa->parent_poa = poa;
+	  ORBit_POA_add_child(poa, new_poa, ev);
+	}
+
+	return new_poa;
+}
+
+/**** PortableServer_POA_find_POA
+      Inputs: 'obj' - a POA
+              'activate_it' - whether to activate unknown POA's
+
+      Outputs: 'child_poa'
+
+      Description: Finds (and optionally activates) a child POA of 'obj'
+                   with the specified names.
+
+      TODO: Activate non-existent adapters if asked.
+
+ */
+PortableServer_POA
+PortableServer_POA_find_POA(PortableServer_POA obj,
+			    CORBA_char *adapter_name,
+			    CORBA_boolean activate_it,
+			    CORBA_Environment *ev)
+{
+	GSList *curitem;
+	PortableServer_POA child_poa;
+
+	for(curitem = obj->child_POAs; curitem;
+	    curitem = g_slist_next(curitem)) {
+		child_poa = (PortableServer_POA)curitem->data;
+		if(!strcmp(child_poa->the_name, adapter_name)) {
+			ev->_major = CORBA_NO_EXCEPTION;
+			return child_poa;
+		}
+	}
+
+	if(activate_it)
+		g_warning("Don't yet know how to activate POA named \"%s\"",
+			  adapter_name);
+
+	CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+			    ex_PortableServer_POA_AdapterNonExistent,
+			    NULL);	
+
+	return NULL;
+}
+
+/**** PortableServer_POA_destroy
+      Inputs: 'obj' - the POA to be destroyed
+              'etherealize_objects' - flag indicating whether any servant
+	                              manager should be asked to etherealize
+				      objects in the active object map
+	      'wait_for_completion' - flag indicating whether to wait for
+	                              requests currently being handled
+ */
+void
+PortableServer_POA_destroy(PortableServer_POA obj,
+			   CORBA_boolean etherealize_objects,
+			   CORBA_boolean wait_for_completion,
+			   CORBA_Environment *ev)
+{
+	if(etherealize_objects || !wait_for_completion)
+		g_warning("PortableServer_POA_destroy not yet fully implemented; ignoring flags");
+
+	if(ORBIT_ROOT_OBJECT(obj)->refs > 1)
+		g_warning("POA has multiple refs [%d]",
+			  ORBIT_ROOT_OBJECT(obj)->refs);
+
+	CORBA_Object_release((CORBA_Object)obj, ev);
+	ev->_major = CORBA_NO_EXCEPTION;
+}
+
+PortableServer_ThreadPolicy PortableServer_POA_create_thread_policy(PortableServer_POA obj, PortableServer_ThreadPolicyValue value, CORBA_Environment *ev)
+{
+	PortableServer_ThreadPolicy retval;
+
+	retval = g_new(struct PortableServer_ThreadPolicy_type, 1);
+	ORBit_policy_object_init((CORBA_Policy)retval,
+				 PortableServer_THREAD_POLICY_ID, ev);
+
+	retval->value = value;
+
+	return (PortableServer_ThreadPolicy)CORBA_Object_duplicate((CORBA_Object)retval, ev);
+}
+
+PortableServer_LifespanPolicy PortableServer_POA_create_lifespan_policy(PortableServer_POA obj, PortableServer_LifespanPolicyValue value, CORBA_Environment *ev)
+{
+	PortableServer_LifespanPolicy retval;
+
+	retval = g_new(struct PortableServer_LifespanPolicy_type, 1);
+	ORBit_policy_object_init((CORBA_Policy)retval,
+				 PortableServer_LIFESPAN_POLICY_ID, ev);
+
+	retval->value = value;
+
+	return (PortableServer_LifespanPolicy)CORBA_Object_duplicate((CORBA_Object)retval, ev);
+}
+
+PortableServer_IdUniquenessPolicy PortableServer_POA_create_id_uniqueness_policy(PortableServer_POA obj, PortableServer_IdUniquenessPolicyValue value, CORBA_Environment *ev)
+{
+	PortableServer_IdUniquenessPolicy retval;
+
+	retval = g_new(struct PortableServer_IdUniquenessPolicy_type, 1);
+	ORBit_policy_object_init((CORBA_Policy)retval,
+				 PortableServer_ID_UNIQUENESS_POLICY_ID,
+				 ev);
+
+	retval->value = value;
+
+	return (PortableServer_IdUniquenessPolicy)CORBA_Object_duplicate((CORBA_Object)retval, ev);
+}
+
+PortableServer_IdAssignmentPolicy PortableServer_POA_create_id_assignment_policy(PortableServer_POA obj, PortableServer_IdAssignmentPolicyValue value, CORBA_Environment *ev)
+{
+	PortableServer_IdAssignmentPolicy retval;
+
+	retval = g_new(struct PortableServer_IdAssignmentPolicy_type, 1);
+	ORBit_policy_object_init((CORBA_Policy)retval,
+				 PortableServer_ID_ASSIGNMENT_POLICY_ID, ev);
+
+	retval->value = value;
+
+	return (PortableServer_IdAssignmentPolicy)CORBA_Object_duplicate((CORBA_Object)retval, ev);
+}
+
+PortableServer_ImplicitActivationPolicy PortableServer_POA_create_implicit_activation_policy(PortableServer_POA obj, PortableServer_ImplicitActivationPolicyValue value, CORBA_Environment *ev)
+{
+	PortableServer_ImplicitActivationPolicy retval;
+
+	retval = g_new(struct PortableServer_ImplicitActivationPolicy_type, 1);
+	ORBit_policy_object_init((CORBA_Policy)retval,
+				 PortableServer_IMPLICIT_ACTIVATION_POLICY_ID, ev);
+
+	retval->value = value;
+
+	return (PortableServer_ImplicitActivationPolicy)CORBA_Object_duplicate((CORBA_Object)retval, ev);
+}
+
+PortableServer_ServantRetentionPolicy PortableServer_POA_create_servant_retention_policy(PortableServer_POA obj, PortableServer_ServantRetentionPolicyValue value, CORBA_Environment *ev)
+{
+	PortableServer_ServantRetentionPolicy retval;
+
+	retval = g_new(struct PortableServer_ServantRetentionPolicy_type, 1);
+	ORBit_policy_object_init((CORBA_Policy)retval,
+				 PortableServer_SERVANT_RETENTION_POLICY_ID, ev);
+
+	retval->value = value;
+
+	return (PortableServer_ServantRetentionPolicy)CORBA_Object_duplicate((CORBA_Object)retval, ev);
+}
+
+PortableServer_RequestProcessingPolicy PortableServer_POA_create_request_processing_policy(PortableServer_POA obj, PortableServer_RequestProcessingPolicyValue value, CORBA_Environment *ev)
+{
+	PortableServer_RequestProcessingPolicy retval;
+
+	retval = g_new(struct PortableServer_RequestProcessingPolicy_type, 1);
+	ORBit_policy_object_init((CORBA_Policy)retval,
+				 PortableServer_REQUEST_PROCESSING_POLICY_ID, ev);
+
+	retval->value = value;
+
+	return (PortableServer_RequestProcessingPolicy)CORBA_Object_duplicate((CORBA_Object)retval, ev);
+}
+
+CORBA_char *PortableServer_POA__get_the_name(PortableServer_POA obj, CORBA_Environment *ev)
+{
+	g_assert(obj);
+	g_assert(obj->the_name);
+	return obj->the_name;
+}
+
+PortableServer_POA
+PortableServer_POA__get_the_parent(PortableServer_POA obj,
+				   CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return NULL;
+	}
+
+	return obj->parent_poa;
+}
+
+PortableServer_POAManager
+PortableServer_POA__get_the_POAManager(PortableServer_POA obj,
+				       CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return NULL;
+	}
+
+	return obj->the_POAManager;
+}
+
+PortableServer_AdapterActivator PortableServer_POA__get_the_activator(PortableServer_POA obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return NULL;
+	}
+
+	return obj->the_activator;
+}
+
+void PortableServer_POA__set_the_activator(PortableServer_POA obj, PortableServer_AdapterActivator the_activator, CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev,
+					   ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	obj->the_activator = the_activator;
+}
+
+PortableServer_ServantManager PortableServer_POA_get_servant_manager(PortableServer_POA obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return NULL;
+	}
+
+	if(obj->request_processing != PortableServer_USE_SERVANT_MANAGER) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return NULL;
+	}
+
+	return obj->servant_manager;
+}
+
+void PortableServer_POA_set_servant_manager(PortableServer_POA obj, PortableServer_ServantManager imgr, CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	if(obj->request_processing != PortableServer_USE_SERVANT_MANAGER) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return;
+	}
+
+	obj->servant_manager = imgr;
+}
+
+PortableServer_Servant PortableServer_POA_get_servant(PortableServer_POA obj, CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return NULL;
+	}
+
+	if(obj->request_processing != PortableServer_USE_DEFAULT_SERVANT) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return NULL;
+	}
+
+	return obj->default_servant;
+}
+
+void PortableServer_POA_set_servant(PortableServer_POA obj, PortableServer_Servant p_servant, CORBA_Environment *ev)
+{
+	if(!obj) {
+		CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	if(obj->request_processing != PortableServer_USE_DEFAULT_SERVANT) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return;
+	}
+
+	obj->default_servant = p_servant;
+}
+
+static CORBA_unsigned_long
+get_objnum_for_obj(PortableServer_POA poa, ORBit_POAObject *obj)
+{
+	CORBA_unsigned_long retval;
+
+	if(poa->first_free_id) {
+		retval = poa->first_free_id;
+		poa->first_free_id = GPOINTER_TO_UINT(g_ptr_array_index(poa->objnum_to_obj,
+									retval));
+		g_ptr_array_index(poa->objnum_to_obj, retval) = obj;
+	} else {
+		retval = poa->objnum_to_obj->len;
+		g_ptr_array_add(poa->objnum_to_obj,
+				obj);
+	}
+
+	return retval;
+}
+
+static CORBA_ORB
+get_orb_for_poa(PortableServer_POA poa)
+{
+	if(poa->orb)
+		return poa->orb;
+	if(poa->parent_poa)
+		return get_orb_for_poa(poa->parent_poa);
+
+	return CORBA_OBJECT_NIL;
+}
+
+PortableServer_ObjectId *
+PortableServer_POA_activate_object(PortableServer_POA obj,
+				   PortableServer_Servant p_servant,
+				   CORBA_Environment *ev)
+{
+	PortableServer_ServantBase *servant;
+	PortableServer_ObjectId *new_objid;
+	ORBit_POAObject *new_obj;
+
+	servant = p_servant;
+
+	if(obj->servant_retention != PortableServer_RETAIN
+	   || obj->id_assignment != PortableServer_SYSTEM_ID) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return NULL;
+	}
+	
+	/* Servant Already Active */
+	if((obj->id_uniqueness==PortableServer_UNIQUE_ID) &&
+	   (ORBIT_OBJECT_KEY(servant->_private)->object != 0)) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_ServantAlreadyActive,
+				    NULL);
+		return NULL;
+	}
+	
+
+	new_obj = g_new0(ORBit_POAObject, 1);
+	new_obj->object_id = (PortableServer_ObjectId*)CORBA_sequence_octet__alloc();
+
+	new_objid =
+		ORBit_POA_allocate_oid(obj,
+					ORBIT_OBJECT_KEY(servant->_private)->class_info->class_name);
+	
+	new_obj->object_id->_buffer = CORBA_octet_allocbuf(new_objid->_length);
+	new_obj->object_id->_length = new_objid->_length;
+	memcpy(new_obj->object_id->_buffer, new_objid->_buffer,
+		new_objid->_length);
+	CORBA_sequence_set_release(new_obj->object_id, CORBA_TRUE);
+
+	new_obj->servant = p_servant;
+	ORBIT_OBJECT_KEY(servant->_private)->object = new_obj;
+	new_obj->orb = get_orb_for_poa(obj);
+	new_obj->poa = obj;
+	new_obj->objnum = get_objnum_for_obj(obj, new_obj);
+	orbit_genrand(new_obj->rand_data, ORBIT_RAND_KEY_LEN);
+
+	g_hash_table_insert(obj->active_object_map,
+			    new_obj->object_id,
+			    new_obj);
+
+	ev->_major = CORBA_NO_EXCEPTION;
+
+	return new_objid;
+}
+
+void
+PortableServer_POA_activate_object_with_id(PortableServer_POA obj,
+					   PortableServer_ObjectId *id,
+					   PortableServer_Servant p_servant,
+					   CORBA_Environment *ev)
+{
+	PortableServer_ServantBase *servant = p_servant;
+	ORBit_POAObject *newobj;
+
+	if(!obj || !id || !p_servant) {
+		CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	newobj = g_hash_table_lookup(obj->active_object_map,
+				     id);
+
+	if(newobj) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_ObjectAlreadyActive, NULL);
+		return;
+	}
+
+	newobj = g_new0(ORBit_POAObject, 1);
+	newobj->object_id = (PortableServer_ObjectId *)CORBA_sequence_octet__alloc();
+	newobj->object_id->_length = id->_length;
+	newobj->object_id->_buffer = CORBA_octet_allocbuf(id->_length);
+	newobj->object_id->_release = CORBA_TRUE;
+	memcpy(newobj->object_id->_buffer, id->_buffer, id->_length);
+	newobj->poa = obj;
+	newobj->orb = get_orb_for_poa(obj);
+	newobj->objnum = get_objnum_for_obj(obj, newobj);
+	orbit_genrand(newobj->rand_data, ORBIT_RAND_KEY_LEN);
+
+	newobj->servant = p_servant;
+
+	g_hash_table_insert(obj->active_object_map,
+			    newobj->object_id,
+			    newobj);
+
+	ORBIT_OBJECT_KEY(servant->_private)->object = newobj;
+
+	ev->_major = CORBA_NO_EXCEPTION;
+}
+
+void
+PortableServer_POA_deactivate_object(PortableServer_POA obj,
+				     PortableServer_ObjectId *oid,
+				     CORBA_Environment *ev)
+{
+	ORBit_POAObject *oldobj;
+
+	if(!obj || !oid) {
+		CORBA_exception_set_system(ev, ex_CORBA_BAD_PARAM,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	oldobj = g_hash_table_lookup(obj->active_object_map,
+				     oid);
+
+	if(!oldobj) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_ObjectNotActive,
+				    NULL);
+		return;
+	}
+
+	g_ptr_array_index(obj->objnum_to_obj, oldobj->objnum) = GUINT_TO_POINTER(obj->first_free_id);
+	obj->first_free_id = oldobj->objnum;
+
+	g_hash_table_remove(obj->active_object_map, oid);
+
+	if(obj->request_processing == PortableServer_USE_SERVANT_MANAGER) {
+		POA_PortableServer_ServantActivator__epv *epv;
+		POA_PortableServer_ServantActivator *sm;
+
+		sm = (POA_PortableServer_ServantActivator *)obj->servant_manager;
+		epv = sm->vepv->PortableServer_ServantActivator_epv;
+		epv->etherealize(sm, oldobj->object_id, obj,
+				oldobj->servant,
+				CORBA_FALSE,
+				CORBA_FALSE,
+				ev);
+	}
+
+	CORBA_free(oldobj->object_id);
+
+	g_free(oldobj);
+	ev->_major = CORBA_NO_EXCEPTION;
+}
+
+CORBA_Object
+PortableServer_POA_create_reference(PortableServer_POA obj,
+				    CORBA_RepositoryId intf,
+				    CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+PortableServer_ObjectId *PortableServer_POA_servant_to_id(PortableServer_POA obj, PortableServer_Servant p_servant, CORBA_Environment *ev)
+{
+	PortableServer_ObjectId *retval, *orig;
+	PortableServer_ServantBase *serv = p_servant;
+	g_return_val_if_fail(p_servant != NULL, NULL);
+
+	orig = ORBIT_OBJECT_KEY(serv->_private)->object->object_id;
+	retval = (PortableServer_ObjectId *)CORBA_sequence_octet__alloc();
+	retval->_length = retval->_maximum = orig->_length;
+	retval->_buffer = CORBA_octet_allocbuf(retval->_length);
+	memcpy(retval->_buffer, orig->_buffer, retval->_length);
+	CORBA_sequence_set_release(retval, CORBA_TRUE);
+
+	return retval;
+}
+
+CORBA_Object
+PortableServer_POA_servant_to_reference(PortableServer_POA obj, PortableServer_Servant p_servant, CORBA_Environment *ev)
+{
+	CORBA_Object retval;
+	PortableServer_ObjectId *orig_id;
+	PortableServer_ServantBase *servant = p_servant;
+	ORBit_ObjectKey *obj_key =  ORBIT_OBJECT_KEY(servant->_private);
+	
+	int implicit = (obj->implicit_activation == PortableServer_IMPLICIT_ACTIVATION);
+	int activate_able = (obj_key->object == 0) ||
+		(obj->id_uniqueness==PortableServer_MULTIPLE_ID);
+	/* ImplicitActivationPolicy */
+	if( implicit && activate_able) {
+		orig_id = PortableServer_POA_activate_object(obj, p_servant, ev);
+	} else {
+		orig_id = obj_key->object->object_id;
+	}
+	retval = PortableServer_POA_id_to_reference(obj,orig_id,ev);
+
+	return retval;
+}
+
+PortableServer_Servant
+PortableServer_POA_reference_to_servant(PortableServer_POA obj, CORBA_Object reference, CORBA_Environment *ev)
+{
+	GSList *cur;
+
+	g_assert(reference);
+
+	if(obj->request_processing != PortableServer_USE_DEFAULT_SERVANT
+	   && obj->servant_retention != PortableServer_RETAIN) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return NULL;
+	}
+
+	if(reference->servant)
+		return reference->servant;
+
+	for(cur = reference->profile_list; cur; cur = cur->next) {
+		PortableServer_ObjectId *oid;
+		ORBit_Object_info *curprof = cur->data;
+		ORBit_POAObject *objinfo;
+
+		objinfo = ORBit_POA_find_oid_for_object_key(obj, &(curprof->object_key), &oid);
+		CORBA_free(oid);
+		if(objinfo)
+			return objinfo->servant;
+	}
+
+	CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+			    ex_PortableServer_POA_ObjectNotActive,
+			    NULL);
+	return NULL;
+}
+
+PortableServer_ObjectId *PortableServer_POA_reference_to_id(PortableServer_POA obj, CORBA_Object reference, CORBA_Environment *ev)
+{
+	PortableServer_ObjectId *retval;
+	ORBit_POAObject *objinfo;
+
+	g_assert(reference);
+	g_assert(reference->active_profile);
+
+	if(obj->request_processing != PortableServer_USE_DEFAULT_SERVANT
+	   && obj->servant_retention != PortableServer_RETAIN) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return NULL;
+	}
+
+	objinfo = ORBit_POA_find_oid_for_object_key(obj, &(reference->active_profile->object_key), &retval);
+	if(objinfo) {
+		CORBA_free(retval);
+		retval = (PortableServer_ObjectId *)CORBA_sequence_octet__alloc();
+		retval->_length = retval->_maximum = objinfo->object_id->_length;
+		retval->_buffer = CORBA_octet_allocbuf(retval->_length);
+		memcpy(retval->_buffer, objinfo->object_id->_buffer, retval->_length);
+		CORBA_sequence_set_release(retval, CORBA_TRUE);
+		return retval;
+	} else if(retval)
+		return retval;
+
+	CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+			    ex_PortableServer_POA_ObjectNotActive,
+			    NULL);
+	return NULL;
+}
+
+PortableServer_Servant PortableServer_POA_id_to_servant(PortableServer_POA obj, PortableServer_ObjectId *oid, CORBA_Environment *ev)
+{
+	ORBit_POAObject *objinfo;
+
+	if(obj->servant_retention != PortableServer_RETAIN) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return NULL;
+	}
+
+	objinfo = g_hash_table_lookup(obj->active_object_map,
+				      oid);
+
+	if(!objinfo) {
+		CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
+				    ex_PortableServer_POA_WrongPolicy,
+				    NULL);
+		return NULL;
+	}
+
+	return objinfo->servant;
+}
+
+static CORBA_Object
+my_PortableServer_POA_id_to_reference(PortableServer_POA obj,
+				      PortableServer_ObjectId *oid,
+				      const char *type_id,
+				      CORBA_Environment *ev)
+{
+	GSList *profiles=NULL;
+	ORBit_Object_info *object_info;
+	CORBA_Object retval;
+	CORBA_ORB orb;
+	ORBit_POAObject *pobj;
+	ORBit_ObjectKey *objkey = NULL;
+
+	orb = obj->the_POAManager->orb;
+
+	g_assert(!oid->_buffer[oid->_length - 1]);
+
+	pobj = g_hash_table_lookup(obj->active_object_map, oid);
+
+	if(pobj) {
+		objkey = ORBIT_OBJECT_KEY(((PortableServer_ServantBase *)pobj->servant)->_private);
+		type_id= objkey->class_info->class_name;
+	}
+
+	/* Do the local connection first, so it will be attempted first by
+	   the client parsing the IOR string
+	 */
+	if(orb->cnx.ipv6 || orb->cnx.usock) {
+		object_info = g_new0(ORBit_Object_info, 1);
+
+		object_info->profile_type=IOP_TAG_ORBIT_SPECIFIC;
+		object_info->iiop_major = 1;
+		object_info->iiop_minor = 0;
+
+		ORBit_POA_find_object_key_for_oid(obj, pobj, oid, &object_info->object_key);
+
+#ifdef HAVE_IPV6
+		if(orb->cnx.ipv6) {
+			object_info->tag.orbitinfo.ipv6_port =
+				ntohs(IIOP_CONNECTION(orb->cnx.ipv6)->u.ipv6.location.sin_port);
+		}
+#endif
+		if(orb->cnx.usock) {
+			object_info->tag.orbitinfo.unix_sock_path =
+				g_strdup(IIOP_CONNECTION(orb->cnx.usock)->u.usock.sun_path);
+		}
+		ORBit_set_object_key(object_info);
+		profiles=g_slist_append(profiles, object_info);
+	}
+
+	if(orb->cnx.ipv4) {
+		object_info=g_new0(ORBit_Object_info, 1);
+
+		object_info->profile_type = IOP_TAG_INTERNET_IOP;
+		object_info->iiop_major = 1;
+		object_info->iiop_minor = 0;
+		ORBit_POA_find_object_key_for_oid(obj, pobj, oid, &object_info->object_key);
+
+		object_info->tag.iopinfo.host = g_strdup(IIOP_CONNECTION(orb->cnx.ipv4)->u.ipv4.hostname);
+		object_info->tag.iopinfo.port = ntohs(IIOP_CONNECTION(orb->cnx.ipv4)->u.ipv4.location.sin_port);
+
+		ORBit_set_object_key(object_info);
+		profiles=g_slist_append(profiles, object_info);
+	}
+
+	retval = ORBit_create_object_with_info(profiles, type_id, orb, ev);
+
+	if(retval != CORBA_OBJECT_NIL
+	   && ev->_major == CORBA_NO_EXCEPTION
+	   && objkey && objkey->class_info && objkey->class_info->init_local_objref) {
+		/* XXX potential memleak if we get an already-valid objref */
+		retval->vepv = g_new0(gpointer, ORBit_class_assignment_counter + 1);
+		retval->vepv_size = ORBit_class_assignment_counter + 1;
+		objkey->class_info->init_local_objref(retval, pobj->servant);
+		retval->servant = pobj->servant;
+	} else
+		retval->vepv = retval->servant = NULL;
+
+	return retval;
+}
+
+CORBA_Object PortableServer_POA_id_to_reference(PortableServer_POA obj,
+						PortableServer_ObjectId *oid,
+						CORBA_Environment *ev)
+{
+	return my_PortableServer_POA_id_to_reference(obj, oid, NULL, ev);
+}
+
+CORBA_Object
+PortableServer_POA_create_reference_with_id(PortableServer_POA obj,
+					    PortableServer_ObjectId *oid,
+					    CORBA_RepositoryId intf,
+					    CORBA_Environment *ev)
+{
+	return my_PortableServer_POA_id_to_reference(obj, oid, intf, ev);
+}
+
+PortableServer_POA PortableServer_Current_get_POA(PortableServer_Current obj, CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+PortableServer_ObjectId *PortableServer_Current_get_object_id(PortableServer_Current obj, CORBA_Environment *ev)
+{
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+
+CORBA_char *PortableServer_ObjectId_to_string(PortableServer_ObjectId *id, CORBA_Environment *env)
+{
+	return CORBA_string_dup((CORBA_char *)id->_buffer);
+}
+
+CORBA_wchar *PortableServer_ObjectId_to_wstring(PortableServer_ObjectId *id, CORBA_Environment *env)
+{
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+PortableServer_ObjectId *PortableServer_string_to_ObjectId(CORBA_char *str, CORBA_Environment *env)
+{
+	PortableServer_ObjectId *retval;
+
+	retval = (PortableServer_ObjectId *)CORBA_sequence_octet__alloc();
+
+	retval->_length = strlen(str) + 1;
+	retval->_buffer = CORBA_octet_allocbuf(retval->_length);
+
+	memcpy(retval->_buffer, str, retval->_length);
+
+	return retval;
+}
+
+PortableServer_ObjectId *PortableServer_wstring_to_ObjectId(CORBA_wchar *str, CORBA_Environment *env)
+{
+	g_assert(!"Not yet implemented");
+	return(NULL);
+}
+
+
+PortableServer_POA PortableServer_ServantBase__default_POA(PortableServer_Servant servant, CORBA_Environment *ev)
+{
+	g_return_val_if_fail(servant, NULL);
+
+	return ORBIT_OBJECT_KEY(((PortableServer_ServantBase *)servant)->_private)->object->poa;
+}
+
+void PortableServer_ServantLocator_preinvoke(PortableServer_ObjectId *oid, PortableServer_POA adapter, CORBA_Identifier op_name, PortableServer_ServantLocator_Cookie *cookie)
+{
+	g_assert(!"Not yet implemented");
+	return;
+}
+
+void PortableServer_ServantLocator_postinvoke(PortableServer_ObjectId *oid, PortableServer_POA adapter, CORBA_Identifier op_name, PortableServer_ServantLocator_Cookie cookie, PortableServer_Servant servant)
+{
+	g_assert(!"Not yet implemented");
+	return;
+}
+
+void PortableServer_ServantBase__init(PortableServer_Servant servant,
+				      CORBA_Environment *ev)
+{
+	PortableServer_ServantBase *serv = servant;
+
+	if(!serv->_private) /* If not already initialized, create the place to
+			       stick our info */
+		serv->_private = g_new0(ORBit_ObjectKey, 1);
+}
+
+void PortableServer_ServantBase__fini(PortableServer_Servant servant,
+				      CORBA_Environment *ev)
+{
+	PortableServer_ServantBase *serv = servant;
+
+	g_free(serv->_private);
+	serv->_private = NULL;
+}
+
+
+/************************ ServerRequest stuff ********************/
+
+CORBA_Identifier CORBA_ServerRequest_operation(CORBA_ServerRequest req, CORBA_Environment *env)
+{
+	return CORBA_string_dup(req->rbuf->message.u.request.operation);
+}
+
+CORBA_Context
+CORBA_ServerRequest_ctx(CORBA_ServerRequest req, CORBA_Environment *env)
+{
+	if(!req->params || req->did_ctx) {
+		CORBA_exception_set_system(env, ex_CORBA_BAD_INV_ORDER,
+					   CORBA_COMPLETED_NO);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+void
+CORBA_ServerRequest_arguments(CORBA_ServerRequest req,
+			      CORBA_NVList *parameters,
+			      CORBA_Environment *env)
+{
+	int i;
+
+	if(req->params) {
+		CORBA_exception_set_system(env, ex_CORBA_BAD_INV_ORDER,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	req->params = parameters;
+
+	for(i = 0; i < parameters->list->len; i++) {
+		CORBA_NamedValue *cur;
+
+		cur = &g_array_index(parameters->list, CORBA_NamedValue, i);
+
+		if(cur->arg_modes & CORBA_ARG_OUT) continue;
+		cur->argument._value = ORBit_demarshal_arg(req->rbuf,
+							   cur->argument._type,
+							   TRUE,
+							   (CORBA_ORB)req->orb);
+		CORBA_any_set_release(&cur->argument, TRUE);
+	}
+}
+
+void
+CORBA_ServerRequest_set_result(CORBA_ServerRequest req,
+			       CORBA_any *value,
+			       CORBA_Environment *env)
+{
+	if(req->sbuf) {
+		CORBA_exception_set_system(env, ex_CORBA_BAD_INV_ORDER,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	req->sbuf = giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(req->rbuf)->connection,
+					       NULL,
+					       req->rbuf->message.u.request.request_id,
+					       CORBA_NO_EXCEPTION);
+	if(!req->sbuf) {
+		CORBA_exception_set_system(env, ex_CORBA_COMM_FAILURE,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+		
+	ORBit_marshal_arg(req->sbuf, value->_value, value->_type);
+}
+
+void
+CORBA_ServerRequest_set_exception(CORBA_ServerRequest req,
+				  CORBA_exception_type major,
+				  CORBA_any *value,
+				  CORBA_Environment *env)
+{
+	if(req->sbuf) {
+		CORBA_exception_set_system(env, ex_CORBA_BAD_INV_ORDER,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	req->sbuf = giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(req->rbuf)->connection,
+					       NULL,
+					       req->rbuf->message.u.request.request_id,
+					       major);
+	if(!req->sbuf) {
+		CORBA_exception_set_system(env, ex_CORBA_COMM_FAILURE,
+					   CORBA_COMPLETED_NO);
+		return;
+	}
+
+	req->did_exc = TRUE;
+
+	/* XXX do we really need to copy the repo_id into the
+	   send buffer? Or is there a way to assume that the CORBA_TypeCode
+	   value->_type will be around until after we send the message? */
+	{
+		CORBA_unsigned_long slen;
+		slen = strlen(value->_type->repo_id) + 1;
+		giop_send_buffer_append_mem_indirect_a(req->sbuf, &slen,
+						       sizeof(slen));
+		giop_send_buffer_append_mem_indirect(req->sbuf,
+						     value->_type->repo_id,
+						     slen);
+	}
+		
+	ORBit_marshal_arg(req->sbuf, value->_value, value->_type);
+}
+
+void
+POA_PortableServer_ServantActivator__init(PortableServer_Servant servant,
+					CORBA_Environment * ev)
+{
+	static const PortableServer_ClassInfo class_info =
+	{NULL,
+	"IDL:omg.org/PortableServer/ServantActivator:1.0",
+	NULL};
+
+	PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant), ev);
+
+	ORBIT_OBJECT_KEY(((PortableServer_ServantBase *)servant)->_private)->class_info = (gpointer)&class_info;
+}
+
+void
+POA_PortableServer_ServantActivator__fini(PortableServer_Servant servant,
+					CORBA_Environment * ev)
+{
+	PortableServer_ServantBase__fini(servant, ev);
+}
+
+void
+POA_PortableServer_ServantLocator__init(PortableServer_Servant servant,
+					CORBA_Environment * ev)
+{
+	static const PortableServer_ClassInfo class_info =
+	{NULL,
+	"IDL:omg.org/PortableServer/ServantLocator:1.0",
+	NULL};
+
+	PortableServer_ServantBase__init(((PortableServer_ServantBase *)servant), ev);
+
+	ORBIT_OBJECT_KEY(((PortableServer_ServantBase *)servant)->_private)->class_info = (gpointer)&class_info;
+}
+
+void
+POA_PortableServer_ServantLocator__fini(PortableServer_Servant servant,
+					CORBA_Environment * ev)
+{
+	PortableServer_ServantBase__fini(servant, ev);
+}
+
+/* POA-related DSI stuff */
+static void
+dynamic_impl_skel(PortableServer_DynamicImpl *_ORBIT_servant,
+		  GIOPRecvBuffer *_ORBIT_recv_buffer,
+		  CORBA_Environment *ev,
+		  PortableServer_DynamicImplRoutine invoke)
+{
+	/* here the magic occurs... */
+	struct CORBA_ServerRequest_type sr;
+
+	ORBit_pseudo_object_init(ORBIT_PSEUDO_OBJECT(&sr),
+				 ORBIT_PSEUDO_SERVERREQUEST, ev);
+
+	CORBA_Object_duplicate((CORBA_Object)&sr, ev); /* just to make
+							  sure it doesn't die
+							  elsewhere */
+
+	sr.rbuf = _ORBIT_recv_buffer;
+	sr.orb = GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->connection->orb_data;
+
+	_ORBIT_servant->vepv->PortableServer_DynamicImpl_epv->invoke(_ORBIT_servant,
+								     &sr);
+
+	if(sr.sbuf) {
+		int i;
+		for(i = 0; i < sr.params->list->len; i++) {
+			CORBA_NamedValue *cur;
+			
+			cur = &g_array_index(sr.params->list, CORBA_NamedValue, i);
+			
+			if(cur->arg_modes & CORBA_ARG_IN) continue;
+
+			ORBit_marshal_arg(sr.sbuf, cur->argument._value,
+					  cur->argument._type);
+		}
+
+		giop_send_buffer_write(sr.sbuf);
+		giop_send_buffer_unuse(sr.sbuf);
+	} else
+		g_warning("Yo, your DSI code is messed up! You forgot to set_result|set_exception");
+
+	CORBA_NVList_free(sr.params, ev);
+}
+
+static ORBitSkeleton 
+dynamic_impl_get_skel(PortableServer_DynamicImpl * servant,
+		      GIOPRecvBuffer * _ORBIT_recv_buffer,
+		      gpointer * impl)
+{
+	*impl = (gpointer)servant->vepv->PortableServer_DynamicImpl_epv->invoke;
+
+	return (ORBitSkeleton)dynamic_impl_skel;
+}
+
+void
+PortableServer_DynamicImpl__init(PortableServer_Servant servant,
+				 CORBA_Environment *ev)
+{
+	static const PortableServer_ClassInfo class_info =
+	{(ORBitSkeleton (*)(PortableServer_ServantBase *, gpointer, gpointer *))
+	 &dynamic_impl_get_skel, "IDL:CORBA/Object:1.0", NULL};
+	
+	PortableServer_ServantBase__init(servant, ev);
+	
+	ORBIT_OBJECT_KEY(((PortableServer_ServantBase *)servant)->_private)->class_info =
+		(PortableServer_ClassInfo *) & class_info;
+	
+}
+
+void PortableServer_DynamicImpl__fini(PortableServer_Servant servant,
+				      CORBA_Environment *ev)
+{
+	PortableServer_ServantBase__fini(servant, ev);
+}
+
diff -urN linux-2.4.1/net/korbit/orb/poa.h linux-2.4.1-korbit/net/korbit/orb/poa.h
--- linux-2.4.1/net/korbit/orb/poa.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/poa.h	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,337 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_POA_H_
+#define _ORBIT_POA_H_
+
+#include "orbit_types.h"
+
+extern PortableServer_ThreadPolicyValue PortableServer_ThreadPolicy__get_value(
+	PortableServer_ThreadPolicy obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_LifespanPolicyValue PortableServer_LifespanPolicy__get_value(
+	PortableServer_LifespanPolicy obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_IdUniquenessPolicyValue PortableServer_IdUniquenessPolicy__get_value(
+	PortableServer_IdUniquenessPolicy obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_IdAssignmentPolicyValue PortableServer_IdAssignmentPolicy__get_value(
+	PortableServer_IdAssignmentPolicy obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_ImplicitActivationPolicyValue PortableServer_ImplicitActivationPolicy__get_value(
+	PortableServer_ImplicitActivationPolicy obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_ServantRetentionPolicyValue PortableServer_ServantRetentionPolicy__get_value(
+	PortableServer_ServantRetentionPolicy obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_RequestProcessingPolicyValue PortableServer_RequestProcessingPolicy__get_value(
+	PortableServer_RequestProcessingPolicy obj,
+	CORBA_Environment *ev);
+
+PortableServer_POAManager_State
+PortableServer_POAManager_get_state(PortableServer_POAManager obj,
+				    CORBA_Environment *ev);
+
+extern void PortableServer_POAManager_activate(
+	PortableServer_POAManager obj,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POAManager_hold_requests(
+	PortableServer_POAManager obj,
+	CORBA_boolean wait_for_completion,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POAManager_discard_requests(
+	PortableServer_POAManager obj,
+	CORBA_boolean wait_for_completion,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POAManager_deactivate(
+	PortableServer_POAManager obj,
+	CORBA_boolean etherealize_objects,
+	CORBA_boolean wait_for_completion,
+	CORBA_Environment *ev);
+
+extern CORBA_boolean PortableServer_AdapterActivator_unknown_adapter(
+	PortableServer_AdapterActivator obj,
+	PortableServer_POA parent,
+	CORBA_char *name,
+	CORBA_Environment *ev);
+
+extern PortableServer_Servant PortableServer_ServantActivator_incarnate(
+	PortableServer_ServantActivator obj,
+	PortableServer_ObjectId *oid,
+	PortableServer_POA adapter,
+	CORBA_Environment *ev);
+
+extern void PortableServer_ServantActivator_etherealize(
+	PortableServer_ServantActivator obj,
+	PortableServer_ObjectId *oid,
+	PortableServer_POA adapter,
+	PortableServer_Servant serv,
+	CORBA_boolean cleanup_in_progress,
+	CORBA_boolean remaining_activations,
+	CORBA_Environment *ev);
+
+extern PortableServer_POA PortableServer_POA_create_POA(
+	PortableServer_POA obj,
+	CORBA_char *adapter_name,
+	PortableServer_POAManager a_POAManager,
+	CORBA_PolicyList *policies,
+	CORBA_Environment *ev);
+
+extern PortableServer_POA PortableServer_POA_find_POA(
+	PortableServer_POA obj,
+	CORBA_char *adapter_name,
+	CORBA_boolean activate_it,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POA_destroy(
+	PortableServer_POA obj,
+	CORBA_boolean etherealize_objects,
+	CORBA_boolean wait_for_completion,
+	CORBA_Environment *ev);
+
+extern PortableServer_ThreadPolicy PortableServer_POA_create_thread_policy(
+	PortableServer_POA obj,
+	PortableServer_ThreadPolicyValue value,
+	CORBA_Environment *ev);
+
+extern PortableServer_LifespanPolicy PortableServer_POA_create_lifespan_policy(
+	PortableServer_POA obj,
+	PortableServer_LifespanPolicyValue value,
+	CORBA_Environment *ev);
+
+extern PortableServer_IdUniquenessPolicy PortableServer_POA_create_id_uniqueness_policy(
+	PortableServer_POA obj,
+	PortableServer_IdUniquenessPolicyValue value,
+	CORBA_Environment *ev);
+
+extern PortableServer_IdAssignmentPolicy PortableServer_POA_create_id_assignment_policy(
+	PortableServer_POA obj,
+	PortableServer_IdAssignmentPolicyValue value,
+	CORBA_Environment *ev);
+
+extern PortableServer_ImplicitActivationPolicy PortableServer_POA_create_implicit_activation_policy(
+	PortableServer_POA obj,
+	PortableServer_ImplicitActivationPolicyValue value,
+	CORBA_Environment *ev);
+
+extern PortableServer_ServantRetentionPolicy PortableServer_POA_create_servant_retention_policy(
+	PortableServer_POA obj,
+	PortableServer_ServantRetentionPolicyValue value,
+	CORBA_Environment *ev);
+
+extern PortableServer_RequestProcessingPolicy PortableServer_POA_create_request_processing_policy(
+	PortableServer_POA obj,
+	PortableServer_RequestProcessingPolicyValue value,
+	CORBA_Environment *ev);
+
+extern CORBA_char *PortableServer_POA__get_the_name(
+	PortableServer_POA obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_POA PortableServer_POA__get_the_parent(
+	PortableServer_POA obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_POAManager PortableServer_POA__get_the_POAManager(
+	PortableServer_POA obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_AdapterActivator PortableServer_POA__get_the_activator(
+	PortableServer_POA obj,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POA__set_the_activator(
+	PortableServer_POA obj,
+	PortableServer_AdapterActivator the_activator,
+	CORBA_Environment *ev);
+
+extern PortableServer_ServantManager PortableServer_POA_get_servant_manager(
+	PortableServer_POA obj,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POA_set_servant_manager(
+	PortableServer_POA obj,
+	PortableServer_ServantManager imgr,
+	CORBA_Environment *ev);
+
+extern PortableServer_Servant PortableServer_POA_get_servant(
+	PortableServer_POA obj,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POA_set_servant(
+	PortableServer_POA obj,
+	PortableServer_Servant p_servant,
+	CORBA_Environment *ev);
+
+extern PortableServer_ObjectId *PortableServer_POA_activate_object(
+	PortableServer_POA obj,
+	PortableServer_Servant p_servant,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POA_activate_object_with_id(
+	PortableServer_POA obj,
+	PortableServer_ObjectId *id,
+	PortableServer_Servant p_servant,
+	CORBA_Environment *ev);
+
+extern void PortableServer_POA_deactivate_object(
+	PortableServer_POA obj,
+	PortableServer_ObjectId *oid,
+	CORBA_Environment *ev);
+
+extern CORBA_Object PortableServer_POA_create_reference(
+	PortableServer_POA obj,
+	CORBA_RepositoryId intf,
+	CORBA_Environment *ev);
+
+extern CORBA_Object PortableServer_POA_create_reference_with_id(
+	PortableServer_POA obj,
+	PortableServer_ObjectId *oid,
+	CORBA_RepositoryId intf,
+	CORBA_Environment *ev);
+
+extern PortableServer_ObjectId *PortableServer_POA_servant_to_id(
+	PortableServer_POA obj,
+	PortableServer_Servant p_servant,
+	CORBA_Environment *ev);
+
+extern CORBA_Object PortableServer_POA_servant_to_reference(
+	PortableServer_POA obj,
+	PortableServer_Servant p_servant,
+	CORBA_Environment *ev);
+
+extern PortableServer_Servant PortableServer_POA_reference_to_servant(
+	PortableServer_POA obj,
+	CORBA_Object reference,
+	CORBA_Environment *ev);
+
+extern PortableServer_ObjectId *PortableServer_POA_reference_to_id(
+	PortableServer_POA obj,
+	CORBA_Object reference,
+	CORBA_Environment *ev);
+
+extern PortableServer_Servant PortableServer_POA_id_to_servant(
+	PortableServer_POA obj,
+	PortableServer_ObjectId *oid,
+	CORBA_Environment *ev);
+
+extern CORBA_Object PortableServer_POA_id_to_reference(
+	PortableServer_POA obj,
+	PortableServer_ObjectId *oid,
+	CORBA_Environment *ev);
+
+extern PortableServer_POA PortableServer_Current_get_POA(
+	PortableServer_Current obj,
+	CORBA_Environment *ev);
+
+extern PortableServer_ObjectId *PortableServer_Current_get_object_id(
+	PortableServer_Current obj,
+	CORBA_Environment *ev);
+
+extern CORBA_char *PortableServer_ObjectId_to_string(
+	PortableServer_ObjectId *id,
+	CORBA_Environment *env);
+
+extern CORBA_wchar *PortableServer_ObjectId_to_wstring(
+	PortableServer_ObjectId *id,
+	CORBA_Environment *env);
+
+extern PortableServer_ObjectId *PortableServer_string_to_ObjectId(
+	CORBA_char *str,
+	CORBA_Environment *env);
+
+extern PortableServer_ObjectId *PortableServer_wstring_to_ObjectId(
+	CORBA_wchar *str,
+	CORBA_Environment *env);
+
+extern PortableServer_POA PortableServer_ServantBase__default_POA(
+	PortableServer_Servant,
+	CORBA_Environment *);
+
+extern void PortableServer_ServantLocator_preinvoke(
+	PortableServer_ObjectId *oid,
+	PortableServer_POA adapter,
+	CORBA_Identifier op_name,
+	PortableServer_ServantLocator_Cookie *cookie);
+
+extern void PortableServer_ServantLocator_postinvoke(
+	PortableServer_ObjectId *oid,
+	PortableServer_POA adapter,
+	CORBA_Identifier op_name,
+	PortableServer_ServantLocator_Cookie cookie,
+	PortableServer_Servant servant);
+
+extern void PortableServer_ServantBase__init(
+	PortableServer_Servant,
+	CORBA_Environment *);
+
+extern void PortableServer_ServantBase__fini(
+	PortableServer_Servant,
+	CORBA_Environment *);
+
+/* 19.27 */
+extern CORBA_Identifier CORBA_ServerRequest_operation(
+	CORBA_ServerRequest req,
+	CORBA_Environment *env);
+
+extern CORBA_Context CORBA_ServerRequest_ctx(
+	CORBA_ServerRequest req,
+	CORBA_Environment *env);
+
+extern void CORBA_ServerRequest_arguments(
+	CORBA_ServerRequest req,
+	CORBA_NVList *parameters,
+	CORBA_Environment *env);
+
+extern void CORBA_ServerRequest_set_result(
+	CORBA_ServerRequest req,
+	CORBA_any *value,
+	CORBA_Environment *env);
+
+extern void CORBA_ServerRequest_set_exception(
+	CORBA_ServerRequest req,
+	CORBA_exception_type major,
+	CORBA_any *value,
+	CORBA_Environment *env);
+
+extern void PortableServer_DynamicImpl__init(PortableServer_Servant,
+					     CORBA_Environment *ev);
+
+extern void PortableServer_DynamicImpl__fini(PortableServer_Servant,
+					     CORBA_Environment *ev);
+
+
+#include "orbit_poa_type.h"
+
+#endif /* !_ORBIT_POA_H_ */
diff -urN linux-2.4.1/net/korbit/orb/sequences.c linux-2.4.1-korbit/net/korbit/orb/sequences.c
--- linux-2.4.1/net/korbit/orb/sequences.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/sequences.c	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,35 @@
+#include "orbit.h"
+#include "sequences.h"
+
+gpointer CORBA_sequence_octet_free(gpointer mem,
+				   gpointer func_data)
+{
+  CORBA_sequence_octet *seqo = mem;
+
+  if(seqo->_release)
+    CORBA_free(seqo->_buffer);
+
+  return (gpointer)((guchar *)mem + sizeof(CORBA_sequence_octet));
+}
+
+CORBA_octet *
+CORBA_octet_allocbuf(CORBA_unsigned_long len)
+{
+  return (CORBA_octet *)ORBit_alloc(len, NULL, NULL);
+}
+
+CORBA_sequence_octet *CORBA_sequence_octet__alloc(void)
+{
+  CORBA_sequence_octet *seqo;
+
+  seqo = ORBit_alloc(sizeof(CORBA_sequence_octet),
+		     (ORBit_free_childvals)CORBA_sequence_octet_free,
+		     GUINT_TO_POINTER(1));
+
+  seqo->_length = seqo->_maximum = 0;
+  seqo->_buffer = NULL;
+  seqo->_release = CORBA_TRUE;
+
+  return seqo;
+}
+
diff -urN linux-2.4.1/net/korbit/orb/sequences.h linux-2.4.1-korbit/net/korbit/orb/sequences.h
--- linux-2.4.1/net/korbit/orb/sequences.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/sequences.h	Thu Feb  1 16:21:19 2001
@@ -0,0 +1,35 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_SEQUENCES_H_
+#define _ORBIT_SEQUENCES_H_
+
+/* #include "corba_sequences_type.h" */
+#include "orbit_types.h"
+
+CORBA_octet *CORBA_octet_allocbuf(CORBA_unsigned_long len);
+CORBA_sequence_octet *CORBA_sequence_octet__alloc(void);
+
+#endif /* !_ORBIT_SEQUENCES_H_ */
diff -urN linux-2.4.1/net/korbit/orb/server.c linux-2.4.1-korbit/net/korbit/orb/server.c
--- linux-2.4.1/net/korbit/orb/server.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/server.c	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,217 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/* Elliot's stuff */
+/* This is somewhat a mess, because I tried to make it easy to add
+   select() support, and as a result #ifdef's litter the land. */
+
+#include "orbit.h"
+#include "orbit_poa.h"
+#include "orbit_poa_type.h"
+#include <IIOP/IIOP-private.h>
+#ifdef HAVE_SYS_POLL_H
+#include <sys/poll.h>
+#endif
+#include <sys/types.h>
+#include <sys/socket.h>
+
+/* We need:
+   a way to find out what FD's need to be selected on
+   a dummy main loop to implement the CORBA_ORB_run() routine;
+*/
+
+gboolean orb_server_keep_running = FALSE;
+
+ORBit_request_validate ORBIT_request_validator = NULL;
+
+/* function protos */
+static PortableServer_POA ORBit_find_POA_for_request(PortableServer_POA poa,
+						     GIOPRecvBuffer *recv_buffer);
+static PortableServer_POA ORBit_find_POA_for_locate_request(PortableServer_POA poa,
+						     GIOPRecvBuffer *recv_buffer);
+
+static void ORBit_handle_incoming_message(GIOPRecvBuffer *recv_buffer);
+
+void
+ORBit_custom_run_setup(CORBA_ORB orb, CORBA_Environment *ev)
+{
+	IIOPIncomingMessageHandler = ORBit_handle_incoming_message;
+}
+
+
+#if __KERNEL__
+// Modules don't do anything when they call this...
+void CORBA_ORB_run(CORBA_ORB orb, CORBA_Environment *ev) {
+	// This should probably free the ORB pointer, because it is a 
+	// duplicated pointer from the one true orb.
+
+}
+
+// The ORB thread calls __CORBA_ORB_run by itself.
+#define CORBA_ORB_run __CORBA_ORB_run
+
+#endif
+
+void
+CORBA_ORB_run(CORBA_ORB orb, CORBA_Environment *ev)
+{
+	ORBit_custom_run_setup(orb, ev);
+
+	orb_server_keep_running = TRUE;
+
+	giop_main();
+}
+
+static void
+ORBit_handle_incoming_request(GIOPRecvBuffer *recv_buffer)
+{
+	CORBA_ORB orb;
+	PortableServer_POA poa;
+	GIOPConnection *connection;
+	ORBit_MessageValidationResult mvr;
+	gboolean do_unuse = TRUE;
+
+	g_assert(recv_buffer);
+
+	connection = GIOP_MESSAGE_BUFFER(recv_buffer)->connection;
+	g_return_if_fail(connection != NULL);
+
+	orb = connection->orb_data;
+
+	g_return_if_fail(orb != NULL);
+
+	ORBit_Trace(TraceMod_ORB, TraceLevel_Debug,
+		    "Received request %s, id %d, on %s",
+		    recv_buffer->message.u.request.operation,
+		    recv_buffer->message.u.request.request_id,
+		    recv_buffer->message.u.request.object_key._buffer);
+
+	if(ORBIT_request_validator)
+		mvr = ORBIT_request_validator(recv_buffer->message.u.request.request_id,
+					      &recv_buffer->message.u.request.requesting_principal,
+					      recv_buffer->message.u.request.operation);
+	else
+		mvr = ORBIT_MESSAGE_ALLOW;
+
+	if(mvr == ORBIT_MESSAGE_ALLOW_ALL)
+		connection->is_auth = TRUE;
+
+	if(mvr != ORBIT_MESSAGE_BAD) {
+		/* Find the POA for this incoming request */
+		poa = ORBit_find_POA_for_request((PortableServer_POA)orb->root_poa,
+						 recv_buffer);
+			
+		if(poa)
+			do_unuse = ORBit_POA_handle_request(recv_buffer, poa);
+		else
+			g_warning("No POA found for operation %s [%d]",
+				  recv_buffer->message.u.request.operation,
+				  recv_buffer->message.u.request.request_id);
+	} else {
+		g_warning("Request %s, ID %d was rejected by the authentication mechanism!",
+			  recv_buffer->message.u.request.operation,
+			  recv_buffer->message.u.request.request_id);
+	}
+
+	if(do_unuse)
+		giop_recv_buffer_unuse(recv_buffer);
+}
+
+static void
+ORBit_handle_incoming_locate_request(GIOPRecvBuffer *recv_buffer)
+{
+	CORBA_ORB orb;
+	PortableServer_POA poa;
+	GIOPConnection *connection;
+	GIOPSendBuffer *send_buffer;
+
+	g_assert(recv_buffer!=NULL);
+
+	connection = GIOP_MESSAGE_BUFFER(recv_buffer)->connection;
+	g_return_if_fail(connection != NULL);
+
+	orb = connection->orb_data;
+
+	g_return_if_fail(orb != NULL);
+
+	ORBit_Trace(TraceMod_ORB, TraceLevel_Debug,
+		    "Received locate request id %d, on %s",
+		    recv_buffer->message.u.locate_request.request_id,
+		    recv_buffer->message.u.locate_request.object_key._buffer);
+	/* Find the POA for this incoming request */
+	poa = ORBit_find_POA_for_locate_request((PortableServer_POA)orb->root_poa, recv_buffer);
+		
+	if(poa) {
+		/* Object found, reply with "Object Here" */
+		send_buffer = giop_send_locate_reply_buffer_use(connection,
+			 recv_buffer->message.u.locate_request.request_id,
+			 GIOP_OBJECT_HERE);
+		giop_send_buffer_write(send_buffer);
+		giop_send_buffer_unuse(send_buffer);
+	} else {
+		/* Object not found, reply with "Unknown Object" */
+		send_buffer = giop_send_locate_reply_buffer_use(connection,
+			 recv_buffer->message.u.locate_request.request_id,
+			 GIOP_UNKNOWN_OBJECT);
+		giop_send_buffer_write(send_buffer);
+		giop_send_buffer_unuse(send_buffer);
+	}
+
+	giop_recv_buffer_unuse(recv_buffer);
+}
+
+static void
+ORBit_handle_incoming_message(GIOPRecvBuffer *recv_buffer)
+{
+	GIOPConnection *connection;
+
+	g_assert(recv_buffer);
+
+	connection = GIOP_MESSAGE_BUFFER(recv_buffer)->connection;
+	g_return_if_fail(connection != NULL);
+
+	switch(GIOP_MESSAGE_BUFFER(recv_buffer)->message_header.message_type) {
+	case GIOP_REQUEST:
+		ORBit_handle_incoming_request(recv_buffer);
+		break;
+	case GIOP_LOCATEREQUEST:
+		ORBit_handle_incoming_locate_request(recv_buffer);
+		break;
+	case GIOP_CLOSECONNECTION:
+		/* Lame hack - need to do this in a manner that isn't
+                   IIOP-specific */
+		giop_recv_buffer_unuse(recv_buffer);
+		giop_main_handle_connection_exception(connection);
+		break;
+	case GIOP_REPLY:
+		/* the above comment probably applies here also... */
+		giop_received_list_push(recv_buffer);
+		break;
+	default:
+		g_warning("discarding message type %d (id possibly %d)",
+			  GIOP_MESSAGE_BUFFER(recv_buffer)->message_header.message_type,
+			  GIOP_MESSAGE_BUFFER(recv_buffer)->message_header.message_type?recv_buffer->message.u.reply.request_id:recv_buffer->message.u.request.request_id);
+		break;
+	}
+}
+
+static PortableServer_POA
+ORBit_find_POA_for_request(PortableServer_POA poa,
+			   GIOPRecvBuffer *recv_buffer)
+{
+	return ORBit_POA_find_POA_for_object_key(poa,
+						 &recv_buffer->message.u.request.object_key);
+}
+
+static PortableServer_POA
+ORBit_find_POA_for_locate_request(PortableServer_POA poa,
+			   GIOPRecvBuffer *recv_buffer)
+{
+	return ORBit_POA_find_POA_for_object_key(poa,
+						 &recv_buffer->message.u.locate_request.object_key);
+}
+
+void
+ORBit_set_request_validation_handler(ORBit_request_validate validator)
+{
+	ORBIT_request_validator = validator;
+}
diff -urN linux-2.4.1/net/korbit/orb/typecode.c linux-2.4.1-korbit/net/korbit/orb/typecode.c
--- linux-2.4.1/net/korbit/orb/typecode.c	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/typecode.c	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,104 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter, Red Hat Software
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *          Elliot Lee <sopwith@cuc.edu>
+ *
+ */
+
+#include "orbit.h"
+#include "orbit_typecode.h"
+ 
+const struct CORBA_TypeCode_struct TC_null_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_null, "null", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_void_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_void, "void", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_short_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_short, "short", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_long_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_long, "long", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_longlong_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_longlong, "long long", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_ushort_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_ushort, "unsigned short", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_ulong_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_ulong, "unsigned long", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_ulonglong_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_ulonglong, "unsigned long long", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_float_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_float, "float", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_double_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_double, "double", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_longdouble_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_longdouble, "long double", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_boolean_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_boolean, "boolean", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_char_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_char, "char", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_wchar_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_wchar, "wide char", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_octet_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_octet, "octet", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_any_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_any, "any", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_TypeCode_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_TypeCode, "TypeCode", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_Principal_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_Principal, "Principal", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_Object_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_objref, "Object Reference", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_string_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_string, "string", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_wstring_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_wstring, "wide string", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+const struct CORBA_TypeCode_struct TC_CORBA_NamedValue_struct=
+	{{{(ORBit_RootObject_Interface *)&ORBit_TypeCode_epv, CORBA_FALSE, -1}, ORBIT_PSEUDO_TYPECODE}, CORBA_tk_struct, "CORBA NamedValue", "", 0, 0, NULL, NULL, NULL, NULL, -1, 0, 0, 0};
+
+static const CORBA_TypeCode anon_subtypes_array7[] =
+{(CORBA_TypeCode) & TC_CORBA_string_struct};
+
+#if (TC_IMPL_TC_CORBA_Identifier_0 == '/')
+const struct CORBA_TypeCode_struct TC_CORBA_Identifier_struct =
+{
+   {
+      {(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1}, ORBIT_PSEUDO_TYPECODE},
+   CORBA_tk_alias, "Identifier", "IDL:omg.org/CORBA/Identifier:1.0",
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array7,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
+
+#if (TC_IMPL_TC_CORBA_RepositoryId_0 == '/')
+const struct CORBA_TypeCode_struct TC_CORBA_RepositoryId_struct =
+{
+   {
+      {(ORBit_RootObject_Interface *) & ORBit_TypeCode_epv, TRUE, -1}, ORBIT_PSEUDO_TYPECODE},
+   CORBA_tk_alias, "RepositoryId", "IDL:omg.org/CORBA/RepositoryId:1.0",
+   0, 1,
+   NULL,
+   (CORBA_TypeCode *) anon_subtypes_array7,
+   NULL,
+   CORBA_OBJECT_NIL, 0, -1, 0, 0
+};
+#endif
diff -urN linux-2.4.1/net/korbit/orb/typecode.h linux-2.4.1-korbit/net/korbit/orb/typecode.h
--- linux-2.4.1/net/korbit/orb/typecode.h	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/orb/typecode.h	Thu Feb  1 11:47:14 2001
@@ -0,0 +1,31 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  ORBit: A CORBA v2.2 ORB
+ *
+ *  Copyright (C) 1998 Richard H. Porter
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Author: Dick Porter <dick@cymru.net>
+ *
+ */
+
+#ifndef _ORBIT_TYPECODE_H_
+#define _ORBIT_TYPECODE_H_
+
+#include "orbit_types.h"
+
+#endif /* !_ORBIT_TYPECODE_H_ */
diff -urN linux-2.4.1/net/korbit/sup/CVS/Entries linux-2.4.1-korbit/net/korbit/sup/CVS/Entries
--- linux-2.4.1/net/korbit/sup/CVS/Entries	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/sup/CVS/Entries	Thu Feb  1 11:47:15 2001
@@ -0,0 +1 @@
+D
diff -urN linux-2.4.1/net/korbit/sup/CVS/Repository linux-2.4.1-korbit/net/korbit/sup/CVS/Repository
--- linux-2.4.1/net/korbit/sup/CVS/Repository	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/sup/CVS/Repository	Thu Feb  1 11:47:15 2001
@@ -0,0 +1 @@
+/cvsroot/korbit/linux/net/korbit/sup
diff -urN linux-2.4.1/net/korbit/sup/CVS/Root linux-2.4.1-korbit/net/korbit/sup/CVS/Root
--- linux-2.4.1/net/korbit/sup/CVS/Root	Thu Jan  1 03:00:00 1970
+++ linux-2.4.1-korbit/net/korbit/sup/CVS/Root	Thu Feb  1 11:47:15 2001
@@ -0,0 +1 @@
+vraalsen@cvs.korbit.sourceforge.net:/cvsroot/korbit