/*dumb marshalling hack */
static void
matecomponent_activation_registration_iterate (const MateComponentActivationBaseService *base_service,
CORBA_Object obj, CORBA_Environment *ev,
gulong offset, int nargs)
{
GSList *link;
char *ior = NULL;
if (nargs == 4)
ior = CORBA_ORB_object_to_string (matecomponent_activation_orb_get (), obj, ev);
for (link = registries; link; link = link->next) {
RegistryInfo *ri;
void (*func_ptr) ();
ri = link->data;
func_ptr = *(gpointer *) ((guchar *) ri->registry + offset);
if (!func_ptr)
continue;
switch (nargs) {
case 4:
func_ptr (ri->registry, ior, base_service, ri->user_data);
break;
case 2:
func_ptr (ri->registry, ri->user_data);
break;
}
}
if (nargs == 4)
CORBA_free (ior);
}
static void
create_bag (void)
{
PropData *pd = g_new0 (PropData, 1);
BonoboArg *def;
char *dstr;
CORBA_char *ior;
FILE *iorfile;
pd->i = 987654321;
pd->l = 123456789;
pd->b = TRUE;
pd->f = 2.71828182845;
pd->d = 3.14159265358;
pd->s = "Hello world";
/* Create the property bag. */
pb = bonobo_property_bag_new (get_prop, set_prop, pd);
dstr = "Testing 1 2 3";
/* Add properties */
bonobo_property_bag_add (pb, "int-test", PROP_INTEGER_TEST,
BONOBO_ARG_INT, NULL, dstr, 0);
def = bonobo_arg_new (BONOBO_ARG_STRING);
BONOBO_ARG_SET_STRING (def, "a default string");
bonobo_property_bag_add (pb, "string-test", PROP_STRING_TEST,
BONOBO_ARG_STRING, def, dstr,
Bonobo_PROPERTY_READABLE |
Bonobo_PROPERTY_WRITEABLE);
bonobo_property_bag_add (pb, "long-test", PROP_LONG_TEST,
BONOBO_ARG_LONG, NULL, dstr, 0);
bonobo_property_bag_add (pb, "boolean-test", PROP_BOOLEAN_TEST,
BONOBO_ARG_BOOLEAN, NULL, dstr, 0);
def = bonobo_arg_new (BONOBO_ARG_FLOAT);
BONOBO_ARG_SET_FLOAT (def, 0.13579);
bonobo_property_bag_add (pb, "float-test", PROP_FLOAT_TEST,
BONOBO_ARG_FLOAT, def, dstr, 0);
bonobo_property_bag_add (pb, "double-test", PROP_DOUBLE_TEST,
BONOBO_ARG_DOUBLE, NULL, dstr, 0);
iorfile = fopen ("iorfile", "wb");
/* Print out the IOR for this object. */
ior = CORBA_ORB_object_to_string (orb, BONOBO_OBJREF (pb), &ev);
/* So we can tee the output to compare */
fwrite (ior, strlen (ior), 1, iorfile);
fclose (iorfile);
CORBA_free (ior);
}
void corba_init(void *p) {
PortableServer_ObjectId objid = {0, sizeof("Freeamp-ORBit"), "Freeamp-ORBit"};
PortableServer_POA poa;
CORBA_Environment ev;
char *retval;
CORBA_ORB orb;
FILE * ofp;
int argc=1;
char *argv;
char *homedir;
char iorfile[1024];
char tmpbuf[1] = {0};
tptr = p;
// :TODO: this should be fixed to pass on argv?
argv=&tmpbuf[0];
CORBA_exception_init(&ev);
orb = CORBA_ORB_init(&argc, &argv, "orbit-local-orb", &ev);
POA_Freeamp__init(&poa_freeamp_servant, &ev);
poa = (PortableServer_POA)CORBA_ORB_resolve_initial_references(orb, "RootPOA", &ev);
PortableServer_POAManager_activate(PortableServer_POA__get_the_POAManager(poa, &ev), &ev);
PortableServer_POA_activate_object_with_id(poa, &objid, &poa_freeamp_servant, &ev);
freeamp_client = PortableServer_POA_servant_to_reference(poa, &poa_freeamp_servant, &ev);
if (!freeamp_client) {
printf("Cannot get objref\n");
return;
}
homedir = getenv("HOME");
strncpy(iorfile, homedir, 1024); // :TODO: add error checking
strncat(iorfile, "/.freeamp.ior", 1024);
retval = CORBA_ORB_object_to_string(orb, freeamp_client, &ev);
ofp = fopen(iorfile,"w");
fprintf(ofp,"%s", retval);
fclose(ofp);
CORBA_free(retval);
fprintf(stdout,"FreeAMP-CORBA Ready. | Waiting for commands.\n");
fflush(stdout);
CORBA_ORB_run(orb, &ev);
}
void
etk_export_object_to_stream (CORBA_ORB orb,
CORBA_Object servant,
FILE *stream,
CORBA_Environment *ev)
{
CORBA_char *objref = NULL;
/* write objref to file */
objref = CORBA_ORB_object_to_string (orb, servant, ev);
if (etk_raised_exception(ev)) return;
/* print ior to terminal */
fprintf (stream, "%s\n", objref);
fflush (stream);
CORBA_free (objref);
}
static PyObject *
pycorba_orb_object_to_string(PyCORBA_ORB *self, PyObject *args)
{
CORBA_string ret;
CORBA_Environment ev;
PyCORBA_Object *obj;
PyObject *pyret;
if (!PyArg_ParseTuple(args, "O!:CORBA.ORB.object_to_string",
&PyCORBA_Object_Type, &obj))
return NULL;
CORBA_exception_init(&ev);
ret = CORBA_ORB_object_to_string(self->orb, obj->objref, &ev);
if (pymatecorba_check_ex(&ev))
return NULL;
pyret = PyString_FromString(ret);
CORBA_free(ret);
return pyret;
}
int main (int argc, char *argv[]) {
CORBA_ORB orb;
CORBA_Environment* ev;
PortableServer_ObjectId* oid;
passlong account;
PortableServer_POA root_poa;
PortableServer_POAManager pm;
CORBA_char* ior;
ev = g_new0(CORBA_Environment,1);
CORBA_exception_init(ev);
/* Initialize the orb. The initialization routine checks the command
* line parameters for directives that affect the orb */
orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", ev);
root_poa = (PortableServer_POA)
CORBA_ORB_resolve_initial_references(orb, "RootPOA", ev);
/* ask for instanciation of one object account */
account = impl_passlong__create(root_poa, ev);
/* Here we get the IOR for the acc object. Our "client" will use
* the IOR to find the server to connect to */
ior = CORBA_ORB_object_to_string(orb, account, ev);
/* print out the IOR, just so you can see what it looks like */
printf ("%s\n", ior);
fflush(stdout);
pm = PortableServer_POA__get_the_POAManager(root_poa, ev);
PortableServer_POAManager_activate(pm,ev);
CORBA_ORB_run(orb, ev);
return (0);
}
int main(int argc, char **argv)
{
#if 0
CORBA_Environment ev;
CORBA_ORB orb;
Map map_client = CORBA_OBJECT_NIL;
#endif
char *gps;
setenv("LC_NUMERIC","C",1);
setlocale(LC_ALL,"");
setlocale(LC_NUMERIC,"C");
gtk_set_locale();
setlocale(LC_NUMERIC,"C");
debug_init();
gtk_init(&argc, &argv);
gdk_rgb_init();
// i18n basic support
bindtextdomain( "navit", "./locale" );
textdomain( "navit" );
map_data_default=load_maps(NULL);
plugin_load();
co=gui_gtk_window(1300000,7000000,32);
co->route=route_new();
route_mapdata_set(co->route, co->map_data);
gps=getenv("GPSDATA");
if (gps) {
co->vehicle=vehicle_new(gps);
if (co->vehicle) {
co->cursor=cursor_new(co,co->vehicle);
sdl_gui_new(co->vehicle);
}
} else {
g_warning(gettext("Environment-Variable GPSDATA not set - No gps tracking. Set it to file:filename or gpsd://host[:port]"));
}
co->speech=speech_new();
if (! co->speech)
g_warning(gettext("Can't connect to speechd, no speech output available"));
speech_handle=co->speech;
if (co->vehicle)
co->compass=compass_new(co);
if (co->vehicle)
co->track=track_new(co->map_data);
#if 0
CORBA_exception_init(&ev);
orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);
g_assert(ev._major == CORBA_NO_EXCEPTION);
map_srv_start_poa(orb, &ev);
g_assert(ev._major == CORBA_NO_EXCEPTION);
map_client = map_srv_start_object(&ev, map);
retval = CORBA_ORB_object_to_string(orb, map_client, &ev);
g_assert(ev._major == CORBA_NO_EXCEPTION);
ior=fopen("map.ior","w");
if (ior) {
fprintf(ior, "%s\n", retval);
fclose(ior);
}
CORBA_free(retval);
#endif
initSDL();
gtk_main();
return 0;
}
/* Copied largely from goad.c, goad_server_activate_exe() */
static CORBA_Object
od_server_activate_exe (MateComponent_ServerInfo *si,
ODActivationInfo *actinfo,
CORBA_Object od_obj,
const MateComponent_ActivationEnvironment *environment,
CORBA_Environment *ev)
{
char **args;
char *extra_arg, *ctmp, *ctmp2;
int fd_arg;
int i;
char *iorstr, *iid;
CORBA_Object retval;
/* Munge the args */
args = g_alloca (36 * sizeof (char *));
#ifndef G_OS_WIN32
/* Split location_info into executable pathname and command-line
* arguments.
*/
for (i = 0, ctmp = ctmp2 = si->location_info; i < 32; i++) {
while (*ctmp2 && !g_ascii_isspace ((guchar) *ctmp2))
ctmp2++;
if (!*ctmp2)
break;
args[i] = g_alloca (ctmp2 - ctmp + 1);
strncpy (args[i], ctmp, ctmp2 - ctmp);
args[i][ctmp2 - ctmp] = '\0';
ctmp = ctmp2;
while (*ctmp2 && g_ascii_isspace ((guchar) *ctmp2))
ctmp2++;
if (!*ctmp2)
break;
ctmp = ctmp2;
}
if (!g_ascii_isspace ((guchar) *ctmp) && i < 32)
args[i++] = ctmp;
if (i > 1)
g_warning ("Passing command-line arguments in .server files is deprecated: \"%s\"", si->location_info);
#else
/* We don't support command-line arguments in the location on
* Win32, as the executable pathname might well contain spaces
* itself (C:\Program Files\Evolution 2.6.2\libexec\...).
* location_info is just the executable's pathname.
*/
args[0] = g_alloca (strlen (si->location_info) + 1);
strcpy (args[0], si->location_info);
i = 1;
#endif
extra_arg =
g_alloca (strlen (si->iid) +
sizeof ("--oaf-activate-iid="));
args[i++] = extra_arg;
sprintf (extra_arg, "--oaf-activate-iid=%s", si->iid);
fd_arg = i;
extra_arg = g_alloca (sizeof ("--oaf-ior-fd=") + 10);
args[i++] = "--oaf-ior-fd=%d";
iorstr = CORBA_ORB_object_to_string (
matecomponent_activation_orb_get (), od_obj, ev);
if (ev->_major != CORBA_NO_EXCEPTION)
iorstr = NULL;
if(actinfo->flags & MateComponent_ACTIVATION_FLAG_PRIVATE) {
extra_arg = g_alloca (sizeof ("--oaf-private"));
args[i++] = extra_arg;
g_snprintf (extra_arg, sizeof ("--oaf-private"),
"--oaf-private");
}
args[i] = NULL;
iid = g_strdup (si->iid);
/* Here comes the too clever by 1/2 bit:
* we drop the (recursive) 'server_lock' - so we
* can get other threads re-entering / doing activations
* here. cf. od_server_activate_factory
*/
{
ServerLockState state;
state = server_lock_drop ();
/*
* We set the process group of activated servers to our process group;
* this allows people to destroy all OAF servers along with oafd
* if necessary
*/
retval = matecomponent_activation_server_by_forking
( (const char **) args, TRUE, fd_arg, environment, iorstr,
iid, FALSE, matecomponent_object_directory_re_check_fn, actinfo, ev);
server_lock_resume (state);
}
g_free (iid);
CORBA_free (iorstr);
return retval;
}
int main(int argc, char **argv)
{
CORBA_ORB orb = 0;
CORBA_Object obj;
#define C_DECLV(type) CORBA_##type ret##type, in##type, out##type, inout##type
#define T_DECLV(type) test1_##type ret##type, in##type, out##type, inout##type
C_DECLV(short);
C_DECLV(long);
T_DECLV(ushort);
T_DECLV(ulong);
C_DECLV(float);
C_DECLV(double);
C_DECLV(char);
C_DECLV(boolean);
C_DECLV(octet);
C_DECLV(Object);
CORBA_char *instring, *outstring, *inoutstring, *retstring;
CORBA_long case_num;
CORBA_Environment ev;
orb = CORBA_ORB_init(&argc, argv, 0 /* use default ORBid */, &ev);
obj = CORBA_ORB_string_to_object(orb, argv[1], &ev);
if (ev._major != CORBA_NO_EXCEPTION) {
printf("Problem converting `%s' to an object.\n", argv[1]);
exit(1);
}
printf("Beginning communication...\n");
#define SHOWPARMS(prn, type) \
if (ev._major != CORBA_NO_EXCEPTION) \
printf("Exception: `%s' EXCEPTION RAISED FOR " #type "!\n", \
CORBA_exception_id(&ev)); \
else \
printf("Exception: no\n"); \
printf("In: " #prn"\n", in##type); \
printf("Inout: " #prn"\n", inout##type); \
printf("Out: " #prn"\n", out##type); \
printf("Result: " #prn"\n", ret##type);
#define RUNTEST(type, inval, inoutval, otherval, prn) \
in##type = inval; \
inout##type = inoutval; \
ret##type = out##type = otherval; \
ev._major = CORBA_NO_EXCEPTION; \
printf("Testing " #type" Before Call:\n"); \
SHOWPARMS(##prn, ##type); \
printf("Calling Server...\n"); \
ret##type = test1_test_##type(obj, in##type, &out##type, \
&inout##type, &ev); \
printf("After Call:\n"); \
SHOWPARMS(##prn, ##type);
RUNTEST(short, 1234, 4321, 7, %d);
RUNTEST(ushort, 65500, 33000, 6, %d);
RUNTEST(long, 12341234, 43214321, 2, %d);
RUNTEST(ulong, 3000000000U, 4000000000U, 5, %u);
RUNTEST(float, 1.234, 2.345, 3.1415, %f);
RUNTEST(double, 1.2345678901, 2.3456789012, 2.71828, %f);
RUNTEST(boolean, 0, 1, 2, %d);
RUNTEST(octet, 12, 23, 34, %d);
RUNTEST(char, 'a', 'b', 'c', %c);
/* Must allocate the `inout' string with the CORBA allocator. */
inoutstring = (char *) CORBA_alloc(sizeof("Howdy"));
(void)strcpy(inoutstring, "Howdy");
RUNTEST(string, "Hello", inoutstring, "Ugh", %s);
/* Now run the object passing test */
inObject = CORBA_Object_duplicate(obj, &ev);
inoutObject = CORBA_Object_duplicate(obj, &ev);
/* check for exception */
retObject = outObject = 0;
printf("Testing Object Before Call:\n");
if (ev._major != CORBA_NO_EXCEPTION)
printf("Exception: `%s' EXCEPTION RAISED FOR Object!\n",
CORBA_exception_id(&ev));
else
printf("Exception: no\n");
printf("In: %p\nURL:\t%s\nIOR:\t%s\n", inObject,
CORBA_ORB_object_to_readable_string(orb, inObject, &ev),
CORBA_ORB_object_to_string(orb, inObject, &ev));
printf("Inout: %p\nURL:\t%s\nIOR:\t%s\n", (void *)inoutObject,
CORBA_ORB_object_to_readable_string(orb, inoutObject, &ev),
CORBA_ORB_object_to_string(orb, inoutObject, &ev));
printf("Out: %p\nURL:\t%s\nIOR:\t%s\n", (void *)outObject,
CORBA_ORB_object_to_readable_string(orb, outObject, &ev),
CORBA_ORB_object_to_string(orb, outObject, &ev));
printf("Result: %p\nURL:\t%s\nIOR:\t%s\n", (void *)retObject,
CORBA_ORB_object_to_readable_string(orb, retObject, &ev),
CORBA_ORB_object_to_string(orb, retObject, &ev));
printf("Calling Server...\n");
retObject = test1_test_Object(obj, inObject, &outObject, &inoutObject,
&ev);
printf("After Call:\n");
if (ev._major != CORBA_NO_EXCEPTION)
printf("Exception: `%s' EXCEPTION RAISED FOR Object!\n",
CORBA_exception_id(&ev));
else
printf("Exception: no\n");
printf("In: %p\nURL:\t%s\nIOR:\t%s\n", inObject,
CORBA_ORB_object_to_readable_string(orb, inObject, &ev),
CORBA_ORB_object_to_string(orb, inObject, &ev));
printf("Inout: %p\nURL:\t%s\nIOR:\t%s\n", inoutObject,
CORBA_ORB_object_to_readable_string(orb, inoutObject, &ev),
CORBA_ORB_object_to_string(orb, inoutObject, &ev));
printf("Out: %p\nURL:\t%s\nIOR:\t%s\n", outObject,
CORBA_ORB_object_to_readable_string(orb, outObject, &ev),
CORBA_ORB_object_to_string(orb, outObject, &ev));
printf("Result: %p\nURL:\t%s\nIOR:\t%s\n", retObject,
CORBA_ORB_object_to_readable_string(orb, retObject, &ev),
CORBA_ORB_object_to_string(orb, retObject, &ev));
for (case_num = -1; case_num <= 5; case_num++) {
ev._major = CORBA_NO_EXCEPTION;
printf("Testing test_throw Before Call:\n");
if (ev._major != CORBA_NO_EXCEPTION)
printf("Exception: `%s' EXCEPTION RAISED FOR throw!\n",
CORBA_exception_id(&ev));
else
printf("Exception: no\n");
printf("In: %d\n", case_num);
printf("Calling Server...\n");
test1_test_throw(obj, case_num, &ev);
printf("After Call:\n");
switch (ev._major) {
case CORBA_USER_EXCEPTION:
if (!strcmp(CORBA_exception_id(&ev), ex_test1_x1))
printf("Caught exception test1_x1! "
"Case_Num: %d\n",
((test1_x1 *)
CORBA_exception_value(&ev))
->case_num);
else if (!strcmp(CORBA_exception_id(&ev),
ex_test1_x2))
printf("Caught exception test1_x2! "
"Obj URL: %s, value: %d\n",
CORBA_ORB_object_to_readable_string(
orb,
((test1_x2 *)
CORBA_exception_value(&ev))->
obj,
&ev),
((test1_x2 *)
CORBA_exception_value(&ev))->value);
else
printf("Unknown User Exception Raised: `%s' "
"for throw!\n",
CORBA_exception_id(&ev));
break;
case CORBA_SYSTEM_EXCEPTION:
printf("Exception: `%s' EXCEPTION RAISED FOR throw!\n",
CORBA_exception_id(&ev));
break;
default:
printf("Exception: no\n");
printf("In: %d\n", case_num);
}
}
printf("About to tell the server to exit...\n");
test1_please_exit(obj, &ev);
printf("Server should be exiting any moment...\n");
return 0;
}
JNIEXPORT void JNICALL Java_org_pgj_chanells_corba_CORBAChanellWorker_run
(JNIEnv * javaenv, jobject threadobj){
JNIEnv _javaenv = *javaenv;
global_javaenv = javaenv;
//---------------------------------------
// initialize class and method references
//---------------------------------------
//chanell worker class and method ID`s
chanell_worker_class = (*javaenv)->FindClass(javaenv,
"org/pgj/chanells/corba/CORBAChanellWorker");
chanell_create_result = (*javaenv)->GetStaticMethodID(javaenv, chanell_worker_class,
"createResultBean", "()Lorg/pgj/messages/Result;");
chanell_create_callreq = (*javaenv)->GetStaticMethodID(javaenv, chanell_worker_class,
"createCallRequestBean", "()Lorg/pgj/messages/CallRequest;");
chanell_create_exception = (*javaenv)->GetStaticMethodID(javaenv, chanell_worker_class,
"createExceptionBean", "()Lorg/pgj/messages/Exception;");
chanell_set_client = (*javaenv)->GetMethodID(javaenv, chanell_worker_class,
"setClient","(ILorg/pgj/messages/Message;)V");
chanell_msg_arrival = (*javaenv)->GetMethodID(javaenv, chanell_worker_class,
"msgArrival", "(Lorg/pgj/messages/Message;)V");
chanell_log = (*javaenv)->GetMethodID(javaenv,
chanell_worker_class,
"nativeLog", "(ILjava/lang/String;)V");
get_message = (*javaenv)->GetMethodID(javaenv,
chanell_worker_class,
"getMessage",
"(Lorg/pgj/chanells/corba/CORBAClient;)Lorg/pgj/messages/Message;");
get_client = (*javaenv)->GetMethodID(javaenv,
chanell_worker_class,
"getClient",
"(I)Lorg/pgj/chanells/corba/CORBAClient;");
//type mapper ID`s
typemapper_interface = (*javaenv)->FindClass(javaenv,
"org/pgj/typemapping/TypeMapper");
typemapper_map_method = (*javaenv)->GetMethodID(javaenv, typemapper_interface,
"map", "([BLjava/lang/String;)Lorg/pgj/typemapping/Field;");
//message class
message_class = (*javaenv)->FindClass(javaenv, STR_CLASS_MESSAGE);
message_set_sid = (*javaenv)->GetMethodID(javaenv, message_class,
"setSid", "(Ljava/lang/Object;)V");
message_get_sid = (*javaenv)->GetMethodID(javaenv, message_class,
"getSid", "()Ljava/lang/Object;");
//result bean ID`s
result_class = (*javaenv)->FindClass(javaenv, STR_CLASS_RESULT);
result_setsize = (*javaenv)->GetMethodID(javaenv, result_class, "setSize","(II)V");
result_set =(*javaenv)->GetMethodID(javaenv, result_class, "set","(IILorg/pgj/typemapping/Field;)V");
result_get = (*javaenv)->GetMethodID(javaenv, result_class, "get","(II)Lorg/pgj/typemapping/Field;");
result_getrows = (*javaenv)->GetMethodID(javaenv, result_class, "getRows","()I");
result_getcolumns = (*javaenv)->GetMethodID(javaenv, result_class, "getColumns","()I");
//call request bean ID`s
callreq_class = (*javaenv)->FindClass(javaenv, STR_CLASS_CALLREQ);
callreq_set_method_name = (*javaenv)->GetMethodID(javaenv, callreq_class,
"setMethodname", "(Ljava/lang/String;)V");
callreq_set_class_name = (*javaenv)->GetMethodID(javaenv, callreq_class,
"setClassname", "(Ljava/lang/String;)V");
callreq_add_param = (*javaenv)->GetMethodID(javaenv, callreq_class,
"addParam", "(Lorg/pgj/typemapping/Field;)V");
//exception bean ID`s
error_class = (*javaenv)->FindClass(javaenv, STR_CLASS_EXCEPTION);
error_get_message = (*javaenv)->GetMethodID(javaenv, error_class, "getMessage","()Ljava/lang/String;");
error_set_message = (*javaenv)->GetMethodID(javaenv, error_class, "getMessage","()Ljava/lang/String;");
error_get_stacktrace = (*javaenv)->GetMethodID(javaenv, error_class, "getStackTrace","()Ljava/lang/String;");
error_set_stacktrace = (*javaenv)->GetMethodID(javaenv, error_class, "setStackTrace","(Ljava/lang/String;)V");
error_get_classname = (*javaenv)->GetMethodID(javaenv, error_class, "getExceptionClassName","()Ljava/lang/String;");
error_set_classname = (*javaenv)->GetMethodID(javaenv, error_class, "setExceptionClassName","(Ljava/lang/String;)V");
message_sql = (*javaenv)->FindClass(javaenv, STR_CLASS_SQL);
message_sql_cursor = (*javaenv)->FindClass(javaenv, STR_CLASS_SQL_CURSOR);
sql_fetch_get_cursorname = (*javaenv)->GetMethodID(javaenv, message_sql_cursor, "getCursorName","()Ljava/lang/String;");
sql_fetch_set_cursorname = (*javaenv)->GetMethodID(javaenv, message_sql_cursor, "setCursorName","(Ljava/lang/String;)V");
message_sql_open_wia_sql = (*javaenv)->FindClass(javaenv, STR_CLASS_SQL_OPEN_SQL);
message_sql_close = (*javaenv)->FindClass(javaenv, STR_CLASS_SQL_CLOSE);
message_sql_fetch = (*javaenv)->FindClass(javaenv, STR_CLASS_SQL_FETCH);
field_class = (*javaenv)->FindClass(javaenv, STR_CLASS_FIELD);
field_get = (*javaenv)->GetMethodID(javaenv, field_class, "get","()[B");
field_rdbmstype = (*javaenv)->GetMethodID(javaenv, field_class, "rdbmsType","()Ljava/lang/String;");
if(_javaenv->ExceptionOccurred(javaenv)){
return;
}
worker_nlog(javaenv, threadobj, WNL_DEBUG,"-----corba-----\n");
//------------
// Start CORBA
//------------
CORBA_exception_init(&env);
orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &env);
poa = (PortableServer_POA) CORBA_ORB_resolve_initial_references(orb, "RootPOA", &env);
poa_manager = PortableServer_POA__get_the_POAManager(poa, &env);
PortableServer_POAManager_activate(poa_manager, &env);
server = impl_org_pgj_corba_CallServer__create(poa, &env, javaenv, threadobj);
worker_nlog(javaenv, threadobj, WNL_DEBUG,"starting orb\n");
//publish IOR
{
char* ior;
jmethodID putIor;
jclass workerclass;
jbyteArray bior;
gunichar ior_utf;
worker_nlog(javaenv, threadobj, WNL_DEBUG, "critical area\n");
ior = CORBA_ORB_object_to_string(orb, server, &env);
ior_utf = g_utf8_get_char(ior);
bior = _javaenv->NewByteArray(javaenv, strlen(ior));
if(_javaenv->ExceptionCheck(javaenv)){
worker_nlog(javaenv, threadobj, WNL_FATAL,
"problems");
return;
}
_javaenv->SetByteArrayRegion(javaenv, bior, 0, strlen(ior), ior);
if(_javaenv->ExceptionCheck(javaenv)){
worker_nlog(javaenv, threadobj, WNL_ERROR, "error occured");
return;
}
workerclass = _javaenv->GetObjectClass(javaenv, threadobj);
if(_javaenv->ExceptionCheck(javaenv)){
worker_nlog(javaenv, threadobj, WNL_ERROR, "problems");
return;
}
putIor = _javaenv->GetMethodID(javaenv, workerclass, "putIor", "([B)V");
if(_javaenv->ExceptionCheck(javaenv)){
worker_nlog(javaenv, threadobj, WNL_FATAL,
"problems");
return;
}
worker_nlog(javaenv, threadobj, WNL_DEBUG, "publishing IOR");
_javaenv->CallObjectMethod(javaenv, threadobj, putIor, bior);
if(_javaenv->ExceptionCheck(javaenv)){
worker_nlog(javaenv, threadobj, WNL_FATAL,
"Error publishing IOR! Stoping!");
return;
}
worker_nlog(javaenv, threadobj, WNL_INFO,
"IOR published successfuly");
}
//publish IOR
CORBA_ORB_run(orb, &env);
worker_nlog(javaenv, threadobj, WNL_FATAL,
"ORB run returned. There must be something problem here.");
}
/* used to be called CORBA_BOA_obj_is_ready, which was entirely wrong.
see Section 8.2 of the CORBA 2.0 Spec.
This function will create an object of the given type and implementation. */
FLICK_TARGET CORBA_BOA_create(CORBA_BOA ths, CORBA_ReferenceData *obj_key,
const char *type_id, FLICK_SERVER impl,
CORBA_Environment *ev)
{
FLICK_TARGET_STRUCT *new_refs;
FLICK_TARGET_STRUCT *obj_ref;
CORBA_octet *ref_key_buffer;
char *ref_type_id;
int type_id_len;
if (ths->max_name_len < obj_key->_length)
ths->max_name_len = obj_key->_length;
/* Allocate the memory we need for the new object reference. */
type_id_len = strlen(type_id);
ref_key_buffer = t_malloc(CORBA_octet, obj_key->_length);
ref_type_id = t_malloc(char, (type_id_len + 1));
if (!ref_key_buffer || !ref_type_id) {
if (ref_key_buffer) free(ref_key_buffer);
if (ref_type_id) free(ref_type_id);
flick_set_exception(ths, ev, ex_CORBA_NO_MEMORY,
0, CORBA_COMPLETED_NO);
fprintf(stderr,
"Error: can't malloc memory for new object.\n");
return 0;
}
/* Reallocate our BOA's vector of references. */
new_refs = t_realloc(ths->refs,
FLICK_TARGET_STRUCT,
(ths->count_servers + 1));
if (!new_refs) {
free(ref_key_buffer);
free(ref_type_id);
flick_set_exception(ths, ev, ex_CORBA_NO_MEMORY,
0, CORBA_COMPLETED_NO);
fprintf(stderr,
"Error: can't realloc memory for CORBA_BOA object "
"references.\n");
return 0;
}
ths->refs = new_refs;
ths->count_servers += 1;
obj_ref = &(ths->refs[ths->count_servers - 1]);
obj_ref->boa = ths;
obj_ref->server_func = impl;
memcpy(ref_key_buffer, obj_key->_buffer, obj_key->_length);
obj_ref->key._buffer = ref_key_buffer;
obj_ref->key._length = obj_key->_length;
obj_ref->key._maximum = obj_key->_maximum;
strncpy(ref_type_id, type_id, (type_id_len + 1));
obj_ref->type_id = ref_type_id;
obj_ref->type_id_len = type_id_len;
obj_ref->ior_len = 0;
obj_ref->ior = 0;
if (!flick_cdr_make_ior(obj_ref, &obj_ref->ior,
&obj_ref->ior_len, 0)) {
flick_set_exception(boa, ev, ex_CORBA_NO_MEMORY,
0, CORBA_COMPLETED_NO);
fprintf(stderr,
"Error: can't malloc memory for IOR.\n");
return 0;
}
/* Finally, print the URL- and IOR-style stringified object refs. */
{
char *url, *ior;
unsigned int i;
url = CORBA_ORB_object_to_readable_string(ths->orb, obj_ref,
ev);
if (ev->_major != CORBA_NO_EXCEPTION)
return 0;
ior = CORBA_ORB_object_to_string(ths->orb, obj_ref, ev);
if (ev->_major != CORBA_NO_EXCEPTION)
return 0;
printf("Object `");
for (i = 0; i < obj_key->_length; ++i) {
if (isprint(obj_key->_buffer[i]))
putchar(obj_key->_buffer[i]);
else
printf("\\%03o", obj_key->_buffer[i]);
}
printf("' is ready.\n");
printf(" URL:\t%s\n IOR:\t%s\n", url, ior);
free(url);
free(ior);
}
return CORBA_Object_duplicate(obj_ref, ev);
}
static int
do_activating(void)
{
Bonobo_ActivationEnvironment environment;
Bonobo_ActivationResult *a_res;
Bonobo_ActivationContext ac;
Bonobo_StringList reqs = { 0 };
char *resior;
int res = 1;
if (acior) {
ac = CORBA_ORB_string_to_object (orb, acior, &ev);
if (ev._major != CORBA_NO_EXCEPTION)
return 1;
} else
ac = bonobo_activation_activation_context_get ();
memset (&environment, 0, sizeof (Bonobo_ActivationEnvironment));
a_res = Bonobo_ActivationContext_activateMatchingFull (
ac, specs, &reqs, &environment, 0,
bonobo_activation_client_get (),
bonobo_activation_context_get (), &ev);
switch (ev._major) {
case CORBA_NO_EXCEPTION:
g_print ("Activation ID \"%s\" ", a_res->aid);
switch (a_res->res._d) {
case Bonobo_ACTIVATION_RESULT_OBJECT:
g_print ("RESULT_OBJECT\n");
resior = CORBA_ORB_object_to_string (orb,
a_res->
res._u.res_object,
&ev);
g_print ("%s\n", resior);
break;
case Bonobo_ACTIVATION_RESULT_SHLIB:
g_print ("RESULT_SHLIB\n");
break;
case Bonobo_ACTIVATION_RESULT_NONE:
g_print ("RESULT_NONE\n");
break;
}
res = 0;
break;
case CORBA_USER_EXCEPTION:
{
char *id;
id = CORBA_exception_id (&ev);
g_print ("User exception \"%s\" resulted from query\n",
id);
if (!strcmp (id,"IDL:Bonobo/ActivationContext/ParseFailed:1.0")) {
Bonobo_Activation_ParseFailed
* exdata = CORBA_exception_value (&ev);
if (exdata)
g_print ("Description: %s\n",
exdata->description);
} else if (!strcmp (id,"IDL:Bonobo/GeneralError:1.0")) {
Bonobo_GeneralError *exdata;
exdata = CORBA_exception_value (&ev);
if (exdata)
g_print ("Description: %s\n",
exdata->description);
}
res = 1;
}
break;
case CORBA_SYSTEM_EXCEPTION:
{
char *id;
id = CORBA_exception_id (&ev);
g_print ("System exception \"%s\" resulted from query\n",
id);
res = 1;
}
break;
}
return res;
}
int
main (int argc, char *argv[])
{
CORBA_ORB orb;
CORBA_Environment ev;
CosNaming_NamingContext context;
const char* progname = "matecorba-name-server";
#ifdef HAVE_SYSLOG
openlog(progname, LOG_NDELAY | LOG_PID, LOG_DAEMON);
syslog(LOG_INFO,"starting");
#endif
#ifdef HAVE_SIGACTION
{
sigset_t empty_mask;
struct sigaction act;
sigemptyset(&empty_mask);
act.sa_handler = signal_handler;
act.sa_mask = empty_mask;
act.sa_flags = 0;
sigaction(SIGINT, &act, NULL);
sigaction(SIGHUP, &act, NULL);
sigaction(SIGSEGV, &act, NULL);
sigaction(SIGABRT, &act, NULL);
act.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &act, NULL);
}
#else
signal(SIGINT, signal_handler);
#ifdef SIGHUP
signal(SIGHUP, signal_handler);
#endif
signal(SIGSEGV, signal_handler);
signal(SIGABRT, signal_handler);
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
#endif
CORBA_exception_init (&ev);
orb = CORBA_ORB_init (&argc, argv, "matecorba-local-orb", &ev);
{
GOptionContext *context;
GError *error = NULL;
gboolean result;
context = g_option_context_new("");
g_option_context_add_main_entries(context, goptions, GETTEXT_PACKAGE);
result = g_option_context_parse(context, &argc, &argv, &error);
g_option_context_free(context);
if (!result) {
g_warning("%s: bad arguments: %s\n",
progname, error->message);
g_error_free(error);
exit(1);
}
}
{
PortableServer_POA root_poa;
PortableServer_POAManager pm;
root_poa = (PortableServer_POA)
CORBA_ORB_resolve_initial_references (orb, "RootPOA", &ev);
context = MateCORBA_CosNaming_NamingContextExt_create (root_poa, &ev);
pm = PortableServer_POA__get_the_POAManager (root_poa, &ev);
PortableServer_POAManager_activate (pm, &ev);
CORBA_Object_release((CORBA_Object)pm, &ev);
CORBA_Object_release((CORBA_Object)root_poa, &ev);
}
{
CORBA_char *objstr;
objstr = CORBA_ORB_object_to_string (orb, context, &ev);
g_print ("%s\n", objstr);
fflush (stdout);
CORBA_free(objstr);
}
if ( opt_corbaloc_key ) {
CORBA_sequence_CORBA_octet okey;
okey._length = strlen(opt_corbaloc_key);
okey._buffer = opt_corbaloc_key;
MateCORBA_ORB_forw_bind(orb, &okey, context, &ev);
}
CORBA_ORB_run (orb, &ev);
/* Don't release until done (dont know why) */
CORBA_Object_release (context, &ev);
#ifdef HAVE_SYSLOG
syslog(LOG_INFO, "exiting");
#endif
return 0;
}
