void
PortableServer_POAManager_hold_requests (PortableServer_POAManager manager,
const CORBA_boolean wait_for_completion,
CORBA_Environment *ev)
{
if (!manager) {
CORBA_exception_set_system (ev, ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return;
}
POA_MGR_LOCK (poa_mgr);
if (manager->state == PortableServer_POAManager_INACTIVE)
CORBA_exception_set
(ev, CORBA_USER_EXCEPTION,
ex_PortableServer_POAManager_AdapterInactive,
NULL);
else {
manager->state = PortableServer_POAManager_HOLDING;
if (!wait_for_completion)
g_warning ("hold_requests not finished - don't "
"know how to kill outstanding request fulfillments");
}
POA_MGR_UNLOCK (poa_mgr);
}
void
PortableServer_POAManager_activate (PortableServer_POAManager manager,
CORBA_Environment *ev)
{
GSList *l;
if (!manager) {
CORBA_exception_set_system (ev, ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return;
}
POA_MGR_LOCK (poa_mgr);
if (manager->state == PortableServer_POAManager_INACTIVE)
CORBA_exception_set
(ev, CORBA_USER_EXCEPTION,
ex_PortableServer_POAManager_AdapterInactive,
NULL);
else {
manager->state = PortableServer_POAManager_ACTIVE;
for (l = manager->poa_collection; l; l = l->next) {
PortableServer_POA poa = (PortableServer_POA)l->data;
/* FIXME: need better locking here */
ORBit_POA_handle_held_requests (poa);
}
}
POA_MGR_UNLOCK (poa_mgr);
}
void
ORBit_handle_system_exception (CORBA_Environment *ev,
const CORBA_char *nom,
CORBA_completion_status status,
GIOPRecvBuffer *buf,
GIOPSendBuffer *sendbuf)
{
CORBA_exception_set_system (ev, nom, status);
giop_recv_buffer_unuse (buf);
giop_send_buffer_unuse (sendbuf);
}
void
CORBA_Context_get_values (CORBA_Context ctx,
const CORBA_char *start_scope,
const CORBA_Flags op_flags,
const CORBA_char *prop_name,
CORBA_NVList *values,
CORBA_Environment *ev)
{
char *ctmp;
int wc_pos;
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);
}
}
void
PortableServer_POAManager_deactivate (PortableServer_POAManager manager,
const CORBA_boolean etherealize_objects,
const CORBA_boolean wait_for_completion,
CORBA_Environment *ev)
{
GSList *l;
if (!manager) {
CORBA_exception_set_system (ev, ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return;
}
POA_MGR_LOCK (poa_mgr);
if (manager->state == PortableServer_POAManager_INACTIVE)
CORBA_exception_set
(ev, CORBA_USER_EXCEPTION,
ex_PortableServer_POAManager_AdapterInactive,
NULL);
else {
if (wait_for_completion)
for (l = manager->poa_collection; l; l = l->next)
if (!ORBit_POA_is_inuse (l->data, FALSE, ev)) {
CORBA_exception_set_system
(ev, ex_CORBA_BAD_INV_ORDER,
CORBA_COMPLETED_NO);
POA_MGR_UNLOCK (poa_mgr);
return;
}
manager->state = PortableServer_POAManager_INACTIVE;
for (l = manager->poa_collection; l; l = l->next)
ORBit_POA_deactivate (l->data, etherealize_objects, ev);
}
POA_MGR_UNLOCK (poa_mgr);
}
static void
impl_MateComponent_Canvas_Component_render (PortableServer_Servant servant,
MateComponent_Canvas_Buf *buf,
CORBA_Environment *ev)
{
Gcc *gcc = GCC (matecomponent_object_from_servant (servant));
MateCanvasItem *item = MATE_CANVAS_ITEM (gcc->priv->item);
MateCanvasBuf canvas_buf;
if (!(buf->flags & MateComponent_Canvas_IS_BUF)) {
buf->rgb_buf._length = buf->row_stride * (buf->rect.y1 - buf->rect.y0);
buf->rgb_buf._maximum = buf->rgb_buf._length;
buf->rgb_buf._buffer = CORBA_sequence_CORBA_octet_allocbuf (
buf->rgb_buf._length);
CORBA_sequence_set_release (&buf->rgb_buf, TRUE);
if (buf->rgb_buf._buffer == NULL) {
CORBA_exception_set_system (
ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
return;
}
}
canvas_buf.buf = buf->rgb_buf._buffer;
canvas_buf.buf_rowstride = buf->row_stride;
canvas_buf.rect.x0 = buf->rect.x0;
canvas_buf.rect.x1 = buf->rect.x1;
canvas_buf.rect.y0 = buf->rect.y0;
canvas_buf.rect.y1 = buf->rect.y1;
canvas_buf.bg_color = buf->bg_color;
if (buf->flags & MateComponent_Canvas_IS_BG)
canvas_buf.is_bg = 1;
else
canvas_buf.is_bg = 0;
if (buf->flags & MateComponent_Canvas_IS_BUF)
canvas_buf.is_buf = 1;
else
canvas_buf.is_buf = 0;
ICLASS (item)->render (item, &canvas_buf);
/* return */
buf->flags =
(canvas_buf.is_bg ? MateComponent_Canvas_IS_BG : 0) |
(canvas_buf.is_buf ? MateComponent_Canvas_IS_BUF : 0);
}
static guint8*
accessible_content_stream_client_read (const Accessibility_ContentStream stream,
const size_t size,
CORBA_long *length_read,
CORBA_Environment *ev)
{
size_t pos;
guint8 *mem;
size_t length;
g_return_val_if_fail (ev != NULL, NULL);
if (length_read)
*length_read = size;
length = size;
if (length == 0)
return NULL;
mem = g_try_malloc (length);
if (!mem) {
CORBA_exception_set_system (ev, ex_CORBA_NO_MEMORY,
CORBA_COMPLETED_NO);
return NULL;
}
*length_read = 0;
for (pos = 0; pos < length;) {
Accessibility_ContentStream_iobuf *buf;
CORBA_long len;
len = (pos + CORBA_BLOCK_SIZE < length) ?
CORBA_BLOCK_SIZE : length - pos;
Accessibility_ContentStream_read (stream, len, &buf, ev);
if (BONOBO_EX (ev) || !buf)
goto io_error;
if (buf->_length > 0) {
memcpy (mem + pos, buf->_buffer, buf->_length);
pos += buf->_length;
*length_read += buf->_length;
/* we assume a short read equals EOF ... is that right? */
if (buf->_length < len || *length_read == size)
return mem;
} else {
g_warning ("Buffer length %d", buf->_length);
goto io_error;
}
*length_read += buf->_length;
CORBA_free (buf);
}
return mem;
io_error:
return NULL;
}
static MateComponent_Canvas_ArtUTA *
impl_MateComponent_Canvas_Component_update (PortableServer_Servant servant,
const MateComponent_Canvas_State *state,
const MateComponent_Canvas_affine aff,
const MateComponent_Canvas_SVP *clip_path,
CORBA_long flags,
CORBA_double *x1,
CORBA_double *y1,
CORBA_double *x2,
CORBA_double *y2,
CORBA_Environment *ev)
{
Gcc *gcc = GCC (matecomponent_object_from_servant (servant));
MateCanvasItem *item = MATE_CANVAS_ITEM (gcc->priv->item);
double affine [6];
int i;
ArtSVP *svp = NULL;
MateComponent_Canvas_ArtUTA *cuta;
MateCanvasItemClass *gci_class = g_type_class_ref (
mate_canvas_item_get_type ());
restore_state (item, state);
for (i = 0; i < 6; i++)
affine [i] = aff [i];
if (clip_path->_length > 0) {
svp = art_alloc (sizeof (ArtSVP) + (clip_path->_length * sizeof (ArtSVPSeg)));
if (svp == NULL)
goto fail;
svp->n_segs = clip_path->_length;
for (i = 0; svp->n_segs; i++) {
gboolean ok;
ok = CORBA_SVP_Segment_to_SVPSeg (&clip_path->_buffer [i], &svp->segs [i]);
if (!ok) {
int j;
for (j = 0; j < i; j++) {
free_seg (&svp->segs [j]);
art_free (svp);
goto fail;
}
}
}
}
invoke_update (item, (double *)aff, svp, flags);
if (svp){
for (i = 0; i < svp->n_segs; i++)
free_seg (&svp->segs [i]);
art_free (svp);
}
fail:
if (getenv ("CC_DEBUG"))
printf ("%g %g %g %g\n", item->x1, item->x2, item->y1, item->y2);
*x1 = item->x1;
*x2 = item->x2;
*y1 = item->y1;
*y2 = item->y2;
cuta = CORBA_UTA (item->canvas->redraw_area);
if (cuta == NULL) {
CORBA_exception_set_system (ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
return NULL;
}
/*
* Now, mark our canvas as fully up to date
*/
/* Clears flags for root item. */
(* gci_class->update) (item->canvas->root, affine, svp, flags);
if (item->canvas->redraw_area) {
art_uta_free (item->canvas->redraw_area);
item->canvas->redraw_area = NULL;
}
item->canvas->need_redraw = FALSE;
return cuta;
}
int
main (int argc, char *argv [])
{
BonoboObject *object;
Bonobo_Unknown ref;
CORBA_Environment *ev, real_ev;
g_thread_init (NULL);
free (malloc (8));
if (bonobo_init (&argc, argv) == FALSE)
g_error ("Can not bonobo_init");
bonobo_activate ();
ev = &real_ev;
CORBA_exception_init (ev);
fprintf (stderr, "Local lifecycle\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
g_assert (bonobo_object_ref (object) == object);
g_assert (bonobo_object_unref (BONOBO_OBJECT (object)) == NULL);
bonobo_object_unref (BONOBO_OBJECT (object));
}
fprintf (stderr, "In-proc lifecycle\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
ref = CORBA_Object_duplicate (BONOBO_OBJREF (object), NULL);
bonobo_object_release_unref (ref, NULL);
}
fprintf (stderr, "Query interface\n");
{
BonoboObject *a, *b;
a = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
b = BONOBO_OBJECT (g_object_new (
bonobo_stream_mem_get_type (), NULL));
bonobo_object_add_interface (a, b);
fprintf (stderr, " invalid interface\n");
object = bonobo_object_query_local_interface (
a, "IDL:This/Is/Not/There:1.0");
g_assert (object == CORBA_OBJECT_NIL);
fprintf (stderr, " symmetry\n");
object = bonobo_object_query_local_interface (
a, "IDL:Bonobo/Stream:1.0");
g_assert (object == b);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
b, "IDL:Bonobo/Stream:1.0");
g_assert (object == b);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
a, "IDL:Bonobo/Moniker:1.0");
g_assert (object == a);
bonobo_object_unref (object);
object = bonobo_object_query_local_interface (
b, "IDL:Bonobo/Moniker:1.0");
g_assert (object == a);
bonobo_object_unref (object);
fprintf (stderr, " remote\n");
ref = Bonobo_Unknown_queryInterface (
BONOBO_OBJREF (a), "IDL:Broken/1.0", ev);
g_assert (!BONOBO_EX (ev));
g_assert (ref == CORBA_OBJECT_NIL);
ref = Bonobo_Unknown_queryInterface (
BONOBO_OBJREF (a), "IDL:Bonobo/Stream:1.0", ev);
g_assert (!BONOBO_EX (ev));
g_assert (ref == BONOBO_OBJREF (b));
bonobo_object_release_unref (ref, ev);
g_assert (!BONOBO_EX (ev));
bonobo_object_unref (a);
}
fprintf (stderr, "Environment exception checks\n");
{
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
g_signal_connect (G_OBJECT (object),
"system_exception",
G_CALLBACK (system_exception_cb),
object);
CORBA_exception_set_system (
ev, ex_CORBA_COMM_FAILURE,
CORBA_COMPLETED_MAYBE);
g_assert (BONOBO_EX (ev));
signal_emitted = 0;
BONOBO_OBJECT_CHECK (
object, BONOBO_OBJREF (object), ev);
g_assert (signal_emitted);
CORBA_exception_free (ev);
bonobo_object_unref (object);
}
fprintf (stderr, "Servant mapping...\n");
{
PortableServer_Servant servant;
object = BONOBO_OBJECT (g_object_new (
bonobo_moniker_get_type (), NULL));
servant = (PortableServer_Servant) &object->servant;
g_assert (bonobo_object (object) == object);
g_assert (bonobo_object (&object->servant) == object);
g_assert (bonobo_object_get_servant (object) == servant);
g_assert (bonobo_object_from_servant (servant) == object);
g_assert (bonobo_object_fast (object) == object);
g_assert (bonobo_object_fast (servant) == object);
bonobo_object_unref (object);
}
fprintf (stderr, "Ret-ex tests...\n");
{
g_assert (!ret_ex_test (ev));
ex_test (ev);
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_Bonobo_PropertyBag_NotFound, NULL);
g_assert (ret_ex_test (ev));
CORBA_exception_free (ev);
}
fprintf (stderr, "General error tests...\n");
{
bonobo_exception_general_error_set (
ev, NULL, "a%s exception occurred", "n exceptional");
g_assert (BONOBO_EX (ev));
g_assert (!strcmp (BONOBO_EX_REPOID (ev), ex_Bonobo_GeneralError));
g_assert (!strcmp (bonobo_exception_get_text (ev),
"an exceptional exception occurred"));
}
fprintf (stderr, "All tests passed\n");
return bonobo_debug_shutdown ();
}
CORBA_Object
CORBA_ORB_string_to_object (CORBA_ORB orb,
const CORBA_char *string,
CORBA_Environment *ev)
{
CORBA_Object retval = CORBA_OBJECT_NIL;
CORBA_unsigned_long len;
GIOPRecvBuffer *buf;
#if defined ENABLE_HTTP
gchar *ior = NULL;
#endif
guchar *tmpbuf;
int i;
if (strncmp (string, "IOR:", strlen("IOR:")) &&
strncmp (string, "corbaloc:", strlen ("corbaloc:")) &&
strncmp (string, "iiop:", strlen ("iiop:")) &&
strncmp (string, "iiops:", strlen ("iiops:")) &&
strncmp (string, "ssliop:", strlen ("ssliop:")) &&
strncmp (string, "uiop:", strlen ("uiop:"))) {
#if defined ENABLE_HTTP
if (matecorba_use_http_iors &&
strstr (string, "://")) {
/* FIXME: this code is a security hazard */
ior = orb_http_resolve (string);
if (!ior) {
/* FIXME, set error minor code
* (vendor's error code) to tell user
* initial location of error, ie my
* local ORB, proxy's ORB, server's
* ORB, etc. */
CORBA_exception_set_system (
ev,
ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return CORBA_OBJECT_NIL;
}
string = ior;
} else
#endif
{
CORBA_exception_set_system (
ev,
ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return CORBA_OBJECT_NIL;
}
}
if (!strncmp (string, "IOR:", strlen ("IOR:")))
{
string += 4;
len = strlen (string);
while (len > 0 && !g_ascii_isxdigit (string [len - 1]))
len--;
if (len % 2) {
#if defined ENABLE_HTTP
g_free (ior);
#endif
return CORBA_OBJECT_NIL;
}
tmpbuf = g_alloca (len / 2);
for (i = 0; i < len; i += 2)
tmpbuf [i/2] = (g_ascii_xdigit_value (string [i]) << 4) |
g_ascii_xdigit_value (string [i + 1]);
buf = giop_recv_buffer_use_encaps (tmpbuf, len / 2);
if (MateCORBA_demarshal_object (&retval, buf, orb)) {
CORBA_exception_set_system (
ev,
ex_CORBA_MARSHAL,
CORBA_COMPLETED_NO);
retval = CORBA_OBJECT_NIL;
}
giop_recv_buffer_unuse (buf);
#if defined ENABLE_HTTP
g_free (ior);
#endif
return retval;
} else {
return MateCORBA_object_by_corbaloc (orb, string, ev);
}
}
CORBA_char *
CORBA_ORB_object_to_string (CORBA_ORB orb,
const CORBA_Object obj,
CORBA_Environment *ev)
{
GIOPSendBuffer *buf;
CORBA_octet endianness = GIOP_FLAG_ENDIANNESS;
CORBA_char *out;
int i, j, k;
g_return_val_if_fail (ev != NULL, NULL);
if(!orb || !obj || MATECORBA_ROOT_OBJECT_TYPE (obj) != MATECORBA_ROT_OBJREF) {
CORBA_exception_set_system (
ev, ex_CORBA_BAD_PARAM, CORBA_COMPLETED_NO);
return NULL;
}
if (matecorba_use_corbaloc) {
out = MateCORBA_object_to_corbaloc (obj, ev);
if (ev->_major == CORBA_NO_EXCEPTION)
return out;
CORBA_exception_free (ev);
/* fall thru, common marshalling */
}
buf = giop_send_buffer_use (orb->default_giop_version);
g_assert (buf->num_used == 1);
buf->header_size = 0;
buf->lastptr = NULL;
buf->num_used = 0; /* we don't want the header in there */
buf->msg.header.message_size = 0;
giop_send_buffer_append (buf, &endianness, 1);
MateCORBA_marshal_object (buf, obj);
out = CORBA_string_alloc (4 + (buf->msg.header.message_size * 2) + 1);
strcpy (out, "IOR:");
for (i = 0, k = 4; i < buf->num_used; i++) {
struct iovec *curvec;
guchar *ptr;
curvec = &buf->iovecs [i];
ptr = curvec->iov_base;
for (j = 0; j < curvec->iov_len; j++, ptr++) {
int n1, n2;
n1 = (*ptr & 0xF0) >> 4;
n2 = (*ptr & 0xF);
out [k++] = num2hexdigit (n1);
out [k++] = num2hexdigit (n2);
}
}
out [k++] = '\0';
giop_send_buffer_unuse (buf);
return out;
}
Account
factory_newAccount(factory _obj, const CORBA_unsigned_long balance,
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;
Account _ORBIT_retval;
if (_obj->servant && _obj->vepv && factory__classid) {
_ORBIT_retval =
((POA_factory__epv *) _obj->vepv[factory__classid])->
newAccount(_obj->servant, balance, 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, "newAccount"};
static const struct iovec _ORBIT_operation_vec =
{ (gpointer) & _ORBIT_operation_name_data, 15 };
_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),
&(balance), sizeof(balance));
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;
}
}
}
