GIOPRecvBuffer *
giop_recv_buffer_use_encaps_buf (GIOPRecvBuffer *buf)
{
guchar *ptr;
CORBA_unsigned_long len;
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
return NULL;
len = *(CORBA_unsigned_long *) buf->cur;
if (giop_msg_conversion_needed (buf))
len = GUINT32_SWAP_LE_BE (len);
buf->cur += 4;
if ((buf->cur + len) > buf->end ||
(buf->cur + len) < buf->cur)
return NULL;
ptr = buf->cur;
buf->cur += len;
return giop_recv_buffer_use_encaps (ptr, len);
}
static gboolean
giop_recv_buffer_demarshal_locate_request_1_1(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed (buf);
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 8) > buf->end)
return TRUE;
if (do_bswap)
buf->msg.u.locate_request_1_1.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.locate_request_1_1.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
if (do_bswap)
buf->msg.u.locate_request_1_1.object_key._length = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.locate_request_1_1.object_key._length = *((guint32 *)buf->cur);
buf->cur += 4;
if ((buf->cur + buf->msg.u.locate_request_1_1.object_key._length) > buf->end ||
(buf->cur + buf->msg.u.locate_request_1_1.object_key._length) < buf->cur)
return TRUE;
buf->msg.u.locate_request_1_1.object_key._buffer = buf->cur;
buf->msg.u.locate_request_1_1.object_key._release = CORBA_FALSE;
buf->cur += buf->msg.u.locate_request_1_1.object_key._length;
return FALSE;
}
static gboolean
giop_recv_buffer_demarshal_reply_1_2(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed(buf);
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 8) > buf->end)
return TRUE;
if(do_bswap)
{
buf->msg.u.reply_1_2.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
buf->cur += 4;
buf->msg.u.reply_1_2.reply_status = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
}
else
{
buf->msg.u.reply_1_2.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
buf->msg.u.reply_1_2.reply_status = *((guint32 *)buf->cur);
}
buf->cur += 4;
buf->msg.u.reply_1_2.service_context._buffer = NULL;
if(giop_IOP_ServiceContextList_demarshal(buf, &buf->msg.u.reply_1_2.service_context))
return TRUE;
buf->cur = ALIGN_ADDRESS(buf->cur, 8);
return FALSE;
}
void
_ORBIT_skel_Freeamp_PlayNumber(POA_Freeamp * _ORBIT_servant,
GIOPRecvBuffer * _ORBIT_recv_buffer,
CORBA_Environment * ev,
void (*_impl_PlayNumber)
(PortableServer_Servant _servant,
const CORBA_char * number,
CORBA_Environment * ev))
{
CORBA_char *number;
{ /* 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;
number = (void *) _ORBIT_curptr;
_ORBIT_curptr += sizeof(number[_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;
number = (void *) _ORBIT_curptr;
_ORBIT_curptr += sizeof(number[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
}
}
_impl_PlayNumber(_ORBIT_servant, number, 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) {
} else
ORBit_send_system_exception(_ORBIT_send_buffer, ev);
giop_send_buffer_write(_ORBIT_send_buffer);
giop_send_buffer_unuse(_ORBIT_send_buffer);
}
}
}
static gboolean
giop_recv_buffer_demarshal_cancel(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed (buf);
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
return TRUE;
if (do_bswap)
buf->msg.u.cancel_request.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.cancel_request.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
return FALSE;
}
/* Don't do this genericaly, union's suck genericaly */
static gboolean
giop_GIOP_TargetAddress_demarshal (GIOPRecvBuffer *buf,
GIOP_TargetAddress *value)
{
gboolean do_bswap = giop_msg_conversion_needed (buf);
buf->cur = ALIGN_ADDRESS(buf->cur, 2);
if ((buf->cur + 2) > buf->end)
return TRUE;
if (do_bswap)
value->_d = GUINT16_SWAP_LE_BE (
*(guint16 *) buf->cur);
else
value->_d = *(guint16 *) buf->cur;
buf->cur += 2;
switch (value->_d) {
case GIOP_KeyAddr:
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
return TRUE;
value->_u.object_key._release = CORBA_FALSE;
if (do_bswap)
value->_u.object_key._length = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
value->_u.object_key._length = *((guint32 *)buf->cur);
buf->cur += 4;
if ((buf->cur + value->_u.object_key._length) > buf->end ||
(buf->cur + value->_u.object_key._length) < buf->cur)
return TRUE;
value->_u.object_key._buffer = buf->cur;
buf->cur += value->_u.object_key._length;
break;
case GIOP_ProfileAddr:
g_warning ("XXX FIXME GIOP_ProfileAddr not handled");
return TRUE;
break;
case GIOP_ReferenceAddr:
g_warning ("XXX FIXME GIOP_ReferenceAddr not handled");
return TRUE;
break;
}
return FALSE;
}
static gboolean
giop_recv_buffer_demarshal_request_1_2(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed(buf);
CORBA_unsigned_long oplen;
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 8) > buf->end)
return TRUE;
if(do_bswap)
buf->msg.u.request_1_2.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.request_1_2.request_id = *((guint32 *) buf->cur);
buf->cur += 4;
buf->msg.u.request_1_2.response_flags = *buf->cur;
buf->cur += 4;
if(giop_GIOP_TargetAddress_demarshal(buf, &buf->msg.u.request_1_2.target))
return TRUE;
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 4) > buf->end)
return TRUE;
if(do_bswap)
oplen = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
oplen = *((guint32 *)buf->cur);
buf->cur += 4;
if((buf->cur + oplen) > buf->end
|| (buf->cur + oplen) < buf->cur)
return TRUE;
buf->msg.u.request_1_2.operation = (CORBA_char *) buf->cur;
buf->cur += oplen;
buf->msg.u.request_1_2.service_context._buffer = NULL;
if(giop_IOP_ServiceContextList_demarshal(buf, &buf->msg.u.request_1_2.service_context))
return TRUE;
buf->cur = ALIGN_ADDRESS(buf->cur, 8);
return FALSE;
}
static gboolean
giop_recv_buffer_demarshal_locate_request_1_2(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed(buf);
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 4) > buf->end)
return TRUE;
if(do_bswap)
buf->msg.u.locate_request_1_2.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.locate_request_1_2.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
return giop_GIOP_TargetAddress_demarshal (buf, &buf->msg.u.locate_request_1_2.target);
}
static gboolean
giop_recv_buffer_demarshal_locate_reply_1_1(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed(buf);
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 8) > buf->end)
return TRUE;
if (do_bswap) {
buf->msg.u.locate_reply_1_1.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
buf->cur += 4;
buf->msg.u.locate_reply_1_1.locate_status = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
} else {
buf->msg.u.locate_reply_1_1.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
buf->msg.u.locate_reply_1_1.locate_status = *((guint32 *)buf->cur);
}
buf->cur += 4;
return FALSE;
}
void
_ORBIT_skel_Freeamp_GetPlaylist(POA_Freeamp * _ORBIT_servant,
GIOPRecvBuffer * _ORBIT_recv_buffer,
CORBA_Environment * ev,
void (*_impl_GetPlaylist)
(PortableServer_Servant _servant,
Freeamp_StringList ** list,
CORBA_Environment * ev))
{
Freeamp_StringList *list;
{ /* demarshalling */
guchar *_ORBIT_curptr;
_ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
} else {
}
}
_impl_GetPlaylist(_ORBIT_servant, &(list), 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) {
register CORBA_unsigned_long _ORBIT_tmpvar_0;
register CORBA_unsigned_long _ORBIT_tmpvar_1;
CORBA_unsigned_long _ORBIT_tmpvar_2;
giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
(_ORBIT_send_buffer), 4);
{
guchar *_ORBIT_t;
_ORBIT_t = alloca(sizeof((*list)._length));
memcpy(_ORBIT_t, &((*list)._length), sizeof((*list)._length));
giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
(_ORBIT_send_buffer),
(_ORBIT_t),
sizeof((*list)._length));
}
for (_ORBIT_tmpvar_0 = 0; _ORBIT_tmpvar_0 < (*list)._length;
_ORBIT_tmpvar_0++) {
_ORBIT_tmpvar_2 = strlen((*list)._buffer[_ORBIT_tmpvar_0]) + 1;
giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
(_ORBIT_send_buffer), 4);
{
guchar *_ORBIT_t;
_ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_2));
memcpy(_ORBIT_t, &(_ORBIT_tmpvar_2),
sizeof(_ORBIT_tmpvar_2));
giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
(_ORBIT_send_buffer),
(_ORBIT_t),
sizeof(_ORBIT_tmpvar_2));
}
{
guchar *_ORBIT_t;
_ORBIT_t =
alloca(sizeof
((*list).
_buffer[_ORBIT_tmpvar_0][_ORBIT_tmpvar_1]) *
_ORBIT_tmpvar_2);
memcpy(_ORBIT_t, ((*list)._buffer[_ORBIT_tmpvar_0]),
sizeof((*list).
_buffer[_ORBIT_tmpvar_0][_ORBIT_tmpvar_1])
* _ORBIT_tmpvar_2);
giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
(_ORBIT_send_buffer),
(_ORBIT_t),
sizeof((*list).
_buffer
[_ORBIT_tmpvar_0]
[_ORBIT_tmpvar_1]) *
_ORBIT_tmpvar_2);
}
}
} 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_free(list);
}
}
gboolean
ORBit_Context_demarshal (CORBA_Context parent,
CORBA_Context initme,
GIOPRecvBuffer *buf)
{
CORBA_unsigned_long nstrings, keylen, vallen, i;
char *key, *value;
initme->parent.refs = ORBIT_REFCOUNT_STATIC;
initme->parent_ctx = parent;
initme->mappings = NULL;
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
goto errout;
nstrings = *(CORBA_unsigned_long *) buf->cur;
if (giop_msg_conversion_needed (buf))
nstrings = GUINT32_SWAP_LE_BE (nstrings);
buf->cur += 4;
if ((buf->cur + nstrings * 8) > buf->end)
goto errout;
if (nstrings)
initme->mappings = g_hash_table_new (g_str_hash, g_str_equal);
else
goto errout;
for (i = 0; i < nstrings; ) {
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
goto errout;
keylen = *(CORBA_unsigned_long *) buf->cur;
if (giop_msg_conversion_needed (buf))
keylen = GUINT32_SWAP_LE_BE(keylen);
buf->cur += 4;
if ((buf->cur + keylen) > buf->end ||
(buf->cur + keylen) < buf->cur)
goto errout;
key = buf->cur;
buf->cur += keylen;
i++;
if (i >= nstrings)
break;
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
goto errout;
vallen = *(CORBA_unsigned_long *) buf->cur;
if (giop_msg_conversion_needed (buf))
vallen = GUINT32_SWAP_LE_BE(vallen);
buf->cur += 4;
if ((buf->cur + vallen) > buf->end ||
(buf->cur + vallen) < buf->cur)
goto errout;
value = buf->cur;
buf->cur += vallen;
i++;
g_hash_table_insert (initme->mappings, key, value);
}
return FALSE;
errout:
if (initme->mappings)
g_hash_table_destroy (initme->mappings);
return TRUE;
}
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;
}
}
}
static gboolean
giop_recv_buffer_demarshal_request_1_1(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed(buf);
CORBA_unsigned_long oplen;
buf->msg.u.request_1_1.service_context._buffer = NULL;
if(giop_IOP_ServiceContextList_demarshal(buf, &buf->msg.u.request_1_1.service_context))
return TRUE;
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 12) > buf->end)
return TRUE;
if(do_bswap)
buf->msg.u.request_1_1.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.request_1_1.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
buf->msg.u.request_1_1.response_expected = *buf->cur;
buf->cur += 4;
if(do_bswap)
buf->msg.u.request_1_1.object_key._length = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.request_1_1.object_key._length = *((guint32 *)buf->cur);
buf->cur += 4;
if((buf->cur + buf->msg.u.request_1_1.object_key._length) > buf->end
|| (buf->cur + buf->msg.u.request_1_1.object_key._length) < buf->cur)
return TRUE;
buf->msg.u.request_1_1.object_key._buffer = buf->cur;
buf->msg.u.request_1_1.object_key._release = CORBA_FALSE;
buf->cur += buf->msg.u.request_1_1.object_key._length;
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 4) > buf->end)
return TRUE;
if(do_bswap)
oplen = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
oplen = *((guint32 *)buf->cur);
buf->cur += 4;
if((buf->cur + oplen) > buf->end
|| (buf->cur + oplen) < buf->cur)
return TRUE;
buf->msg.u.request_1_1.operation = (CORBA_char *) buf->cur;
buf->cur += oplen;
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 4) > buf->end)
return TRUE;
if(do_bswap)
buf->msg.u.request_1_1.requesting_principal._length = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.request_1_1.requesting_principal._length = *((guint32 *)buf->cur);
buf->cur += 4;
if((buf->cur + buf->msg.u.request_1_1.requesting_principal._length) > buf->end
|| (buf->cur + buf->msg.u.request_1_1.requesting_principal._length) < buf->cur)
return TRUE;
buf->msg.u.request_1_1.requesting_principal._buffer = buf->cur;
buf->msg.u.request_1_1.requesting_principal._release = CORBA_FALSE;
buf->cur += buf->msg.u.request_1_1.requesting_principal._length;
return FALSE;
}
/**
* giop_recv_buffer_handle_fragmented:
* @buf: pointer to recv buffer pointer
* @cnx: current connection.
*
* This will append @buf to the right list of buffers
* on the connection, forming a complete message, and
* re-write *@buf to the first buffer in the chain.
*
* Return value: TRUE on error else FALSE
**/
static gboolean
giop_recv_buffer_handle_fragmented (GIOPRecvBuffer **ret_buf,
GIOPConnection *cnx)
{
GList *list;
gboolean giop_1_1;
gboolean error = FALSE;
CORBA_long message_id;
GIOPRecvBuffer *buf = *ret_buf;
giop_1_1 = (buf->giop_version == GIOP_1_1);
switch (buf->msg.header.message_type) {
case GIOP_REPLY:
case GIOP_LOCATEREPLY:
case GIOP_REQUEST:
case GIOP_LOCATEREQUEST:
message_id = giop_recv_buffer_get_request_id (buf);
break;
case GIOP_FRAGMENT:
if (!giop_1_1) {
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end) {
dprintf (ERRORS, "incoming bogus fragment length");
return TRUE;
}
if (giop_msg_conversion_needed (buf))
message_id = GUINT32_SWAP_LE_BE (*((guint32 *)buf->cur));
else
message_id = *(guint32 *) buf->cur;
buf->cur += 4;
} else
message_id = 0;
break;
default:
dprintf (ERRORS, "Bogus fragment packet type %d",
buf->msg.header.message_type);
return TRUE;
}
if (!(list = giop_connection_get_frag (cnx, message_id, giop_1_1))) {
if (!MORE_FRAGMENTS_FOLLOW (buf))
return TRUE;
giop_connection_add_frag (cnx, buf);
} else {
GIOPRecvBuffer *head = list->data;
*ret_buf = head;
g_assert (head->msg.header.message_type != GIOP_FRAGMENT);
/* track total length on head node */
/* (end - cur) to account for fragment (msg id) header */
head->msg.header.message_size += (buf->end - buf->cur);
list = g_list_append (list, buf);
if (!cnx->parent.is_auth &&
buf->msg.header.message_size > giop_initial_msg_size_limit) {
dprintf (ERRORS, "Message exceeded initial size limit\n");
error = TRUE;
giop_connection_remove_frag (cnx, list);
}
if (!MORE_FRAGMENTS_FOLLOW (buf)) {
g_assert (buf->msg.header.message_type == GIOP_FRAGMENT);
/* concat all fragments - re-write & continue */
error = concat_frags (list);
giop_connection_remove_frag (cnx, list);
}
}
return error;
}
