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 +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 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 + + +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 , + Andy Reitz , + Fredrik Vraalsen , and + Keith Wessel + + 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//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 +#endif + +#include +#include +#include + +#include + +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 +#include +#include + +#include + +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 +#include +#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 +#include +#ifdef ORBIT_DEBUG +#include +#endif +#include +#include +#include +#include +#ifndef _XOPEN_SOURCE_EXTENDED +# define _XOPEN_SOURCE_EXTENDED 1 +#endif +#include +#include +#ifdef WE_DEFINED_XOPEN_SOURCE_EXTENDED +# undef _XOPEN_SOURCE_EXTENDED +#endif +#include +#include +#include +#include +#include +#include +#include + +/* +#ifdef O_NONBLOCK +#undef O_NONBLOCK +#endif +#define O_NONBLOCK 0 +*/ + +#if defined(HAVE_TCPD_H) && defined(HAVE_HOSTS_ACCESS) +#include +#endif + +#if 0 +#include + +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 +#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 +#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 +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_POLL +# include +#else +# include +# include +#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 + +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 + +#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 + +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 +#include +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 +#include + +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 +# endif + +# include + +# 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 + +#include + +/* This file should be a bunch of #ifdef's to #include the + os-.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_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 + +#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 + * + */ + +#include +#include + +#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 + * + */ + +#ifndef _ORBIT_TRACE_H_ +#define _ORBIT_TRACE_H_ + +#include +#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 + +#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 +#include +#include +#include + +#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 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 +#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 header file. */ +#define HAVE_ENDIAN_H 1 + +/* Define if you have the header file. */ +#define HAVE_FCNTL_H 1 + +/* Define if you have the header file. */ +#define HAVE_STDDEF_H 1 + +/* Define if you have the header file. */ +#define HAVE_SYS_POLL_H 1 + +/* Define if you have the header file. */ +#define HAVE_TCPD_H 1 + +/* Define if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* Define if you have the 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 +#include +#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 + +#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 +#include + +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 +#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 + +#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 +#include +#include + +#include + +#include + +#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 +#include + +#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 + +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 +#include +#include +#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 +#include +#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 + +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#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 +#include +#include +#include + +#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 +#include + +#include + +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#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 +#include +#include +#include + +/* 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 + +#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 +#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 +#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 +#include +#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 +#include +#include +#include +/* 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 +#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 +#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 +#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 + +/* include varargs functions for assertment macros + */ +#include + +#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 +/*#include */ +#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 +#endif + +#include +#include +#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 +#endif + +#include +#include +#include +#include +#include +#include /* For tolower() */ +#if !defined (HAVE_STRSIGNAL) || !defined(NO_SYS_SIGLIST_DECL) +#include +#endif +#include "glib.h" +/* do not include 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 +#include +#include +#include +#include +#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 +#endif +#include +#include +#include +#include +#include +#ifdef HAVE_PWD_H +#include +#endif +#include +#ifdef HAVE_SYS_PARAM_H +#include +#endif + +#ifdef NATIVE_WIN32 +# define STRICT /* Strict typing, please */ +# include +# include +# include +# include +# ifdef _MSC_VER +# include +# 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 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 +#include +#include +#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 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 +#include "orb/orbit.h" +#include "korbit.h" +#include + +#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 = ; +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 +#include +#include +#include +#include + +// #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 = ; +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 +#include +#include + +#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 +#include +#include +#include +#include + +#include +#include +#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 DirEntSeq; + typedef sequence 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#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 +#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 +#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 +#include +#include + +#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 +#define ORBIT_IDL_SERIAL 9 +#include + +#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 +#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 +#include +#include +#include +#include +#include + +#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 +#include +#include +#include +#include + +#ifdef __KERNEL__ +#include +#include +#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 +#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 +#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 +#define ORBIT_IDL_SERIAL 9 +#include + +#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 = ; +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 +#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 +#include +#include +#include +#include + +#include +#include +#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 +#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 +#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 +#define ORBIT_IDL_SERIAL 9 +#include + +#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 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 +#include +#include +#include +#include +#include +#include + +#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 +#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 +#include +#include +#include +#include +#include +#include + +#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 +#include +#include +#include +#include +#include +#include +#include + +#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 +#include +#include +#include +#include +#include +#include + +#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 +#include +#include + +// 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 +#include +#include +#include + +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 + +#include + +#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 + * + */ + +#include "config.h" +#include "../IIOP/iiop-endianP.h" +#include +#include +#include +#include + +#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 + * + */ + +#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 + * + */ + +#include +#include +#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 + * + */ + +#ifndef _ORBIT_CORBA_ANY_H_ +#define _ORBIT_CORBA_ANY_H_ + +#include "orbit_types.h" +#include "corba_typecode.h" + +#include + +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 + * + */ + +#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 + * + */ + +#ifndef _ORBIT_CORBA_BASIC_SEQUENCES_TYPE_H_ +#define _ORBIT_CORBA_BASIC_SEQUENCES_TYPE_H_ + +#include + +#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 +#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, <mp, 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 + * + */ + +#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 + * + */ + +#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 + * Elliot Lee + * + */ + +#include "config.h" +#include +#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 +#include +#include +#include + +#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;iprofile_list, i); + + for(j=0;jprofile_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 + * + */ + +#ifndef _ORBIT_CORBA_OBJECT_H_ +#define _ORBIT_CORBA_OBJECT_H_ + +#include + +#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 + * + */ + +#ifndef _ORBIT_CORBA_OBJECT_TYPE_H_ +#define _ORBIT_CORBA_OBJECT_TYPE_H_ + +#include /* for struct iovec */ + +#include /* 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 + * + */ + +#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 + * + */ + +#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 + * + */ + +#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 + * + */ + +#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 + * + */ + +#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 + * + */ + +#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 + * + */ + +#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 + * + */ + +#ifndef _ORBIT_CORBA_TYPECODE_TYPE_H_ +#define _ORBIT_CORBA_TYPECODE_TYPE_H_ + +#include +#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 + * Dick Porter + * + */ + +#include +#include +#include + +#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 + * + */ + +#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 + * + */ + +/* + * CORBA_Environment handling functions + */ + +#include +#include +#include +#include + +#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 + * + */ + +#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 +#include +#include +#include +#include +#include +#include +#include +#ifdef __KERNEL__ +#include +#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 + +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 + * + */ + +#ifndef _ORBIT_IOP_H_ +#define _ORBIT_IOP_H_ + +#include + +#include + +#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 + * + */ + +#include +#include + +#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 + * + */ + +#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 + * + */ + +/* + * Option parsing + * + * All ORB options are stripped from the application's argv, and argc is + * adjusted accordingly + */ + +#include +#include +#include +#include + +#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 + * + */ + +#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 + * Elliot Lee + * + */ + +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 +#include + +// 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;itype)!=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;ilabel)!=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;isubnames[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;itype != 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 + * + */ + +#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 + * + */ + +/* + * This file is a repository for random functions that don't fit anywhere + * else, and for ORBit-specific stuff. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#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 + * Elliot Lee + * + */ + +/* 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 + +#define BACKWARDS_COMPAT_0_4 +#undef NOT_BACKWARDS_COMPAT_0_4 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef __KORBIT__ +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 + * Elliot Lee + * + */ + +/* 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 + +#define BACKWARDS_COMPAT_0_4 +#undef NOT_BACKWARDS_COMPAT_0_4 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 + * Elliot Lee + * + */ + +/* + * ORBit specific CORBA_Object functions. + * + */ + +#include +#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 + +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 */ + 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 */ + 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 + * + */ + +/* + * ORBit specific CORBA_Object funcitons. + * + */ +#ifndef _ORBIT_ORBIT_OBJECT_H_ +#define _ORBIT_ORBIT_OBJECT_H_ + +#include +#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 + * Philip Dawes + * Elliot Lee + * + */ + +#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 + * Elliot Lee + * + */ + +/* + * ORBit specific POA funcitons. + * + */ + +#include +#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 + * + */ + +/* + * 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 + * + */ + +/* + * 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 +#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(kindindex=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;isub_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;isub_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;isub_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;isub_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;isub_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;isub_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;ilength;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;ilength;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 + * + */ + +#ifndef _ORBIT_TYPES_H_ +#define _ORBIT_TYPES_H_ + +#include /* for wchar_t */ +#include /* for sysdep types */ +#include /* for sockaddr_in */ +#include /* for struct iovec */ + +#include + +#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 + * Elliot Lee + * + */ + +#include +#include +#include + +#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 + * + */ + +#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 + * + */ + +#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 +#ifdef HAVE_SYS_POLL_H +#include +#endif +#include +#include + +/* 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 + * Elliot Lee + * + */ + +#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 + * + */ + +#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