/* Releases @servant object and finally destroys @orb. If error
* occures @ev points to exception object on return.
*/
static void
server_cleanup (CORBA_ORB orb,
PortableServer_POA poa,
CORBA_Object ref,
CORBA_Environment *ev)
{
PortableServer_ObjectId *objid = NULL;
objid = PortableServer_POA_reference_to_id (poa, ref, ev);
if (etk_raised_exception(ev)) return;
/* Servant: deactivatoin - will invoke __fini destructor */
PortableServer_POA_deactivate_object (poa, objid, ev);
if (etk_raised_exception(ev)) return;
PortableServer_POA_destroy (poa, TRUE, FALSE, ev);
if (etk_raised_exception(ev)) return;
CORBA_free (objid);
CORBA_Object_release ((CORBA_Object) poa, ev);
if (etk_raised_exception(ev)) return;
CORBA_Object_release (ref, ev);
if (etk_raised_exception(ev)) return;
/* ORB: tear down the ORB */
if (orb != CORBA_OBJECT_NIL)
{
/* going to destroy orb.. */
CORBA_ORB_destroy(orb, ev);
if (etk_raised_exception(ev)) return;
}
}
static void
server_cleanup (CORBA_ORB orb,
PortableServer_POA poa,
CORBA_Object ref,
CORBA_Environment *ev)
{
PortableServer_ObjectId *objid = NULL;
objid = PortableServer_POA_reference_to_id (poa, ref, ev);
if (etk_raised_exception(ev)) return;
PortableServer_POA_deactivate_object (poa, objid, ev);
if (etk_raised_exception(ev)) return;
PortableServer_POA_destroy (poa, TRUE, FALSE, ev);
if (etk_raised_exception(ev)) return;
CORBA_free (objid);
CORBA_Object_release ((CORBA_Object) poa, ev);
if (etk_raised_exception(ev)) return;
CORBA_Object_release (ref, ev);
if (etk_raised_exception(ev)) return;
if (orb != CORBA_OBJECT_NIL)
{
CORBA_ORB_destroy(orb, ev);
if (etk_raised_exception(ev)) return;
}
}
static void
DeadReferenceObj_test (PortableServer_Servant servant,
CORBA_Environment *ev)
{
PortableServer_Current poa_current;
PortableServer_POA poa;
CORBA_Object obj = CORBA_OBJECT_NIL;
poa_current = (PortableServer_Current)
CORBA_ORB_resolve_initial_references (global_orb,
"POACurrent",
ev);
g_assert (ev->_major == CORBA_NO_EXCEPTION);
poa = PortableServer_Current_get_POA (poa_current, ev);
g_assert (ev->_major == CORBA_NO_EXCEPTION);
obj = PortableServer_POA_servant_to_reference (poa, servant, ev);
g_assert (ev->_major == CORBA_NO_EXCEPTION);
g_assert (obj != CORBA_OBJECT_NIL);
CORBA_Object_release ((CORBA_Object) obj, ev);
CORBA_Object_release ((CORBA_Object) poa, ev);
CORBA_Object_release ((CORBA_Object) poa_current, ev);
}
*/static
void
server_init (int *argc_ptr,
char *argv[],
CORBA_ORB *orb,
PortableServer_POA *poa,
CORBA_Environment *ev)
{
PortableServer_POA rootpoa = CORBA_OBJECT_NIL;
PortableServer_POAManager rootpoa_mgr = CORBA_OBJECT_NIL;
CORBA_Environment local_ev[1];
CORBA_exception_init(local_ev);
/* init signal handling */
signal(SIGTERM, server_shutdown);
/* create Object Request Broker (ORB) */
(*orb) = CORBA_ORB_init(argc_ptr, argv, "orbit-local-mt-orb", ev);
if (etk_raised_exception(ev))
goto failed_orb;
rootpoa = (PortableServer_POA)
CORBA_ORB_resolve_initial_references(*orb, "RootPOA", ev);
if (etk_raised_exception(ev))
goto failed_poa;
rootpoa_mgr = PortableServer_POA__get_the_POAManager(rootpoa, ev);
if (etk_raised_exception(ev))
goto failed_poamanager;
/* create default POA with specific policies */
(*poa) = server_create_multi_threaded_poa (*orb,
rootpoa,
rootpoa_mgr,
ev);
if (etk_raised_exception(ev))
goto failed_child_poa;
PortableServer_POAManager_activate(rootpoa_mgr, ev);
if (etk_raised_exception(ev))
goto failed_activation;
CORBA_Object_release ((CORBA_Object) rootpoa_mgr, ev);
return;
failed_activation:
failed_child_poa:
failed_poamanager:
CORBA_Object_release ((CORBA_Object) rootpoa_mgr, local_ev);
failed_poa:
CORBA_ORB_destroy(*orb, local_ev);
failed_orb:
return;
}
static
void
main_func(int argc, char *argv[]) {
PortableServer_POA poa = CORBA_OBJECT_NIL;
PortableServer_POAManager poa_manager = CORBA_OBJECT_NIL;
CORBA_Environment ev[1];
CORBA_exception_init(ev);
/* init signal handling */
signal(SIGINT, server_shutdown);
signal(SIGTERM, server_shutdown);
/* create Object Request Broker (ORB) */
global_orb = CORBA_ORB_init(&argc,
argv,
"orbit-local-treaded-orb",
ev);
g_assert (!ORBIT_EX (ev));
/* get Portable Object Adaptor (POA) */
poa = (PortableServer_POA)
CORBA_ORB_resolve_initial_references(global_orb,
"RootPOA",
ev);
g_assert (!ORBIT_EX (ev));
/* activate POA Manager */
poa_manager = PortableServer_POA__get_the_POAManager(poa, ev);
g_assert (!ORBIT_EX (ev));
PortableServer_POAManager_activate(poa_manager, ev);
g_assert (!ORBIT_EX (ev));
LEAK_DETECT_WITH_TOLERANCE (1000, test_ORBit_alloc (), 50);
LEAK_DETECT_WITH_TOLERANCE (1000, test_ORBit_sequence (), 50);
LEAK_DETECT_WITH_TOLERANCE (1000, test_activate_deactivate (poa, ev), 50);
/* tear down the ORB */
CORBA_Object_release ((CORBA_Object) poa_manager, ev);
g_assert (!ORBIT_EX (ev));
CORBA_Object_release ((CORBA_Object) poa, ev);
g_assert (!ORBIT_EX (ev));
if (global_orb != CORBA_OBJECT_NIL) {
/* going to destroy orb.. */
CORBA_ORB_destroy(global_orb, ev);
g_assert (!ORBIT_EX (ev));
}
}
static void
impl_setLineStatus(PortableServer_Servant servant, GNOME_Evolution_ShellState shell_state, GNOME_Evolution_Listener listener, CORBA_Environment *ev)
{
struct _setline_data *sd;
int status = status_check(shell_state);
/* This will dis/enable further auto-mail-check action. */
/* FIXME: If send/receive active, wait for it to finish? */
if (status)
camel_session_set_online(session, status);
sd = g_malloc0(sizeof(*sd));
sd->status = status;
sd->listener = CORBA_Object_duplicate(listener, ev);
if (ev->_major == CORBA_NO_EXCEPTION)
mail_component_stores_foreach(mail_component_peek(), setline_check, sd);
else
CORBA_exception_free(ev);
if (sd->pending == 0) {
if (sd->listener) {
CORBA_Object_release(sd->listener, ev);
CORBA_exception_free(ev);
}
g_free(sd);
if (!status)
camel_session_set_online(session, status);
GNOME_Evolution_Listener_complete(listener, ev);
}
}
/**
* matecomponent_zoomable_frame_bind_to_zoomable:
* @zoomable_frame: A MateComponentZoomableFrame object.
* @zoomable: The CORBA object for the MateComponentZoomable embedded
* in this MateComponentZoomableFrame.
*
* Associates @zoomable with this @zoomable_frame.
*/
void
matecomponent_zoomable_frame_bind_to_zoomable (MateComponentZoomableFrame *zoomable_frame,
MateComponent_Zoomable zoomable,
CORBA_Environment *opt_ev)
{
CORBA_Environment *ev, temp_ev;
g_return_if_fail (zoomable != CORBA_OBJECT_NIL);
g_return_if_fail (MATECOMPONENT_IS_ZOOMABLE_FRAME (zoomable_frame));
if (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL)
CORBA_Object_release (zoomable_frame->priv->zoomable, NULL);
zoomable_frame->priv->zoomable = CORBA_Object_duplicate (zoomable, NULL);
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
MateComponent_Zoomable_setFrame (zoomable, MATECOMPONENT_OBJREF (zoomable_frame), ev);
if (MATECOMPONENT_EX (ev))
matecomponent_object_check_env (MATECOMPONENT_OBJECT (zoomable_frame), zoomable, ev);
if (!opt_ev)
CORBA_exception_free (&temp_ev);
}
/**
* bonobo_zoomable_frame_bind_to_zoomable:
* @zoomable_frame: A BonoboZoomableFrame object.
* @zoomable: The CORBA object for the BonoboZoomable embedded
* in this BonoboZoomableFrame.
*
* Associates @zoomable with this @zoomable_frame.
*/
void
bonobo_zoomable_frame_bind_to_zoomable (BonoboZoomableFrame *zoomable_frame,
Bonobo_Zoomable zoomable,
CORBA_Environment *opt_ev)
{
CORBA_Environment *ev, temp_ev;
g_return_if_fail (zoomable != CORBA_OBJECT_NIL);
g_return_if_fail (BONOBO_IS_ZOOMABLE_FRAME (zoomable_frame));
if (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL)
CORBA_Object_release (zoomable_frame->priv->zoomable, NULL);
zoomable_frame->priv->zoomable = CORBA_Object_duplicate (zoomable, NULL);
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
Bonobo_Zoomable_setFrame (zoomable, BONOBO_OBJREF (zoomable_frame), ev);
if (BONOBO_EX (ev))
bonobo_object_check_env (BONOBO_OBJECT (zoomable_frame), zoomable, ev);
if (!opt_ev)
CORBA_exception_free (&temp_ev);
}
static void
set_data (BonoboWidget *control, const char *string)
{
Bonobo_PersistStream persist;
BonoboObject *bstream;
CORBA_Environment ev;
persist = (Bonobo_PersistStream) Bonobo_Unknown_queryInterface (
bonobo_widget_get_objref (control),
"IDL:Bonobo/PersistStream:1.0", &ev);
if (persist == CORBA_OBJECT_NIL) {
g_object_ref_sink (G_OBJECT (control));
return ;
}
bstream = bonobo_stream_mem_create (string, strlen (string), TRUE, FALSE);
CORBA_exception_init (&ev);
Bonobo_PersistStream_load (persist, BONOBO_OBJREF (bstream),
"text/calendar", &ev);
bonobo_object_unref (BONOBO_OBJECT (bstream));
Bonobo_Unknown_unref (persist, &ev);
CORBA_Object_release (persist, &ev);
}
static gboolean
test_matecomponent_activation_server (CORBA_Environment *ev, const char *type)
{
CORBA_Object ns;
ns = matecomponent_activation_name_service_get (ev);
if (ev->_major != CORBA_NO_EXCEPTION) {
g_warning ("Exception '%s' (%s) finding matecomponent_activation_server %s",
matecomponent_activation_exception_id (ev), ev->_id, type);
return FALSE;
}
if (name_service != CORBA_OBJECT_NIL &&
name_service != ns) {
g_warning ("matecomponent_activation_server crashed %s", type);
return FALSE;
}
if (name_service == CORBA_OBJECT_NIL)
name_service = ns;
else
CORBA_Object_release (ns, ev);
return TRUE;
}
static int
pycorba_any_init(PyCORBA_Any *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "typecode", "value", NULL };
PyCORBA_TypeCode *pytc;
PyObject *value;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O:CORBA.any.__init__",
kwlist, &PyCORBA_TypeCode_Type, &pytc,
&value))
return -1;
self->any._type = (CORBA_TypeCode)CORBA_Object_duplicate(
(CORBA_Object)pytc->tc, NULL);
self->any._value = MateCORBA_small_alloc(self->any._type);
if (!pymatecorba_marshal_any(&self->any, value)) {
CORBA_Object_release((CORBA_Object)self->any._type, NULL);
self->any._type = NULL;
CORBA_free(self->any._value);
self->any._value = NULL;
PyErr_SetString(PyExc_TypeError, "could not marshal value");
return -1;
}
return 0;
}
static void FreeDataSourceObjectData(DataSourceObjectData* p_object_data) {
ilu_Error an_error;
CORBA_Environment ilu_env;
if (p_object_data->m_state_change_condition)
ilu_DestroyCondition(p_object_data->m_state_change_condition);
if (p_object_data->m_access_mutex) {
ilu_DestroyMutex(p_object_data->m_access_mutex, &an_error);
if (ILU_ERRNOK(an_error)) {
ILU_HANDLED(an_error);
ILU_CLER(an_error);
}
}
if (p_object_data->m_renderSink) {
CORBA_Object_release(p_object_data->m_renderSink, &ilu_env);
log_and_clear_if_exception(&ilu_env, "CORBA_Object_release problem");
}
if (p_object_data->m_pipeline) {
ILU_C_ReleasePipeline(p_object_data->m_pipeline, &ilu_env);
log_and_clear_if_exception(&ilu_env, "Calling ILU_C_ReleasePipeline");
ILU_C_SetPipelineContext(NULL);
}
CLOSE_FUNCTION(p_object_data->m_h_native_content_file);
ilu_free(p_object_data->m_pc_object_id);
ilu_free(p_object_data);
}
static void
matecomponent_control_unset_control_frame (MateComponentControl *control,
CORBA_Environment *opt_ev)
{
CORBA_Environment *ev, tmp_ev;
if (!opt_ev) {
CORBA_exception_init (&tmp_ev);
ev = &tmp_ev;
} else
ev = opt_ev;
if (control->priv->no_frame_timeout_id != 0) {
g_source_remove (control->priv->no_frame_timeout_id);
control->priv->no_frame_timeout_id = 0;
}
if (control->priv->frame != CORBA_OBJECT_NIL) {
MateComponent_ControlFrame frame = control->priv->frame;
control->priv->frame = CORBA_OBJECT_NIL;
MateCORBA_small_unlisten_for_broken (
frame, G_CALLBACK (control_frame_connection_died_cb));
if (control->priv->active)
MateComponent_ControlFrame_notifyActivated (
frame, FALSE, ev);
CORBA_Object_release (frame, ev);
}
if (!opt_ev)
CORBA_exception_free (&tmp_ev);
}
*/static
void
server_init (int *argc_ptr,
char *argv[],
CORBA_ORB *orb,
PortableServer_POA *poa,
CORBA_Environment *ev)
{
PortableServer_POAManager poa_manager = CORBA_OBJECT_NIL;
CORBA_Environment local_ev[1];
CORBA_exception_init(local_ev);
/* init signal handling */
signal(SIGINT, server_shutdown);
signal(SIGTERM, server_shutdown);
/* create Object Request Broker (ORB) */
(*orb) = CORBA_ORB_init(argc_ptr, argv, "orbit-local-mt-orb", ev);
if (etk_raised_exception(ev))
goto failed_orb;
(*poa) = (PortableServer_POA)
CORBA_ORB_resolve_initial_references(*orb, "RootPOA", ev);
if (etk_raised_exception(ev))
goto failed_poa;
poa_manager = PortableServer_POA__get_the_POAManager(*poa, ev);
if (etk_raised_exception(ev))
goto failed_poamanager;
PortableServer_POAManager_activate(poa_manager, ev);
if (etk_raised_exception(ev))
goto failed_activation;
CORBA_Object_release ((CORBA_Object) poa_manager, ev);
return;
failed_activation:
failed_poamanager:
CORBA_Object_release ((CORBA_Object) poa_manager, local_ev);
failed_poa:
CORBA_ORB_destroy(*orb, local_ev);
failed_orb:
return;
}
static void
pycorba_any_dealloc(PyCORBA_Any *self)
{
if (self->any._type)
CORBA_Object_release((CORBA_Object)self->any._type, NULL);
CORBA_free(self->any._value);
PyObject_DEL(self);
}
/**
* matecomponent_activation_orb_init:
* @argc: pointer to program's argument count
* @argv: argument array
*
* Initialize MateComponent Activation's ORB - do this once centrally
* so it can be easily shared.
*
* Return value: the ORB.
**/
CORBA_ORB
matecomponent_activation_orb_init (int *argc, char **argv)
{
CORBA_Context def_ctx;
CORBA_Environment ev;
const char *hostname;
gchar *orb_id;
CORBA_exception_init (&ev);
#ifdef HAVE_GTHREADS
orb_id = "matecorba-local-mt-orb";
#else
orb_id = "matecorba-local-non-threaded-orb";
#endif
matecomponent_activation_orb = CORBA_ORB_init (argc, argv, orb_id, &ev);
g_assert (ev._major == CORBA_NO_EXCEPTION);
matecomponent_activation_init_activation_env ();
/* Set values in default context */
CORBA_ORB_get_default_context (matecomponent_activation_orb, &def_ctx, &ev);
CORBA_Context_create_child (def_ctx, "activation", &matecomponent_activation_context, &ev);
g_assert (ev._major == CORBA_NO_EXCEPTION);
CORBA_Object_release ((CORBA_Object) def_ctx, &ev);
g_assert (ev._major == CORBA_NO_EXCEPTION);
hostname = matecomponent_activation_hostname_get ();
CORBA_Context_set_one_value (matecomponent_activation_context, "hostname",
(char *) hostname, &ev);
CORBA_Context_set_one_value (matecomponent_activation_context, "username",
(char *) g_get_user_name (), &ev);
CORBA_exception_free (&ev);
#ifdef MATECOMPONENT_ACTIVATION_DEBUG
if (getenv ("MATECOMPONENT_ACTIVATION_TRAP_SEGV")) {
#ifdef HAVE_SIGACTION
struct sigaction sa;
sa.sa_handler = do_barrier;
sigaction (SIGSEGV, &sa, NULL);
sigaction (SIGPIPE, &sa, NULL);
#else
signal (SIGSEGV, do_barrier);
#ifdef SIGPIPE
signal (SIGPIPE, do_barrier);
#endif
#endif
}
if (getenv ("MATECOMPONENT_ACTIVATION_BARRIER_INIT")) {
volatile int barrier = 1;
while (barrier);
}
#endif
return matecomponent_activation_orb;
}
static void
matecomponent_zoomable_frame_dispose (GObject *object)
{
MateComponentZoomableFrame *frame = (MateComponentZoomableFrame *) object;
CORBA_Object_release (frame->priv->zoomable, NULL);
parent_class->dispose (object);
}
static void
bonobo_zoomable_frame_dispose (GObject *object)
{
BonoboZoomableFrame *frame = (BonoboZoomableFrame *) object;
CORBA_Object_release (frame->priv->zoomable, NULL);
parent_class->dispose (object);
}
static void
test_activation (void)
{
CORBA_Environment env;
PortableServer_POA poa;
GSList *objids = NULL, *l;
int i;
fprintf (stderr, "Testing object activation...\n");
CORBA_exception_init (&env);
POA_Test__init (&test_servant, &env);
poa = create_mult_id_poa (&env);
g_assert (env._major == CORBA_NO_EXCEPTION);
g_timer_reset (timer);
for (i = 0; i < 1000; i++) {
PortableServer_ObjectId *objid;
objid = PortableServer_POA_activate_object (poa, &test_servant, &env);
g_assert (env._major == CORBA_NO_EXCEPTION);
objids = g_slist_append (objids, objid);
}
elapsed_time = g_timer_elapsed (timer, NULL);
bogomark += elapsed_time;
fprintf (stderr, " activation : %g(ms)\n", elapsed_time);
g_timer_reset (timer);
for (l = objids; l; l = l->next) {
PortableServer_POA_deactivate_object (poa, l->data, &env);
g_assert (env._major == CORBA_NO_EXCEPTION);
}
elapsed_time = g_timer_elapsed (timer, NULL);
bogomark += elapsed_time;
fprintf (stderr, " de-activation : %g(ms)\n", elapsed_time);
for (l = objids; l; l = l->next)
CORBA_free (l->data);
g_slist_free (objids);
POA_Test__fini (&test_servant, &env);
PortableServer_POA_destroy (poa, CORBA_FALSE, CORBA_FALSE, &env);
g_assert (env._major == CORBA_NO_EXCEPTION);
CORBA_Object_release ((CORBA_Object) poa, &env);
g_assert (env._major == CORBA_NO_EXCEPTION);
CORBA_exception_free (&env);
}
/**
* matecomponent_activation_debug_shutdown:
*
* A debugging function to shutdown the ORB and process
* any reference count leaks that may have occurred.
*
* Return value: FALSE if there were leaks detected, else TRUE
**/
gboolean
matecomponent_activation_debug_shutdown (void)
{
int retval = TRUE;
CORBA_Environment ev;
if (is_initialized) {
CORBA_exception_init (&ev);
matecomponent_activation_base_service_debug_shutdown (&ev);
if (ev._major != CORBA_NO_EXCEPTION) {
retval = FALSE;
}
if (matecomponent_activation_context != CORBA_OBJECT_NIL) {
CORBA_Object_release (
(CORBA_Object) matecomponent_activation_context, &ev);
matecomponent_activation_context = CORBA_OBJECT_NIL;
}
matecomponent_activation_release_corba_client ();
if (object_directory != CORBA_OBJECT_NIL) {
CORBA_Object_release (object_directory, &ev);
object_directory = CORBA_OBJECT_NIL;
}
if (matecomponent_activation_orb != CORBA_OBJECT_NIL) {
CORBA_ORB_destroy (matecomponent_activation_orb, &ev);
if (ev._major != CORBA_NO_EXCEPTION) {
retval = FALSE;
}
CORBA_Object_release (
(CORBA_Object) matecomponent_activation_orb, &ev);
is_initialized = FALSE;
}
CORBA_exception_free (&ev);
}
return retval;
}
static CORBA_UnionMemberSeq *
MateCORBA_imodule_get_union_members (GHashTable *typecodes,
IDL_tree tree,
CORBA_TypeCode switchtc,
CORBA_Environment *ev)
{
CORBA_UnionMemberSeq *members;
IDL_tree l;
int num_members = 0;
int i;
g_return_val_if_fail (IDL_NODE_TYPE (tree) == IDLN_TYPE_UNION, NULL);
for (l = IDL_TYPE_UNION (tree).switch_body; l; l = IDL_LIST (l).next)
num_members += IDL_list_length (IDL_CASE_STMT (IDL_LIST (l).data).labels);
members = CORBA_UnionMemberSeq__alloc ();
members->_length = members->_maximum = num_members;
members->_buffer = CORBA_UnionMemberSeq_allocbuf (members->_length);
members->_release = CORBA_TRUE;
for (i = 0, l = IDL_TYPE_UNION (tree).switch_body; l; l = IDL_LIST (l).next) {
CORBA_TypeCode subtc;
IDL_tree member, label, dcl;
member = IDL_CASE_STMT (IDL_LIST (l).data).element_spec;
g_assert (IDL_NODE_TYPE (member) == IDLN_MEMBER);
subtc = MateCORBA_imodule_get_typecode (
typecodes, IDL_MEMBER (member).type_spec);
dcl = IDL_LIST (IDL_MEMBER (member).dcls).data;
for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label;
label = IDL_LIST (label).next, i++) {
CORBA_UnionMember *umember = &members->_buffer [i];
MateCORBA_imodule_setup_label_any (
switchtc, IDL_LIST (label).data, &umember->label);
umember->label._release = CORBA_TRUE;
umember->name = CORBA_string_dup (IDL_IDENT (dcl).str);
umember->type = (CORBA_TypeCode)
CORBA_Object_duplicate ((CORBA_Object) subtc, ev);
umember->type_def = CORBA_OBJECT_NIL; /* Not used? */
}
CORBA_Object_release ((CORBA_Object) subtc, ev);
}
g_assert (i == num_members);
return members;
}
static void
pyorbit_poa_dealloc(PyCORBA_Object *self)
{
if (self->objref)
CORBA_Object_release(self->objref, NULL);
self->objref = NULL;
if (self->ob_type->tp_free)
self->ob_type->tp_free((PyObject *)self);
else
PyObject_DEL(self);
}
/**
* matecomponent_event_source_notify_listeners:
* @event_source: the Event Source that will emit the event.
* @event_name: Name of the event being emitted
* @opt_value: A CORBA_any value that contains the data that is passed
* to interested clients, or NULL for an empty value
* @opt_ev: A CORBA_Environment where a failure code can be returned, can be NULL.
*
* This will notify all clients that have registered with this EventSource
* (through the addListener or addListenerWithMask methods) of the availability
* of the event named @event_name. The @value CORBA::any value is passed to
* all listeners.
*
* @event_name can not contain comma separators, as commas are used to
* separate the various event names.
*/
void
matecomponent_event_source_notify_listeners (MateComponentEventSource *event_source,
const char *event_name,
const CORBA_any *opt_value,
CORBA_Environment *opt_ev)
{
GSList *l, *notify;
CORBA_Environment *ev, temp_ev;
const MateComponentArg *my_value;
g_return_if_fail (MATECOMPONENT_IS_EVENT_SOURCE (event_source));
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
if (!opt_value)
my_value = matecomponent_arg_new (MATECOMPONENT_ARG_NULL);
else
my_value = opt_value;
notify = NULL;
for (l = event_source->priv->listeners; l; l = l->next) {
ListenerDesc *desc = (ListenerDesc *) l->data;
if (desc->event_masks == NULL ||
event_match (event_name, desc->event_masks)) {
notify = g_slist_prepend (
notify,
CORBA_Object_duplicate (desc->listener, ev));
}
}
matecomponent_object_ref (MATECOMPONENT_OBJECT (event_source));
for (l = notify; l; l = l->next) {
MateComponent_Listener_event (l->data, event_name, my_value, ev);
CORBA_Object_release (l->data, ev);
}
matecomponent_object_unref (MATECOMPONENT_OBJECT (event_source));
g_slist_free (notify);
if (!opt_ev)
CORBA_exception_free (ev);
if (!opt_value)
matecomponent_arg_release ((MateComponentArg *) my_value);
}
void CORBA_BOA_impl_is_ready(CORBA_BOA ths, CORBA_Environment *ev)
{
trapeze_mcp_init(1 /* yes, I'm the server */);
/* Accept new clients, read client requests & send replies forever. */
while (1) {
FLICK_TARGET obj;
FLICK_BUFFER msg;
void *buffer;
flick_trapeze_server_get_request(&msg);
buffer = tpz_mtod(msg);
obj = find_implementation(
ths, buffer, ev);
if (ev->_major != CORBA_NO_EXCEPTION) {
/* Error finding object. */
flick_trapeze_server_send_corba_exception(
msg,
CORBA_exception_id(ev));
ev->_major = CORBA_NO_EXCEPTION;
} else {
switch ((*obj->server_func)(msg, buffer, obj)) {
case FLICK_OPERATION_SUCCESS:
/* end_encode already sent reply */
break;
case FLICK_OPERATION_SUCCESS_NOREPLY:
break;
default:
/* FLICK_OPERATION_FAILURE */
/*
* XXX --- The server dispatch function may
* have already encoded an exception
* `..._decode_error'. We should send it, or
* the dispatch func should return FLICK_
* OPERATION_SUCCESS in that case.
*/
flick_trapeze_server_send_corba_exception(
msg,
ex_CORBA_NO_IMPLEMENT);
break;
}
}
if (!CORBA_Object_is_nil(obj, ev))
CORBA_Object_release(obj, ev);
}
/* Should never be reached. */
flick_set_exception(ths, ev, ex_CORBA_INTERNAL,
0, CORBA_COMPLETED_YES);
}
static CORBA_StructMemberSeq *
MateCORBA_imodule_get_struct_members (GHashTable *typecodes,
IDL_tree tree,
CORBA_Environment *ev)
{
CORBA_StructMemberSeq *members;
IDL_tree l;
int num_members = 0;
int i;
g_return_val_if_fail (IDL_NODE_TYPE (tree) == IDLN_TYPE_STRUCT ||
IDL_NODE_TYPE (tree) == IDLN_EXCEPT_DCL, NULL);
for (l = IDL_TYPE_STRUCT (tree).member_list; l; l = IDL_LIST (l).next)
num_members += IDL_list_length (IDL_MEMBER (IDL_LIST (l).data).dcls);
members = CORBA_StructMemberSeq__alloc ();
members->_length = members->_maximum = num_members;
members->_buffer = CORBA_StructMemberSeq_allocbuf (members->_length);
members->_release = CORBA_TRUE;
for (i = 0, l = IDL_TYPE_STRUCT (tree).member_list; l; l = IDL_LIST (l).next) {
CORBA_TypeCode subtc;
IDL_tree dcl;
subtc = MateCORBA_imodule_get_typecode (
typecodes, IDL_MEMBER (IDL_LIST (l).data).type_spec);
for (dcl = IDL_MEMBER (IDL_LIST (l).data).dcls; dcl;
dcl = IDL_LIST (dcl).next, i++) {
CORBA_StructMember *member = &members->_buffer [i];
CORBA_string name;
if (IDL_NODE_TYPE (dcl) == IDLN_IDENT)
name = IDL_IDENT (dcl).str;
else /* IDLN_TYPE_ARRAY */
name = IDL_IDENT (IDL_TYPE_ARRAY (dcl).ident).str;
member->name = CORBA_string_dup (name);
member->type = (CORBA_TypeCode)
CORBA_Object_duplicate ((CORBA_Object) subtc, ev);
member->type_def = CORBA_OBJECT_NIL; /* Not used? */
}
CORBA_Object_release ((CORBA_Object) subtc, ev);
}
g_assert (i == num_members);
return members;
}
void
matecomponent_event_source_client_add_listener_closure (MateComponent_Unknown object,
GClosure *event_callback,
const char *opt_mask,
CORBA_Environment *opt_ev)
{
MateComponent_Listener l;
l = matecomponent_event_source_client_add_listener_full (
object, event_callback, opt_mask, opt_ev);
if (l != CORBA_OBJECT_NIL)
CORBA_Object_release (l, NULL);
}
static void
impl_Test_LargeSeq__destroy(impl_POA_Test_LargeSeq *servant, CORBA_Environment *ev)
{
CORBA_Object_release ((CORBA_Object) servant->poa, ev);
/* No further remote method calls are delegated to
* servant and you may free your private attributes. */
/* ------ free private attributes here ------ */
/* ------ ---------- end ------------- ------ */
POA_Test_LargeSeq__fini((PortableServer_Servant)servant, ev);
g_free (servant);
}
static void
kill_old_dataserver (void)
{
GNOME_Evolution_DataServer_InterfaceCheck iface;
CORBA_Environment ev;
CORBA_char *version;
CORBA_exception_init (&ev);
/* FIXME Should we really kill it off? We also shouldn't hard code the version */
iface = bonobo_activation_activate_from_id ("OAFIID:GNOME_Evolution_DataServer_InterfaceCheck", 0, NULL, &ev);
if (BONOBO_EX (&ev) || iface == CORBA_OBJECT_NIL) {
kill_dataserver ();
CORBA_exception_free (&ev);
return;
}
version = GNOME_Evolution_DataServer_InterfaceCheck__get_interfaceVersion (iface, &ev);
if (BONOBO_EX (&ev)) {
kill_dataserver ();
CORBA_Object_release (iface, &ev);
CORBA_exception_free (&ev);
return;
}
if (strcmp (version, DATASERVER_VERSION) != 0) {
CORBA_free (version);
kill_dataserver ();
CORBA_Object_release (iface, &ev);
CORBA_exception_free (&ev);
return;
}
CORBA_free (version);
CORBA_Object_release (iface, &ev);
CORBA_exception_free (&ev);
}
int
main (int argc, char **argv)
{
CORBA_Environment ev[1];
PortableServer_POA rootpoa, poa;
CORBA_exception_init (ev);
orb = CORBA_ORB_init (&argc, argv, "", ev);
rootpoa = (PortableServer_POA)
CORBA_ORB_resolve_initial_references (orb, "RootPOA", ev);
g_assert (ev->_major == CORBA_NO_EXCEPTION);
{
poa = ORBit_POA_new_from (orb, rootpoa, "Foo", NULL, ev);
g_assert (ev->_major == CORBA_NO_EXCEPTION);
PortableServer_POA_destroy (poa, FALSE, FALSE, ev);
CORBA_Object_release ((CORBA_Object) poa, ev);
}
CORBA_Object_release ((CORBA_Object) rootpoa, ev);
CORBA_ORB_destroy (orb, ev);
g_assert (ev->_major == CORBA_NO_EXCEPTION);
CORBA_Object_release ((CORBA_Object) orb, ev);
g_assert (ev->_major == CORBA_NO_EXCEPTION);
CORBA_exception_free (ev);
fprintf (stderr, "PASS: test-poa\n");
return 0;
}
static
void
client_cleanup (CORBA_ORB orb,
CORBA_Object service,
CORBA_Environment *ev)
{
CORBA_Object_release(service, ev);
if (etk_raised_exception(ev)) return;
if (orb != CORBA_OBJECT_NIL)
{
CORBA_ORB_destroy(orb, ev);
if (etk_raised_exception(ev)) return;
}
}