/*
 * This file was generated by orbit-idl - DO NOT EDIT!
 */

#include <string.h>
#include "trxctrl.h"

void
_ORBIT_Trx_TrxError_marshal(GIOPSendBuffer * _ORBIT_send_buffer,
			    CORBA_Environment * ev)
{
   register CORBA_unsigned_long _ORBIT_tmpvar_0;
   CORBA_unsigned_long _ORBIT_tmpvar_1;
   Trx_TrxError *_ORBIT_exdata = ev->_params;

   _ORBIT_tmpvar_1 = strlen((*_ORBIT_exdata).reason) + 1;
   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				    4);
   giop_send_buffer_append_mem_indirect(GIOP_SEND_BUFFER(_ORBIT_send_buffer),
					&(_ORBIT_tmpvar_1),
					sizeof(_ORBIT_tmpvar_1));
   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				  ((*_ORBIT_exdata).reason),
				  sizeof((*_ORBIT_exdata).
					 reason[_ORBIT_tmpvar_0]) *
				  _ORBIT_tmpvar_1);
}

void
_ORBIT_skel_Trx_Control_GetDescription(POA_Trx_Control * _ORBIT_servant,
				       GIOPRecvBuffer * _ORBIT_recv_buffer,
				       CORBA_Environment * ev,
				       void (*_impl_GetDescription)
				       (PortableServer_Servant _servant,
					Trx_TrxDescription ** desc,
					CORBA_Environment * ev))
{
   Trx_TrxDescription *desc;

   {				/* 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_GetDescription(_ORBIT_servant, &(desc), 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;
	    CORBA_unsigned_long _ORBIT_tmpvar_1;
	    register CORBA_unsigned_long _ORBIT_tmpvar_2;
	    CORBA_unsigned_long _ORBIT_tmpvar_3;
	    register CORBA_unsigned_long _ORBIT_tmpvar_4;
	    CORBA_unsigned_long _ORBIT_tmpvar_5;
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    CORBA_unsigned_long _ORBIT_tmpvar_7;
	    register CORBA_unsigned_long _ORBIT_tmpvar_8;
	    register CORBA_unsigned_long _ORBIT_tmpvar_9;

	    _ORBIT_tmpvar_1 = strlen((*desc).manufacturer) + 1;
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_1));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   ((*desc).manufacturer),
					   sizeof((*desc).
						  manufacturer
						  [_ORBIT_tmpvar_0]) *
					   _ORBIT_tmpvar_1);
	    _ORBIT_tmpvar_3 = strlen((*desc).model) + 1;
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_3));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_3), sizeof(_ORBIT_tmpvar_3));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_3));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   ((*desc).model),
					   sizeof((*desc).
						  model[_ORBIT_tmpvar_2]) *
					   _ORBIT_tmpvar_3);
	    _ORBIT_tmpvar_5 = strlen((*desc).copyright) + 1;
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_5));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_5), sizeof(_ORBIT_tmpvar_5));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_5));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   ((*desc).copyright),
					   sizeof((*desc).
						  copyright[_ORBIT_tmpvar_4])
					   * _ORBIT_tmpvar_5);
	    _ORBIT_tmpvar_7 = strlen((*desc).instid) + 1;
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_7));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_7), sizeof(_ORBIT_tmpvar_7));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_7));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   ((*desc).instid),
					   sizeof((*desc).
						  instid[_ORBIT_tmpvar_6]) *
					   _ORBIT_tmpvar_7);
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof((*desc).rxbands._length));
	       memcpy(_ORBIT_t, &((*desc).rxbands._length),
		      sizeof((*desc).rxbands._length));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*desc).rxbands.
						     _length));
	    }
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 8);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t =
		  alloca(sizeof((*desc).rxbands._buffer[_ORBIT_tmpvar_8]) *
			 (*desc).rxbands._length);
	       memcpy(_ORBIT_t, ((*desc).rxbands._buffer),
		      sizeof((*desc).rxbands._buffer[_ORBIT_tmpvar_8]) *
		      (*desc).rxbands._length);
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*desc).rxbands.
						     _buffer[_ORBIT_tmpvar_8])
					      * (*desc).rxbands._length);
	    }
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof((*desc).txbands._length));
	       memcpy(_ORBIT_t, &((*desc).txbands._length),
		      sizeof((*desc).txbands._length));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*desc).txbands.
						     _length));
	    }
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 8);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t =
		  alloca(sizeof((*desc).txbands._buffer[_ORBIT_tmpvar_9]) *
			 (*desc).txbands._length);
	       memcpy(_ORBIT_t, ((*desc).txbands._buffer),
		      sizeof((*desc).txbands._buffer[_ORBIT_tmpvar_9]) *
		      (*desc).txbands._length);
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*desc).txbands.
						     _buffer[_ORBIT_tmpvar_9])
					      * (*desc).txbands._length);
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &((*desc).rssimin),
					   sizeof((*desc).rssimin));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &((*desc).rssimax),
					   sizeof((*desc).rssimax));
	 } 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(desc);
   }
}
void
_ORBIT_skel_Trx_Control_GetState(POA_Trx_Control * _ORBIT_servant,
				 GIOPRecvBuffer * _ORBIT_recv_buffer,
				 CORBA_Environment * ev,
				 void (*_impl_GetState)
				 (PortableServer_Servant _servant,
				  Trx_TrxState * state,
				  CORBA_Environment * ev))
{
   Trx_TrxState state;

   {				/* 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_GetState(_ORBIT_servant, &(state), 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) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(state.mode), sizeof(state.mode));
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 8);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(state.rxfreq),
					   sizeof(state.rxfreq));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(state.txfreq),
					   sizeof(state.txfreq));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(state.ptt),
					   sizeof(state.ptt));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(state.manualptt),
					   sizeof(state.manualptt));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(state.dcd),
					   sizeof(state.dcd));
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(state.rssi), sizeof(state.rssi));
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_SetPTT(POA_Trx_Control * _ORBIT_servant,
			       GIOPRecvBuffer * _ORBIT_recv_buffer,
			       CORBA_Environment * ev,
			       void (*_impl_SetPTT) (PortableServer_Servant
						     _servant,
						     const CORBA_boolean ptt,
						     CORBA_Environment * ev))
{
   CORBA_boolean ptt;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 ptt = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
	 ptt = *((CORBA_boolean *) _ORBIT_curptr);
      }
   }
   _impl_SetPTT(_ORBIT_servant, ptt, 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 if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_SetFrequency(POA_Trx_Control * _ORBIT_servant,
				     GIOPRecvBuffer * _ORBIT_recv_buffer,
				     CORBA_Environment * ev,
				     void (*_impl_SetFrequency)
				     (PortableServer_Servant _servant,
				      const Trx_frequency rx,
				      const Trx_frequency tx,
				      CORBA_Environment * ev))
{
   Trx_frequency rx;
   Trx_frequency tx;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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, 8);
	 iiop_byteswap((guchar *) & (rx), _ORBIT_curptr, 8);
	 _ORBIT_curptr += 8;
	 iiop_byteswap((guchar *) & (tx), _ORBIT_curptr, 8);
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 8);
	 rx = *((Trx_frequency *) _ORBIT_curptr);
	 _ORBIT_curptr += 8;
	 tx = *((Trx_frequency *) _ORBIT_curptr);
      }
   }
   _impl_SetFrequency(_ORBIT_servant, rx, tx, ev);
}

void
_ORBIT_skel_Trx_Control_UartSend(POA_Trx_Control * _ORBIT_servant,
				 GIOPRecvBuffer * _ORBIT_recv_buffer,
				 CORBA_Environment * ev,
				 void (*_impl_UartSend)
				 (PortableServer_Servant _servant,
				  const CORBA_char * str,
				  CORBA_Environment * ev))
{
   CORBA_char *str;

   {				/* 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;
	 str = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(str[_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;
	 str = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(str[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl_UartSend(_ORBIT_servant, str, ev);
}

void
_ORBIT_skel_Trx_Control_UartReceive(POA_Trx_Control * _ORBIT_servant,
				    GIOPRecvBuffer * _ORBIT_recv_buffer,
				    CORBA_Environment * ev,
				    void (*_impl_UartReceive)
				    (PortableServer_Servant _servant,
				     CORBA_unsigned_long * ptr,
				     CORBA_char ** str,
				     CORBA_Environment * ev))
{
   CORBA_unsigned_long ptr;
   CORBA_char *str;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (ptr))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 ptr = *((CORBA_unsigned_long *) _ORBIT_curptr);
      }
   }
   _impl_UartReceive(_ORBIT_servant, &(ptr), &(str), 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;
	    CORBA_unsigned_long _ORBIT_tmpvar_1;

	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(ptr),
					   sizeof(ptr));
	    _ORBIT_tmpvar_1 = strlen(str) + 1;
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_1));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (str),
					   sizeof(str[_ORBIT_tmpvar_0]) *
					   _ORBIT_tmpvar_1);
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } 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(str);
   }
}
void
_ORBIT_skel_Trx_Control_BaycomUSBAdapterGetConfig(POA_Trx_Control *
						  _ORBIT_servant,
						  GIOPRecvBuffer *
						  _ORBIT_recv_buffer,
						  CORBA_Environment * ev,
						  void
						  (*_impl_BaycomUSBAdapterGetConfig)
						  (PortableServer_Servant
						   _servant,
						   Trx_BaycomUSBAdapterConfig
						   * cfg,
						   CORBA_Environment * ev))
{
   Trx_BaycomUSBAdapterConfig cfg;

   {				/* 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_BaycomUSBAdapterGetConfig(_ORBIT_servant, &(cfg), 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;

	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(cfg.mode),
					   sizeof(cfg.mode));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(cfg.fclk),
					   sizeof(cfg.fclk));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.bitraterx),
					   sizeof(cfg.bitraterx));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.bitratetx),
					   sizeof(cfg.bitratetx));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.loopback),
					   sizeof(cfg.loopback));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.pttmute),
					   sizeof(cfg.pttmute));
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.filtmode),
					   sizeof(cfg.filtmode));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.samplerate),
					   sizeof(cfg.samplerate));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(cfg.gain),
					   sizeof(cfg.gain));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (cfg.audiodevin),
					   sizeof(cfg.
						  audiodevin[_ORBIT_tmpvar_0])
					   * 64);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (cfg.audiodevout),
					   sizeof(cfg.
						  audiodevout
						  [_ORBIT_tmpvar_1]) * 64);
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.rfsquelch),
					   sizeof(cfg.rfsquelch));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.audiosquelch),
					   sizeof(cfg.audiosquelch));
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_BaycomUSBAdapterSetConfig(POA_Trx_Control *
						  _ORBIT_servant,
						  GIOPRecvBuffer *
						  _ORBIT_recv_buffer,
						  CORBA_Environment * ev,
						  void
						  (*_impl_BaycomUSBAdapterSetConfig)
						  (PortableServer_Servant
						   _servant,
						   const
						   Trx_BaycomUSBAdapterConfig
						   * cfg,
						   CORBA_Environment * ev))
{
   Trx_BaycomUSBAdapterConfig cfg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      register 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 *) & (cfg.mode))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.fclk))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.bitraterx))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.bitratetx))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.loopback))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 cfg.pttmute = *((CORBA_boolean *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (cfg.filtmode))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.samplerate))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.gain))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 memcpy(cfg.audiodevin, _ORBIT_curptr,
		sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64);
	 _ORBIT_curptr += sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64;
	 memcpy(cfg.audiodevout, _ORBIT_curptr,
		sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64);
	 _ORBIT_curptr += sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (cfg.rfsquelch))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 cfg.audiosquelch = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 cfg.mode = *((Trx_BaycomUSBAdapterMode *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.fclk = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.bitraterx = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.bitratetx = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.loopback = *((Trx_BaycomUSBAdapterLoopback *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.pttmute = *((CORBA_boolean *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 cfg.filtmode = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.samplerate = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.gain = *((CORBA_float *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 memcpy(cfg.audiodevin, _ORBIT_curptr,
		sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64);
	 _ORBIT_curptr += sizeof(cfg.audiodevin[_ORBIT_tmpvar_2]) * 64;
	 memcpy(cfg.audiodevout, _ORBIT_curptr,
		sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64);
	 _ORBIT_curptr += sizeof(cfg.audiodevout[_ORBIT_tmpvar_3]) * 64;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 cfg.rfsquelch = *((Trx_signalstrength *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 cfg.audiosquelch = *((CORBA_boolean *) _ORBIT_curptr);
      }
   }
   _impl_BaycomUSBAdapterSetConfig(_ORBIT_servant, &(cfg), 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 if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_BaycomUSBAdapterGetAudioDevices(POA_Trx_Control *
							_ORBIT_servant,
							GIOPRecvBuffer *
							_ORBIT_recv_buffer,
							CORBA_Environment *
							ev,
							void
							(*_impl_BaycomUSBAdapterGetAudioDevices)
							(PortableServer_Servant
							 _servant,
							 Trx_BaycomUSBAdapterAudioDevs
							 ** devs,
							 CORBA_Environment *
							 ev))
{
   Trx_BaycomUSBAdapterAudioDevs *devs;

   {				/* 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_BaycomUSBAdapterGetAudioDevices(_ORBIT_servant, &(devs), 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;
	    register CORBA_unsigned_long _ORBIT_tmpvar_2;
	    register CORBA_unsigned_long _ORBIT_tmpvar_3;

	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof((*devs).audiodevsin._length));
	       memcpy(_ORBIT_t, &((*devs).audiodevsin._length),
		      sizeof((*devs).audiodevsin._length));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*devs).audiodevsin.
						     _length));
	    }
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t =
		  alloca(sizeof((*devs).audiodevsin._buffer[_ORBIT_tmpvar_0])
			 * (*devs).audiodevsin._length);
	       memcpy(_ORBIT_t, ((*devs).audiodevsin._buffer),
		      sizeof((*devs).audiodevsin._buffer[_ORBIT_tmpvar_0]) *
		      (*devs).audiodevsin._length);
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*devs).audiodevsin.
						     _buffer[_ORBIT_tmpvar_0])
					      * (*devs).audiodevsin._length);
	    }
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof((*devs).audiodevsout._length));
	       memcpy(_ORBIT_t, &((*devs).audiodevsout._length),
		      sizeof((*devs).audiodevsout._length));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*devs).audiodevsout.
						     _length));
	    }
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t =
		  alloca(sizeof((*devs).audiodevsout._buffer[_ORBIT_tmpvar_2])
			 * (*devs).audiodevsout._length);
	       memcpy(_ORBIT_t, ((*devs).audiodevsout._buffer),
		      sizeof((*devs).audiodevsout._buffer[_ORBIT_tmpvar_2]) *
		      (*devs).audiodevsout._length);
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*devs).audiodevsout.
						     _buffer[_ORBIT_tmpvar_2])
					      * (*devs).audiodevsout._length);
	    }
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } 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(devs);
   }
}
void
_ORBIT_skel_Trx_Control_ChannelAccessGetConfig(POA_Trx_Control *
					       _ORBIT_servant,
					       GIOPRecvBuffer *
					       _ORBIT_recv_buffer,
					       CORBA_Environment * ev,
					       void
					       (*_impl_ChannelAccessGetConfig)
					       (PortableServer_Servant
						_servant,
						Trx_ChannelAccessConfig * cfg,
						CORBA_Environment * ev))
{
   Trx_ChannelAccessConfig cfg;

   {				/* 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_ChannelAccessGetConfig(_ORBIT_servant, &(cfg), 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) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(cfg),
					   sizeof(cfg));
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_ChannelAccessSetConfig(POA_Trx_Control *
					       _ORBIT_servant,
					       GIOPRecvBuffer *
					       _ORBIT_recv_buffer,
					       CORBA_Environment * ev,
					       void
					       (*_impl_ChannelAccessSetConfig)
					       (PortableServer_Servant
						_servant,
						const Trx_ChannelAccessConfig
						* cfg,
						CORBA_Environment * ev))
{
   Trx_ChannelAccessConfig cfg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (cfg.txdelay))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.slottime))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.ppersistence))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.txtail))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 cfg.fullduplex = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 memcpy(&(cfg), _ORBIT_curptr, sizeof(cfg));
      }
   }
   _impl_ChannelAccessSetConfig(_ORBIT_servant, &(cfg), 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 if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_InterfaceGetConfig(POA_Trx_Control * _ORBIT_servant,
					   GIOPRecvBuffer *
					   _ORBIT_recv_buffer,
					   CORBA_Environment * ev,
					   void (*_impl_InterfaceGetConfig)
					   (PortableServer_Servant _servant,
					    Trx_InterfaceConfig * cfg,
					    CORBA_Environment * ev))
{
   Trx_InterfaceConfig cfg;

   {				/* 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_InterfaceGetConfig(_ORBIT_servant, &(cfg), 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;
	    register CORBA_unsigned_long _ORBIT_tmpvar_2;
	    register CORBA_unsigned_long _ORBIT_tmpvar_3;
	    register CORBA_unsigned_long _ORBIT_tmpvar_4;
	    register CORBA_unsigned_long _ORBIT_tmpvar_5;
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    register CORBA_unsigned_long _ORBIT_tmpvar_7;

	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (cfg.ifname),
					   sizeof(cfg.
						  ifname[_ORBIT_tmpvar_0]) *
					   16);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (cfg.hwaddr),
					   sizeof(cfg.
						  hwaddr[_ORBIT_tmpvar_1]) *
					   16);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (cfg.ipaddr),
					   sizeof(cfg.
						  ipaddr[_ORBIT_tmpvar_2]) *
					   4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (cfg.netmask),
					   sizeof(cfg.
						  netmask[_ORBIT_tmpvar_3]) *
					   4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (cfg.broadcast),
					   sizeof(cfg.
						  broadcast[_ORBIT_tmpvar_4])
					   * 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (cfg.gwhwaddr),
					   sizeof(cfg.
						  gwhwaddr[_ORBIT_tmpvar_5]) *
					   128);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (cfg.gwipaddr),
					   sizeof(cfg.
						  gwipaddr[_ORBIT_tmpvar_6]) *
					   4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (cfg.gwnetmask),
					   sizeof(cfg.
						  gwnetmask[_ORBIT_tmpvar_7])
					   * 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(cfg.gwipmode),
					   sizeof(cfg.gwipmode));
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_InterfaceSetConfig(POA_Trx_Control * _ORBIT_servant,
					   GIOPRecvBuffer *
					   _ORBIT_recv_buffer,
					   CORBA_Environment * ev,
					   void (*_impl_InterfaceSetConfig)
					   (PortableServer_Servant _servant,
					    const Trx_InterfaceConfig * cfg,
					    CORBA_Environment * ev))
{
   Trx_InterfaceConfig cfg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_8;
      register CORBA_unsigned_long _ORBIT_tmpvar_9;
      register CORBA_unsigned_long _ORBIT_tmpvar_10;
      register CORBA_unsigned_long _ORBIT_tmpvar_11;
      register CORBA_unsigned_long _ORBIT_tmpvar_12;
      register CORBA_unsigned_long _ORBIT_tmpvar_13;
      register CORBA_unsigned_long _ORBIT_tmpvar_14;
      register CORBA_unsigned_long _ORBIT_tmpvar_15;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 memcpy(cfg.ifname, _ORBIT_curptr,
		sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16);
	 _ORBIT_curptr += sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16;
	 memcpy(cfg.hwaddr, _ORBIT_curptr,
		sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16);
	 _ORBIT_curptr += sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16;
	 memcpy(cfg.ipaddr, _ORBIT_curptr,
		sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4);
	 _ORBIT_curptr += sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4;
	 memcpy(cfg.netmask, _ORBIT_curptr,
		sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4);
	 _ORBIT_curptr += sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4;
	 memcpy(cfg.broadcast, _ORBIT_curptr,
		sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4);
	 _ORBIT_curptr += sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4;
	 memcpy(cfg.gwhwaddr, _ORBIT_curptr,
		sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128);
	 _ORBIT_curptr += sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128;
	 memcpy(cfg.gwipaddr, _ORBIT_curptr,
		sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4);
	 _ORBIT_curptr += sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4;
	 memcpy(cfg.gwnetmask, _ORBIT_curptr,
		sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4);
	 _ORBIT_curptr += sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4;
	 cfg.gwipmode = *((CORBA_char *) _ORBIT_curptr);
      } else {
	 memcpy(cfg.ifname, _ORBIT_curptr,
		sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16);
	 _ORBIT_curptr += sizeof(cfg.ifname[_ORBIT_tmpvar_8]) * 16;
	 memcpy(cfg.hwaddr, _ORBIT_curptr,
		sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16);
	 _ORBIT_curptr += sizeof(cfg.hwaddr[_ORBIT_tmpvar_9]) * 16;
	 memcpy(cfg.ipaddr, _ORBIT_curptr,
		sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4);
	 _ORBIT_curptr += sizeof(cfg.ipaddr[_ORBIT_tmpvar_10]) * 4;
	 memcpy(cfg.netmask, _ORBIT_curptr,
		sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4);
	 _ORBIT_curptr += sizeof(cfg.netmask[_ORBIT_tmpvar_11]) * 4;
	 memcpy(cfg.broadcast, _ORBIT_curptr,
		sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4);
	 _ORBIT_curptr += sizeof(cfg.broadcast[_ORBIT_tmpvar_12]) * 4;
	 memcpy(cfg.gwhwaddr, _ORBIT_curptr,
		sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128);
	 _ORBIT_curptr += sizeof(cfg.gwhwaddr[_ORBIT_tmpvar_13]) * 128;
	 memcpy(cfg.gwipaddr, _ORBIT_curptr,
		sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4);
	 _ORBIT_curptr += sizeof(cfg.gwipaddr[_ORBIT_tmpvar_14]) * 4;
	 memcpy(cfg.gwnetmask, _ORBIT_curptr,
		sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4);
	 _ORBIT_curptr += sizeof(cfg.gwnetmask[_ORBIT_tmpvar_15]) * 4;
	 cfg.gwipmode = *((CORBA_char *) _ORBIT_curptr);
      }
   }
   _impl_InterfaceSetConfig(_ORBIT_servant, &(cfg), 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 if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_ModemDisconnectGetConfig(POA_Trx_Control *
						 _ORBIT_servant,
						 GIOPRecvBuffer *
						 _ORBIT_recv_buffer,
						 CORBA_Environment * ev,
						 void
						 (*_impl_ModemDisconnectGetConfig)
						 (PortableServer_Servant
						  _servant,
						  Trx_ModemDisconnectConfig *
						  cfg,
						  CORBA_Environment * ev))
{
   Trx_ModemDisconnectConfig cfg;

   {				/* 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_ModemDisconnectGetConfig(_ORBIT_servant, &(cfg), 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) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(cfg),
					   sizeof(cfg));
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_ModemDisconnectSetConfig(POA_Trx_Control *
						 _ORBIT_servant,
						 GIOPRecvBuffer *
						 _ORBIT_recv_buffer,
						 CORBA_Environment * ev,
						 void
						 (*_impl_ModemDisconnectSetConfig)
						 (PortableServer_Servant
						  _servant,
						  const
						  Trx_ModemDisconnectConfig *
						  cfg,
						  CORBA_Environment * ev))
{
   Trx_ModemDisconnectConfig cfg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (cfg.output))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.direction))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.rxc))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.txc))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (cfg.txd))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 memcpy(&(cfg), _ORBIT_curptr, sizeof(cfg));
      }
   }
   _impl_ModemDisconnectSetConfig(_ORBIT_servant, &(cfg), 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 if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_GetAudioState(POA_Trx_Control * _ORBIT_servant,
				      GIOPRecvBuffer * _ORBIT_recv_buffer,
				      CORBA_Environment * ev,
				      void (*_impl_GetAudioState)
				      (PortableServer_Servant _servant,
				       Trx_TrxAudioState * state,
				       CORBA_Environment * ev))
{
   Trx_TrxAudioState state;

   {				/* 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_GetAudioState(_ORBIT_servant, &(state), 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) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(state),
					   sizeof(state));
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_GetAudioMicSamples(POA_Trx_Control * _ORBIT_servant,
					   GIOPRecvBuffer *
					   _ORBIT_recv_buffer,
					   CORBA_Environment * ev,
					   void (*_impl_GetAudioMicSamples)
					   (PortableServer_Servant _servant,
					    const CORBA_unsigned_long ptr,
					    const CORBA_unsigned_long len,
					    Trx_TrxAudioSamples ** samples,
					    CORBA_Environment * ev))
{
   CORBA_unsigned_long ptr;
   CORBA_unsigned_long len;
   Trx_TrxAudioSamples *samples;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (ptr))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (len))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 ptr = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 len = *((CORBA_unsigned_long *) _ORBIT_curptr);
      }
   }
   _impl_GetAudioMicSamples(_ORBIT_servant, ptr, len, &(samples), 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;

	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof((*samples)._length));
	       memcpy(_ORBIT_t, &((*samples)._length),
		      sizeof((*samples)._length));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*samples)._length));
	    }
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t =
		  alloca(sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
			 (*samples)._length);
	       memcpy(_ORBIT_t, ((*samples)._buffer),
		      sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
		      (*samples)._length);
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*samples).
						     _buffer[_ORBIT_tmpvar_0])
					      * (*samples)._length);
	    }
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } 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(samples);
   }
}
void
_ORBIT_skel_Trx_Control_GetAudioSpkSamples(POA_Trx_Control * _ORBIT_servant,
					   GIOPRecvBuffer *
					   _ORBIT_recv_buffer,
					   CORBA_Environment * ev,
					   void (*_impl_GetAudioSpkSamples)
					   (PortableServer_Servant _servant,
					    const CORBA_unsigned_long ptr,
					    const CORBA_unsigned_long len,
					    Trx_TrxAudioSamples ** samples,
					    CORBA_Environment * ev))
{
   CORBA_unsigned_long ptr;
   CORBA_unsigned_long len;
   Trx_TrxAudioSamples *samples;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (ptr))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (len))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 ptr = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 len = *((CORBA_unsigned_long *) _ORBIT_curptr);
      }
   }
   _impl_GetAudioSpkSamples(_ORBIT_servant, ptr, len, &(samples), 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;

	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof((*samples)._length));
	       memcpy(_ORBIT_t, &((*samples)._length),
		      sizeof((*samples)._length));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*samples)._length));
	    }
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t =
		  alloca(sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
			 (*samples)._length);
	       memcpy(_ORBIT_t, ((*samples)._buffer),
		      sizeof((*samples)._buffer[_ORBIT_tmpvar_0]) *
		      (*samples)._length);
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof((*samples).
						     _buffer[_ORBIT_tmpvar_0])
					      * (*samples)._length);
	    }
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } 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(samples);
   }
}
void
_ORBIT_skel_Trx_Control_SetAudioDTMF(POA_Trx_Control * _ORBIT_servant,
				     GIOPRecvBuffer * _ORBIT_recv_buffer,
				     CORBA_Environment * ev,
				     void (*_impl_SetAudioDTMF)
				     (PortableServer_Servant _servant,
				      const CORBA_long ch,
				      CORBA_Environment * ev))
{
   CORBA_long ch;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (ch))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 ch = *((CORBA_long *) _ORBIT_curptr);
      }
   }
   _impl_SetAudioDTMF(_ORBIT_servant, ch, 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 if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_Trx_TrxError_struct,
		  (gpointer) _ORBIT_Trx_TrxError_marshal}, {CORBA_OBJECT_NIL,
							    NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_Trx_Control_SetAudioParams(POA_Trx_Control * _ORBIT_servant,
				       GIOPRecvBuffer * _ORBIT_recv_buffer,
				       CORBA_Environment * ev,
				       void (*_impl_SetAudioParams)
				       (PortableServer_Servant _servant,
					const Trx_TrxAudioParams * params,
					CORBA_Environment * ev))
{
   Trx_TrxAudioParams params;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (params.rfsquelch))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 params.audiosquelch = *((CORBA_boolean *) _ORBIT_curptr);
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 memcpy(&(params), _ORBIT_curptr, sizeof(params));
      }
   }
   _impl_SetAudioParams(_ORBIT_servant, &(params), 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 ORBitSkeleton
get_skel_Trx_Control(POA_Trx_Control * servant,
		     GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'B':
	switch (opname[1]) {
	  case 'a':
	     switch (opname[2]) {
	       case 'y':
		  switch (opname[3]) {
		    case 'c':
		       switch (opname[4]) {
			 case 'o':
			    switch (opname[5]) {
			      case 'm':
				 switch (opname[6]) {
				   case 'U':
				      switch (opname[7]) {
					case 'S':
					   switch (opname[8]) {
					     case 'B':
						switch (opname[9]) {
						  case 'A':
						     switch (opname[10]) {
						       case 'd':
							  switch (opname[11]) {
							    case 'a':
							       switch (opname
								       [12]) {
								 case 'p':
								    switch
								       (opname
									[13])
								      {
								      case 't':
									 switch
									    (opname
									     [14])
									   {
									   case 'e':
									      switch
										 (opname
										  [15])
										{
										case 'r':
										   switch
										      (opname
										       [16])
										     {
										     case 'G':
											switch
											   (opname
											    [17])
											  {
											  case 'e':
											     switch
												(opname
												 [18])
											       {
											       case 't':
												  switch
												     (opname
												      [19])
												    {
												    case 'A':
												       if (strcmp((opname + 20), "udioDevices"))
													  break;
												       *impl
													  =
													  (gpointer)
													  servant->
													  vepv->
													  Trx_Control_epv->
													  BaycomUSBAdapterGetAudioDevices;
												       return
													  (ORBitSkeleton)
													  _ORBIT_skel_Trx_Control_BaycomUSBAdapterGetAudioDevices;
												       break;
												    case 'C':
												       if (strcmp((opname + 20), "onfig"))
													  break;
												       *impl
													  =
													  (gpointer)
													  servant->
													  vepv->
													  Trx_Control_epv->
													  BaycomUSBAdapterGetConfig;
												       return
													  (ORBitSkeleton)
													  _ORBIT_skel_Trx_Control_BaycomUSBAdapterGetConfig;
												       break;
												    default:
												       break;
												  }
												  break;
											       default:
												  break;
											     }
											     break;
											  default:
											     break;
											}
											break;
										     case 'S':
											if (strcmp((opname + 17), "etConfig"))
											   break;
											*impl
											   =
											   (gpointer)
											   servant->
											   vepv->
											   Trx_Control_epv->
											   BaycomUSBAdapterSetConfig;
											return
											   (ORBitSkeleton)
											   _ORBIT_skel_Trx_Control_BaycomUSBAdapterSetConfig;
											break;
										     default:
											break;
										   }
										   break;
										default:
										   break;
									      }
									      break;
									   default:
									      break;
									 }
									 break;
								      default:
									 break;
								    }
								    break;
								 default:
								    break;
							       }
							       break;
							    default:
							       break;
							  }
							  break;
						       default:
							  break;
						     }
						     break;
						  default:
						     break;
						}
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     case 'C':
	switch (opname[1]) {
	  case 'h':
	     switch (opname[2]) {
	       case 'a':
		  switch (opname[3]) {
		    case 'n':
		       switch (opname[4]) {
			 case 'n':
			    switch (opname[5]) {
			      case 'e':
				 switch (opname[6]) {
				   case 'l':
				      switch (opname[7]) {
					case 'A':
					   switch (opname[8]) {
					     case 'c':
						switch (opname[9]) {
						  case 'c':
						     switch (opname[10]) {
						       case 'e':
							  switch (opname[11]) {
							    case 's':
							       switch (opname
								       [12]) {
								 case 's':
								    switch
								       (opname
									[13])
								      {
								      case 'G':
									 if (strcmp((opname + 14), "etConfig"))
									    break;
									 *impl
									    =
									    (gpointer)
									    servant->
									    vepv->
									    Trx_Control_epv->
									    ChannelAccessGetConfig;
									 return
									    (ORBitSkeleton)
									    _ORBIT_skel_Trx_Control_ChannelAccessGetConfig;
									 break;
								      case 'S':
									 if (strcmp((opname + 14), "etConfig"))
									    break;
									 *impl
									    =
									    (gpointer)
									    servant->
									    vepv->
									    Trx_Control_epv->
									    ChannelAccessSetConfig;
									 return
									    (ORBitSkeleton)
									    _ORBIT_skel_Trx_Control_ChannelAccessSetConfig;
									 break;
								      default:
									 break;
								    }
								    break;
								 default:
								    break;
							       }
							       break;
							    default:
							       break;
							  }
							  break;
						       default:
							  break;
						     }
						     break;
						  default:
						     break;
						}
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     case 'G':
	switch (opname[1]) {
	  case 'e':
	     switch (opname[2]) {
	       case 't':
		  switch (opname[3]) {
		    case 'A':
		       switch (opname[4]) {
			 case 'u':
			    switch (opname[5]) {
			      case 'd':
				 switch (opname[6]) {
				   case 'i':
				      switch (opname[7]) {
					case 'o':
					   switch (opname[8]) {
					     case 'M':
						if (strcmp
						    ((opname + 9),
						     "icSamples"))
						   break;
						*impl =
						   (gpointer) servant->vepv->
						   Trx_Control_epv->
						   GetAudioMicSamples;
						return (ORBitSkeleton)
						   _ORBIT_skel_Trx_Control_GetAudioMicSamples;
						break;
					     case 'S':
						switch (opname[9]) {
						  case 'p':
						     if (strcmp
							 ((opname + 10),
							  "kSamples"))
							break;
						     *impl =
							(gpointer) servant->
							vepv->
							Trx_Control_epv->
							GetAudioSpkSamples;
						     return (ORBitSkeleton)
							_ORBIT_skel_Trx_Control_GetAudioSpkSamples;
						     break;
						  case 't':
						     if (strcmp
							 ((opname + 10),
							  "ate"))
							break;
						     *impl =
							(gpointer) servant->
							vepv->
							Trx_Control_epv->
							GetAudioState;
						     return (ORBitSkeleton)
							_ORBIT_skel_Trx_Control_GetAudioState;
						     break;
						  default:
						     break;
						}
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    case 'D':
		       if (strcmp((opname + 4), "escription"))
			  break;
		       *impl =
			  (gpointer) servant->vepv->Trx_Control_epv->
			  GetDescription;
		       return (ORBitSkeleton)
			  _ORBIT_skel_Trx_Control_GetDescription;
		       break;
		    case 'S':
		       if (strcmp((opname + 4), "tate"))
			  break;
		       *impl =
			  (gpointer) servant->vepv->Trx_Control_epv->GetState;
		       return (ORBitSkeleton)
			  _ORBIT_skel_Trx_Control_GetState;
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     case 'I':
	switch (opname[1]) {
	  case 'n':
	     switch (opname[2]) {
	       case 't':
		  switch (opname[3]) {
		    case 'e':
		       switch (opname[4]) {
			 case 'r':
			    switch (opname[5]) {
			      case 'f':
				 switch (opname[6]) {
				   case 'a':
				      switch (opname[7]) {
					case 'c':
					   switch (opname[8]) {
					     case 'e':
						switch (opname[9]) {
						  case 'G':
						     if (strcmp
							 ((opname + 10),
							  "etConfig"))
							break;
						     *impl =
							(gpointer) servant->
							vepv->
							Trx_Control_epv->
							InterfaceGetConfig;
						     return (ORBitSkeleton)
							_ORBIT_skel_Trx_Control_InterfaceGetConfig;
						     break;
						  case 'S':
						     if (strcmp
							 ((opname + 10),
							  "etConfig"))
							break;
						     *impl =
							(gpointer) servant->
							vepv->
							Trx_Control_epv->
							InterfaceSetConfig;
						     return (ORBitSkeleton)
							_ORBIT_skel_Trx_Control_InterfaceSetConfig;
						     break;
						  default:
						     break;
						}
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     case 'M':
	switch (opname[1]) {
	  case 'o':
	     switch (opname[2]) {
	       case 'd':
		  switch (opname[3]) {
		    case 'e':
		       switch (opname[4]) {
			 case 'm':
			    switch (opname[5]) {
			      case 'D':
				 switch (opname[6]) {
				   case 'i':
				      switch (opname[7]) {
					case 's':
					   switch (opname[8]) {
					     case 'c':
						switch (opname[9]) {
						  case 'o':
						     switch (opname[10]) {
						       case 'n':
							  switch (opname[11]) {
							    case 'n':
							       switch (opname
								       [12]) {
								 case 'e':
								    switch
								       (opname
									[13])
								      {
								      case 'c':
									 switch
									    (opname
									     [14])
									   {
									   case 't':
									      switch
										 (opname
										  [15])
										{
										case 'G':
										   if (strcmp((opname + 16), "etConfig"))
										      break;
										   *impl
										      =
										      (gpointer)
										      servant->
										      vepv->
										      Trx_Control_epv->
										      ModemDisconnectGetConfig;
										   return
										      (ORBitSkeleton)
										      _ORBIT_skel_Trx_Control_ModemDisconnectGetConfig;
										   break;
										case 'S':
										   if (strcmp((opname + 16), "etConfig"))
										      break;
										   *impl
										      =
										      (gpointer)
										      servant->
										      vepv->
										      Trx_Control_epv->
										      ModemDisconnectSetConfig;
										   return
										      (ORBitSkeleton)
										      _ORBIT_skel_Trx_Control_ModemDisconnectSetConfig;
										   break;
										default:
										   break;
									      }
									      break;
									   default:
									      break;
									 }
									 break;
								      default:
									 break;
								    }
								    break;
								 default:
								    break;
							       }
							       break;
							    default:
							       break;
							  }
							  break;
						       default:
							  break;
						     }
						     break;
						  default:
						     break;
						}
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     case 'S':
	switch (opname[1]) {
	  case 'e':
	     switch (opname[2]) {
	       case 't':
		  switch (opname[3]) {
		    case 'A':
		       switch (opname[4]) {
			 case 'u':
			    switch (opname[5]) {
			      case 'd':
				 switch (opname[6]) {
				   case 'i':
				      switch (opname[7]) {
					case 'o':
					   switch (opname[8]) {
					     case 'D':
						if (strcmp
						    ((opname + 9), "TMF"))
						   break;
						*impl =
						   (gpointer) servant->vepv->
						   Trx_Control_epv->
						   SetAudioDTMF;
						return (ORBitSkeleton)
						   _ORBIT_skel_Trx_Control_SetAudioDTMF;
						break;
					     case 'P':
						if (strcmp
						    ((opname + 9), "arams"))
						   break;
						*impl =
						   (gpointer) servant->vepv->
						   Trx_Control_epv->
						   SetAudioParams;
						return (ORBitSkeleton)
						   _ORBIT_skel_Trx_Control_SetAudioParams;
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    case 'F':
		       if (strcmp((opname + 4), "requency"))
			  break;
		       *impl =
			  (gpointer) servant->vepv->Trx_Control_epv->
			  SetFrequency;
		       return (ORBitSkeleton)
			  _ORBIT_skel_Trx_Control_SetFrequency;
		       break;
		    case 'P':
		       if (strcmp((opname + 4), "TT"))
			  break;
		       *impl =
			  (gpointer) servant->vepv->Trx_Control_epv->SetPTT;
		       return (ORBitSkeleton) _ORBIT_skel_Trx_Control_SetPTT;
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     case 'U':
	switch (opname[1]) {
	  case 'a':
	     switch (opname[2]) {
	       case 'r':
		  switch (opname[3]) {
		    case 't':
		       switch (opname[4]) {
			 case 'R':
			    if (strcmp((opname + 5), "eceive"))
			       break;
			    *impl =
			       (gpointer) servant->vepv->Trx_Control_epv->
			       UartReceive;
			    return (ORBitSkeleton)
			       _ORBIT_skel_Trx_Control_UartReceive;
			    break;
			 case 'S':
			    if (strcmp((opname + 5), "end"))
			       break;
			    *impl =
			       (gpointer) servant->vepv->Trx_Control_epv->
			       UartSend;
			    return (ORBitSkeleton)
			       _ORBIT_skel_Trx_Control_UartSend;
			    break;
			 default:
			    break;
		       }
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_Trx_Control(CORBA_Object obj, POA_Trx_Control * servant)
{
   obj->vepv[Trx_Control__classid] = servant->vepv->Trx_Control_epv;
}

void
POA_Trx_Control__init(PortableServer_Servant servant, CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_Trx_Control, "IDL:Trx/Control:1.0",
(ORBit_local_objref_init) & init_local_objref_Trx_Control };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!Trx_Control__classid)
      Trx_Control__classid = ORBit_register_class(&class_info);
}

void
POA_Trx_Control__fini(PortableServer_Servant servant, CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}
