/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
/*
 * glu.h
 *
 * Andrew Schofield, Thursday, the 6th of October 1994
 *
 * $Id: glu_head.h 1.14 1997/12/18 08:57:26 nagler PACKAGED $
 *
 * The Graceland Utilities (GLU) are a set of routines to
 * facilitate the use of the Graceland Idiom.
 *
 * The following functions are used to prepare
 * an interface description for use by the other
 * GLU functions:
 *
 * - "GLU_INTERFACE_PREPARE"
 *
 * - "GLU_INTERFACE_PREPARE_LENGTH"
 *
 * The following functions are used to pack/unpack requests/responses:
 *
 * - "GLU_HEAD_UNPACK"
 *
 * - "GLU_REQUEST_PACK"
 *
 * - "GLU_REQUEST_HEADER_UNPACK_BY_REF"
 *
 * - "GLU_REQUEST_BODY_UNPACK"
 *
 * - "GLU_RESPONSE_PACK"
 *
 * - "GLU_RESPONSE_HEADER_UNPACK"
 *
 * The following functions are used to copy requests/responses in memory:
 *
 * - "GLU_REQUEST_COPY"
 *
 * - "GLU_RESPONSE_COPY"
 *
 * The following functions are used to pack/unpack encapsulated
 * service context data:
 *
 * - GLU_ENCAPSULATION_PACK
 *
 * - GLU_ENCAPSULATION_UNPACK
 *
 * The following functions are used to obtain information
 * about a prepared interface (e.g. for use by CEE):
 *
 * - "GLU_GET_NR_OPERATIONS"
 *
 * - "GLU_GET_NR_PARAMETERS"
 *
 * - "GLU_GET_OPERATION_ID"
 *
 * - "GLU_GET_OPERATION_INDEX"
 *
 * 
 * PARAMETER VECTORS ("pv")
 * 
 * GLU uses the concept of a "parameter vector" or, simply, "pv" to pass
 * arbitrary object call parameters.  Synchronous and asynchronous calls have
 * different "pv" formats.  The "synch" parameter to the request/response
 * un/pack calls defines this format.  To aid the explanation the values
 * and types for CEE Example #1 TIM::Now operation are used in the diagrams
 * below.  The order of the parameters is the same as they were defined
 * in the IDL.
 *
 * A synchronous "pv" has the same format in the client and the server as
 * follows (C types in parentheses): 
 *
 *  Index   Description
 *        +-------------------------------------------------+
 *      0 | Pointer to Operation Synopsis or NULL           |
 *        | (IDL_unsigned long *)                           |
 *        +-------------------------------------------------+
 *      1 | Pointer to pointer to Operation's Exception     |
 *        | (struct **TIM_Now_exc_)                         |
 *        +-------------------------------------------------+
 *      2 | Pointer to Operation Result or First Parameter  |
 *        | (TimeZoneDef *)                                 |
 *        +-------------------------------------------------+
 *      3 | Pointer to Next Parameter			    |
 *        | (IDL_string **)                                 |
 *        +-------------------------------------------------+
 *
 * In the above layout, note that the second parameter (IDL_string) is
 * passed by reference, hence the extra level of indirection.  The
 * operation's exception structure is always passed by reference.
 *
 * The "pv" for asynchronous clients and servers is different, because
 * it only contains those parameters which are essential to the particular
 * action.
 *
 * Asynchronous (!synch) "GLU_REQUEST_PACK" and "GLU_REQUEST_BODY_UNPACK"
 * parameter vector (pv) layout:
 * 
 *  Index   Description
 *        +-------------------------------------------------+
 *      0 | Pointer to Operation Synopsis or NULL           |
 *        | (IDL_unsigned long *)                           |
 *        +-------------------------------------------------+
 *      1 | Pointer to First "in" or "inout" Parameter      |
 *        | (TimeZoneDef *)                                 |
 *        +-------------------------------------------------+
 *
 * Asynchronous (!synch) "GLU_RESPONSE_PACK" and "GLU_RESPONSE_BODY_UNPACK"
 * parameter vector (pv) layout:
 * 
 *  Index   Description
 *        +-------------------------------------------------+
 *      0 | Pointer to Operation Synopsis or NULL           |
 *        | (IDL_unsigned long *)                           |
 *        +-------------------------------------------------+
 *      1 | Pointer to pointer to Operation's Exception     |
 *        | (struct **TIM_Now_exc_)                         |
 *        +-------------------------------------------------+
 *      2 | Pointer to Operation Result                     |
 *        | or First "in" or "inout" Parameter              |
 *        | (TimeZoneDef *)                                 |
 *        +-------------------------------------------------+
 * 
 * MESSAGE FORMATS
 * 
 * All GLU messages begin with a GLU_header_def as follows:
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *      0 | Magic Bytes: "GLU"                              |
 *        +-------------------------------------------------+
 *      4 | Version Bytes: "002"                            |
 *        +-------------------------------------------------+
 *      7 | Type Byte: 'Q', 'P', or 'C'                     |
 *        +-------------------------------------------------+
 *      8 | Total Msg Size: Big Endian ulong                |
 *        +-------------------------------------------------+
 *     12 | Request Id: Big Endian ulong                    |
 *        +-------------------------------------------------+
 *     16
 *
 * Cancel (type 'C') messages contain nothing but this header.
 * Request and Response messages are followed by an "encapsulation".
 * An encapsulation is an octet stream which begins with a
 * four-byte GLU_data_format_def as follows (offsets continued):
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *     17 | Integer Format Byte: 1 or 2                     |
 *        +-------------------------------------------------+
 *     18 | Char Format Byte: 65                            |
 *        +-------------------------------------------------+
 *     19 | Real Format Byte: 33 or 34                      |
 *        +-------------------------------------------------+
 *     20 | Pack Format Byte: 97                            |
 *        +-------------------------------------------------+
 *     21
 *
 * The various formats are defined in pcu.h.
 *
 * A GLU_response_header_def or GLU_request_header_def follows the
 * encapsulation data format description.  Unlike the GLU_header_def
 * which always contains big endian integers, integers contained in the
 * encapsulation are in the order defined by the GLU_data_format_def
 * that begins the encapsulation.  Therefore, in the following layouts
 * only the type of the integer is specified.
 *
 * The data in requests and responses is variable length.  The
 * following is the layout of the request from CEE Example #1.
 * For this example, there service context list is empty.
 * Service contexts are discussed later.
 *
 * The GLU_request_header_def for a "Now" request to the "TIME" object
 * is laid out as follows (offsets continued):
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *     21 | Service Context List Length: ulong (0)          |
 *        +-------------------------------------------------+
 *     25 | Object Id Length: ulong (4)                     |
 *        +-------------------------------------------------+
 *     29 | Object Id Chars: "TIME"                         |
 *        +-------------------------------------------------+
 *     33 | Operation Synopsis: long (1203756531)           |
 *        +-------------------------------------------------+
 *     37 | Operation Name Length: ulong (3)                |
 *        +-------------------------------------------------+
 *     41 | Operation Name Chars: "Now"                     |
 *        +-------------------------------------------------+
 *     44
 *
 * Immediately following the request come the "in" and "inout" parameters
 * in the order they were declared in the IDL file.  "TIM::Now" has one
 * in parameter, TimeZoneDef, an enum.  The parameters are laid out as
 * follows (offsets continued):
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *     21 | TimeZoneDef: GMT (0) or LOCAL (1)               |
 *        +-------------------------------------------------+
 *     25
 *
 * A GLU reply contains a GLU_header_def and an encapsulation.  The
 * encapsulation begins with a GLU_data_format_def as described above
 * and contains a GLU_response_header_def, a GLU_exception_def, and
 * the result (if any) followed by the "out" and "inout" parameters.
 * In the event of a user exception, the GLU_exception_def is followed
 * by the marshalled user exception.  A standard exception consists
 * solely of the GLU_exception_def.
 *
 * Again, a response is variable length.  In this case, there is
 * no service context list and a normal response of "11:11:11" is
 * shown.  The GLU_response_header_def follows (offsets continued
 * from GLU_data_format_def):
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *     21 | Service Context List Length: ulong (0)          |
 *        +-------------------------------------------------+
 *     25 | Response Status Byte: 0                         |
 *        +-------------------------------------------------+
 *     26
 *
 * The GLU_exception_def is laid out as follows (offsets continued):
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *     26 | exception_nr: long (0)                          |
 *        +-------------------------------------------------+
 *     30 | exception_detail: long (0)                      |
 *        +-------------------------------------------------+
 *     34
 *
 * The result and "out" and "inout" parameters follow.  In this case,
 * there is no result.  There is a single out parameter, an unbounded
 * string:
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *     26 | timeStr Length: ulong (8)                       |
 *        +-------------------------------------------------+
 *     30 | timeStr Chars: "11:11:11"                       |
 *        +-------------------------------------------------+
 *     38
 *
 * The Service Context is an unbound sequence of "tagged" sequences of octets.
 * A single element defines an implicit parameter associated with the request
 * or response.  A "tagged" sequence of octets is the term the OMG uses for a
 * type-specific datum.  The "tags" in this case are a "type" and some "flags".
 * The flags help the receiving ORB determine what to do with the datum without
 * actually having to unpack it.  In particular, if the "must use" flag isn't
 * set, the ORB is free to ignore the contents.  As new service context types
 * are added over time, older ORBs may not support (nor recognize) the new
 * facilities and therefore the ORB needs to know whether to accept or reject
 * the request based solely on the flags.  The "IOP" (CORBA/GIOP/IIOP/) flag
 * indicates the data is from another name space, managed by the OMG.  This
 * allows gateways to pass through uninterpretable service context elements.
 * The ultimate destination then can make a decision as to whether to accept or
 * reject the request.
 *
 * The layout of a Service Context List follows for the case of one
 * element which is 42 bytes long with type 13 and flags 0 (continued from
 * GLU_data_format_def):
 *
 * Absolute
 *  Offset  Description
 *        +-------------------------------------------------+
 *     21 | Service Context List Length: ulong (1)          |
 *        +-------------------------------------------------+
 *     25 | Service Context[0] Type: ulong (13)             |
 *        +-------------------------------------------------+
 *     29 | Service Context[0] Flags: ulong (0)             |
 *        +-------------------------------------------------+
 *     33 | Service Context[0] Data Length: ulong (42)      |
 *        +-------------------------------------------------+
 *     37 | Service Context[0] Data Bytes                   |
 *        +-------------------------------------------------+
 *     79
 *
 * A service context element (data) is an encapsulation.  As with all
 * encapsulations, it begins with a GLU_data_format_def.  The format of each
 * service context element may not necessarily be the same as the format of the
 * rest of the request or response header and body.  This allows gateways to
 * pass through the service context data without unpacking it.  The function
 * GLU_ENCAPSULATION_UNPACK first unpacks the GLU_data_format_def and
 * the encapsulated data.
 */
#ifndef GLU_H
#define GLU_H

#ifdef __cplusplus
extern "C" {
#endif

#include <glu_rs.h>
#include <glu_stdexc.h>



#ifndef GLU_H_
#define GLU_H_
/*
 * Translation unit: GLU
 * Generated by CNPGEN(TANTAU CNPGEN TANTAU_AG_PC1 19991203.133909) on Mon Nov 20 10:39:05 2000
 */
#include <idltype.h>
#if IDL_TYPE_H_VERSION != 19971225
#error Version mismatch IDL_TYPE_H_VERSION != 19971225
#endif

/****************
 * Module 'GLU' *
 ****************/
#define GLU_INVALID_OPERATION_INDEX ((IDL_unsigned_long) 0)
struct GLU_exception_tag {
  IDL_long exception_nr;
  IDL_long exception_detail;
};
typedef struct GLU_exception_tag GLU_exception_def;
#define GLU_exception_def_cin_ ((char *) "b2+FF")
#define GLU_exception_def_csz_ ((IDL_unsigned_long) 5)
#define GLU_MAGIC_STRING ((IDL_string) "GLU ")
#define GLU_MAGIC_SIZE ((IDL_unsigned_long) 4)
#define GLU_VERSION_STRING ((IDL_string) "002")
#define GLU_VERSION_SIZE ((IDL_unsigned_long) 3)
struct GLU_header_tag {
  IDL_octet magic[4];
  IDL_octet version[3];
  IDL_octet type;
  IDL_unsigned_long size;
  IDL_unsigned_long request_id;
};
typedef struct GLU_header_tag GLU_header_def;
#define GLU_header_def_cin_ ((char *) "b5+a1+4+Ha1+3+HHKK")
#define GLU_header_def_csz_ ((IDL_unsigned_long) 18)
#define GLU_HEADER_SIZE ((IDL_unsigned_long) 16)
struct GLU_data_format_tag {
  IDL_octet integer;
  IDL_octet character;
  IDL_octet real;
  IDL_octet pack;
};
typedef struct GLU_data_format_tag GLU_data_format_def;
#define GLU_data_format_def_cin_ ((char *) "b4+HHHH")
#define GLU_data_format_def_csz_ ((IDL_unsigned_long) 7)
#define GLU_DATA_FORMAT_SIZE ((IDL_unsigned_long) 4)
struct GLU_service_context_tag {
  IDL_unsigned_long type;
  IDL_unsigned_long flags;
  struct GLU_service_context_tag_data_seq_ {
    IDL_unsigned_long _length;
    char pad_to_offset_8_[4];
    IDL_octet *_buffer;
    IDL_PTR_PAD(_buffer, 1)
  } data;
};
typedef struct GLU_service_context_tag GLU_service_context_def;
#define GLU_service_context_def_cin_ ((char *) "b3+KKc0+H")
#define GLU_service_context_def_csz_ ((IDL_unsigned_long) 9)
typedef struct GLU_service_context_list_def_seq_ {
  IDL_unsigned_long _length;
  char pad_to_offset_8_[4];
  GLU_service_context_def *_buffer;
  IDL_PTR_PAD(_buffer, 1)
} GLU_service_context_list_def;
#define GLU_service_context_list_def_cin_ ((char *) "c0+b3+KKc0+H")
#define GLU_service_context_list_def_csz_ ((IDL_unsigned_long) 12)
#define GLU_SERVICE_CONTEXT_FLAG_MUST_USE ((IDL_unsigned_long) 1)
#define GLU_SERVICE_CONTEXT_FLAG_IOP ((IDL_unsigned_long) 2)
#define GLU_TYPE_REQUEST ((IDL_char) 'Q')
struct GLU_request_header_tag {
  GLU_service_context_list_def service_context_list;
  struct GLU_request_header_tag_oid_seq_ {
    IDL_unsigned_long _length;
    char pad_to_offset_8_[4];
    IDL_char *_buffer;
    IDL_PTR_PAD(_buffer, 1)
  } oid;
  IDL_unsigned_long op_synopsis;
  char pad_to_offset_40_[4];
  struct GLU_request_header_tag_op_name_seq_ {
    IDL_unsigned_long _length;
    char pad_to_offset_8_[4];
    IDL_char *_buffer;
    IDL_PTR_PAD(_buffer, 1)
  } op_name;
};
typedef struct GLU_request_header_tag GLU_request_header_def;
#define GLU_request_header_def_cin_ ((char *) "b4+c0+b3+KKc0+Hc0+CKc0+C")
#define GLU_request_header_def_csz_ ((IDL_unsigned_long) 24)
typedef struct GLU_request_context_def_seq_ {
  IDL_unsigned_long _length;
  char pad_to_offset_8_[4];
  IDL_string *_buffer;
  IDL_PTR_PAD(_buffer, 1)
} GLU_request_context_def;
#define GLU_request_context_def_cin_ ((char *) "c0+d0+")
#define GLU_request_context_def_csz_ ((IDL_unsigned_long) 6)
#define GLU_TYPE_RESPONSE ((IDL_char) 'P')
struct GLU_response_header_tag {
  GLU_service_context_list_def service_context_list;
  IDL_octet status;
  char pad_to_size_24_[7];
};
typedef struct GLU_response_header_tag GLU_response_header_def;
#define GLU_response_header_def_cin_ ((char *) "b2+c0+b3+KKc0+HH")
#define GLU_response_header_def_csz_ ((IDL_unsigned_long) 16)
#define GLU_RESPONSE_STATUS_NONE ((IDL_unsigned_long) 0)
#define GLU_TYPE_REQUEST_CANCEL ((IDL_char) 'C')
/* End module: GLU */
/*
 * End translation unit: GLU
 */
#endif /* GLU_H_ */
/*
 * "GLU_PV_*" lays out a parameter vector.
 */
#define GLU_PV_SYNOPSIS			0
#define GLU_PV_EXCEPTION		(GLU_PV_SYNOPSIS + 1)
#define GLU_PV_ASYNCH_REQUEST_PARAM1	(GLU_PV_SYNOPSIS + 1)
#define GLU_PV_ASYNCH_RESPONSE_PARAM1	(GLU_PV_EXCEPTION + 1)
#define GLU_PV_SYNCH_PARAM1		GLU_PV_ASYNCH_RESPONSE_PARAM1

/*
 *
 * "GLU_INDEX_PARAMETER1" is the index of the first parameter.
 */
#define GLU_INDEX_PARAMETER1		1

/*
 *
 * "GLU_INDEX_OPERATION1" is the index of the first operation.
 */
#define GLU_INDEX_OPERATION1		1

/*
 *
 * "GLU_INDEX_EXCEPTION1" is the index of the first exception.
 */
#define GLU_INDEX_EXCEPTION1		1

/*
 * "GLU_GET_EXCEPTION_BY_REF" gets a exceptions name, direction, and
 * type (prep) given an operation index and except_index
 * (GLU_INDEX_EXCEPTION1 is first).
 *
 * <prep>               	contains the prepared CIN description as
 *				returned by "GLU_INTERFACE_PREPARE".
 *
 * <operation_index>    	which operation
 *
 * <except_index>		which exception
 * 				(starts with GLU_INDEX_EXCEPTION1)
 *
 * <except_id>			gets address of exception id in "prep"
 *
 * <except_id_len>		length of "*except_id"
 *
 * <except_pcu_prep>		gets the address of the PCU_PREPAREd cin
 *
 * <except_pcu_prep_len>	length of "except_pcu_prep" 
 */
extern GLU_status
GLU_GET_EXCEPTION_BY_REF(
  /* In  */ const void      		      	       *prep,
  /* In  */ IDL_unsigned_long           		operation_index,
  /* In  */ IDL_unsigned_long           		except_index,
  /* Out */ const char      	       		      **except_id,
  /* Out */ IDL_unsigned_long			       *except_id_len,
  /* Out */ const void				      **except_pcu_prep,
  /* Out */ IDL_unsigned_long			       *except_pcu_prep_len
  );

/*
 * "GLU_GET_INTERFACE_ID_BY_REF" is used to obtain the interface's ID.
 *
 * <prep>               	contains the prepared CIN description as 
 *                      	returned by "GLU_INTERFACE_PREPARE".
 *
 * <interface_id>		gets the address of the interface's ID
 *
 * <interface_id_len>    	length of "id"
 */
extern GLU_status
GLU_GET_INTERFACE_ID_BY_REF(
  /* In  */ const void      		      	       *prep,
  /* Out */ const char      	       		      **interface_id,
  /* Out */ IDL_unsigned_long  	        	       *interface_id_len);

/*
 * "GLU_GET_NR_EXCEPTIONS" is used to find out how many exceptions
 * an operation has. "GLU_GET_NR_EXCEPTIONS" returns
 * GLU_SUCCESS or a value indicating the reason for the failure.
 *
 * <prep>          	contains the prepared CIN description as returned by
 *                 	"GLU_INTERFACE_PREPARE".
 *
 * <operation_index>    specifies the operation whose exception count
 *                      is required.
 *                      Constants are generated for each operation
 *                      (suffix "_ldx_").
 *
 * <nr_exceptions>      gets the number of exceptions.
 */
extern GLU_status
GLU_GET_NR_EXCEPTIONS(
  /* In  */ const void  	       		       *prep,
  /* In  */ IDL_unsigned_long				operation_index,
  /* Out */ IDL_unsigned_long         		       *nr_exceptions);

/*
 * "GLU_GET_NR_OPERATIONS" is used to find out how many operations
 * are contained in an interface. "GLU_GET_NR_OPERATIONS" returns
 * GLU_SUCCESS or a value indicating the reason for the failure.
 *
 * <prep>          contains the prepared CIN description as returned by
 *                 "GLU_INTERFACE_PREPARE".
 *
 * <nr_operations> gets the number of operations in the interface.
 */
extern GLU_status
GLU_GET_NR_OPERATIONS(
  /* In  */ const void      	       		       *prep,
  /* Out */ IDL_unsigned_long         		       *nr_operations);

/*
 * "GLU_GET_NR_PARAMETERS" is used to find out how many parameters
 * an operation has. "GLU_get_nr_parameters" returns
 * GLU_SUCCESS or a value indicating the reason for the failure.
 *
 * <prep>          	contains the prepared CIN description as returned by
 *                 	"GLU_INTERFACE_PREPARE".
 *
 * <operation_index>    specifies the operation whose parameter count
 *                      is required.
 *                      Constants are generated for each operation
 *                      (suffix "_ldx_").
 *
 * <nr_parameters>      gets the number of parameters.
 *
 *
 *
 */
extern GLU_status
GLU_GET_NR_PARAMETERS(
  /* In  */ const void  	       		       *prep,
  /* In  */ IDL_unsigned_long				operation_index,
  /* Out */ IDL_unsigned_long         		       *nr_parameters);

/*
 * "GLU_GET_OPERATION_ID_BY_REF" is used to obtain an operation's ID and
 * synopsis given its index. "GLU_GET_OPERATION_ID_BY_REF" and
 * "GLU_GET_OPERATION_INDEX" can be used to match operations between
 * two different interfaces (for intracapsule calls).
 * "GLU_GET_OPERATION_ID_BY_REF" returns GLU_SUCCESS or a value indicating
 * the reason for the failure.
 *
 * <prep>               contains the prepared CIN description as returned
 *                      by "GLU_INTERFACE_PREPARE".
 *
 * <operation_index>    specifies the operation whose ID is required.
 *                      Constants are generated for each operation
 *                      (suffix "_ldx_").
 *
 * <operation_id>       gets the address of the operation's ID
 *
 * <operation_id_len>   length of operation_id (ignored if NULL)
 *
 * <operation_synopsis> gets the operation's synopsis.
 */
extern GLU_status
GLU_GET_OPERATION_ID_BY_REF(
  /* In  */ const void      		      	       *prep,
  /* In  */ IDL_unsigned_long           		operation_index,
  /* Out */ const char      	       		      **operation_id,
  /* Out  */ IDL_unsigned_long           	       *operation_id_len,
  /* Out */ IDL_long        	        	       *operation_synopsis);

/*
 * "GLU_GET_OPERATION_INDEX" gets an operation's index given its
 * ID and synopsis."GLU_GET_OPERATION_ID_BY_REF" and
 * "GLU_GET_OPERATION_INDEX" can be used to match operations between
 * two different interfaces (for intracapsule calls).
 * "GLU_GET_OPERATION_INDEX" returns
 * GLU_SUCCESS or a value indicating the reason for the failure.
 *
 * <prep>               contains the prepared CIN description as returned by
 *                     "GLU_INTERFACE_PREPARE".
 *
 * <operation_id>    	is the ID of the operation whose index is required.
 *
 * <operation_synopsis> is the synopsis of the operation whose index
 *                      is required.
 *
 * <operation_index>    gets the operations index.
 */
extern GLU_status
GLU_GET_OPERATION_INDEX(
  /* In  */ const void        	       		       *prep,
  /* In  */ const char      	       		       *operation_id,
  /* In  */ IDL_long         				operation_synopsis,
  /* Out */ IDL_unsigned_long 	       		       *operation_index);

/*
 * "GLU_GET_PARAMETER_BY_REF" gets a parameters name, direction, and
 * type (prep) given an operation index and param_index
 * (GLU_INDEX_PARAMETER1 is first).
 *
 * <prep>               	contains the prepared CIN description as
 *				returned by "GLU_INTERFACE_PREPARE".
 *
 * <operation_index>    	which operation
 *
 * <param_index>		which parameter
 * 				(starts with GLU_INDEX_PARAMETER1)
 *
 * <param_name>			gets address of parameter name in "prep"
 *
 * <param_name_len>		length of "*param_name"
 *
 * <param_direction>		one of the CIN_direction_* or
 *				CIN_function_result.  If there is a function
 *				result, it will be GLU_INDEX_PARAMETER1.
 *
 * <param_pcu_prep>		gets the address of the PCU_PREPAREd cin
 *
 * <param_pcu_prep_len>		length of "param_pcu_prep" 
 */
extern GLU_status
GLU_GET_PARAMETER_BY_REF(
  /* In  */ const void      		      	       *prep,
  /* In  */ IDL_unsigned_long           		operation_index,
  /* In  */ IDL_unsigned_long           		param_index,
  /* Out */ const char      	       		      **param_name,
  /* Out */ IDL_unsigned_long			       *param_name_len,
  /* Out */ char        	        	       *param_direction,
  /* Out */ const void				      **param_pcu_prep,
  /* Out */ IDL_unsigned_long			       *param_pcu_prep_len
  );

/*
 * "GLU_HEADER_UNPACK" unmarshals and validates the magic and version
 * of a GLU_header_def.
 *
 * <to_unpack_buf>	must pointer to a buffer which contains at least
 *			GLU_HEADER_SIZE bytes.  
 *
 * <header>   		all fields are set.
 */
extern GLU_status
GLU_HEADER_UNPACK(
  /* In    */ const IDL_octet			       *to_unpack_buf,
  /* Out   */ GLU_header_def			       *header);

/* Call this after you've packed the request/response_header and
   the body to pack the length, type, request_id, and data_format on
   the front of packed_buf. */
extern GLU_status
GLU_HEADER_PACK(
  /* In    */ IDL_unsigned_long 			request_id,
  /* In    */ char 					type,
  /* In    */ const GLU_data_format_def 	       *data_format,
  /* InOut */ IDL_octet 			       *packed_buf,
  /* In    */ IDL_unsigned_long 			packed_len
  );

/*
 * "GLU_INTERFACE_PREPARE" is used to prepare a CIN description
 * of an interface (generated by CNPGEN) for efficient use by
 * the other GLU routines.
 * "GLU_INTERFACE_PREPARE" returns
 * GLU_SUCCESS or a value indicating the reason for the failure.
 *
 * NOTE: Unlike PCU_PREPARE, "prep" may not be copied as it contains
 *       internal pointers.  To make a copy, call this routine again.
 *
 * <cinbuf>       is the generated CIN description of the interface.
 *
 * <cinlen>       is the size of CIN description contained in
 *                "cinbuf".
 *
 * <max_prep_len> is the maximum number of bytes that can be
 *                accommodated in "prep". The correct size can
 *                be obtained by calling "GLU_INTERFACE_PREPARE_length".
 *
 * <prep>         is the buffer to receive the prepared CIN.
 *
 * <prep_len> 	  gets the size of prepared CIN that will be
 *            	  produced by "GLU_INTERFACE_PREPARE".
 */
extern GLU_status
GLU_INTERFACE_PREPARE(
  /* In  */ const char        	       		       *cinbuf,
  /* In  */ IDL_unsigned_long  			  	cinlen,
  /* In  */ IDL_unsigned_long				max_prep_len,
  /* Out */ void              	       		       *prep,
  /* Out */ IDL_unsigned_long         		       *prep_len);

/*
 * "GLU_INTERFACE_PREPARE_LENGTH" is used to obtain the length of
 * the prepared interface description that will be produced by
 * "GLU_INTERFACE_PREPARE". This is useful if the memory for the
 * prepared description is to be allocated dynamically.
 * "GLU_INTERFACE_PREPARE_length" returns
 * GLU_SUCCESS or a value indicating the reason for the failure.
 *
 * <cinbuf>   is the generated CIN description of the interface.
 *
 * <cinlen>   is the size of CIN description contained in "cinbuf".
 *
 * <prep_len> gets the size of prepared CIN that will be
 *            produced by "GLU_INTERFACE_PREPARE".
 */
extern GLU_status
GLU_INTERFACE_PREPARE_LENGTH(
  /* In  */ const char  	       		       *cinbuf,
  /* In  */ IDL_unsigned_long        			cinlen,
  /* Out */ IDL_unsigned_long         		       *prep_len);

/*
 * "GLU_REQUEST_BODY_UNPACK" unpacks the parameters associated
 * with the request.  The "GLU_header_def" and "GLU_request_header_def"
 * must be unpacked by "GLU_HEADER_UNPACK" and
 * "GLU_REQUEST_HEADER_UNPACK_BY_REF", respectively.
 *
 * <data_format>		how to unmarshall the parameters.
 *				This value was returned by 
 * 				"GLU_REQUEST_HEADER_UNPACK_BY_REF".
 *				If NULL and request_header is NULL,
 *                              "GLU_HEADER_UNPACK" and
 *				"GLU_REQUEST_HEADER_UNPACK_BY_REF" will
 *				be called implicitly.
 *
 * <request_header>		defines the operation whose parameters
 *                              are being unpacked.  This value was returned
 *				by "GLU_REQUEST_HEADER_UNPACK_BY_REF".
 *				If NULL and data_format is NULL,
 *                              "GLU_HEADER_UNPACK" and
 *				"GLU_REQUEST_HEADER_UNPACK_BY_REF" will
 *				be called implicitly.
 *
 * <prep>			the prepared CIN which was returned by
 * 				"GLU_INTERFACE_PREPARE".  This value should
 *				be related to "request_header->oid".
 *
 * <synch>			is this a synchronous or asynchronous object
 *				call?  This value controls the interpretation
 * 				of "pv".
 *
 * <pv_len_max>			maximum number of elements in "pv"
 *
 * <to_unpack_buf>		marshalled request parameters.  This pointer
 * 				should point just after the
 * 				"GLU_request_header_def".  This value should be
 * 				computed by adding the "to_unpack_buf" and
 * 				"to_unpack_used" values passed to/from
 * 				"GLU_REQUEST_HEADER_UNPACK_BY_REF".
 *				If "GLU_HEADER_UNPACK" and
 *                              "GLU_REQUEST_HEADER_UNPACK_BY_REF" are
 *				to be called implicitly (see above),
 *				"to_unpack_buf" should point to
 *				"GLU_header_def.
 * 				
 * <to_unpack_len>		size of "to_unpack_buf".  This value should be
 * 				computed by subtracting the "to_unpack_len" and
 * 				"to_unpack_used" values passed to/from 
 * 				"GLU_REQUEST_HEADER_UNPACK_BY_REF".  
 * 				
 * <unpacked_len_max>		size of "unpacked_data".  This value should be
 * 				computed by subtracting the "unpacked_len_max"
 * 				and "unpacked_len" values passed to/from 
 * 				"GLU_REQUEST_HEADER_UNPACK_BY_REF".
 * 				
 * <unpacked_data>		buffer to unpack the parameters into.
 *
 * <unpacked_len>		sizeof of "unpacked_data" consumed by
 * 				this routine.
 *
 * <pv>				where to place the pointers to the unpacked
 * 				parameters.  For a detailed description,
 * 			 	see the section "PARAMETER VECTORS".
 * 				
 * <local_op_idx>		the index of the operation specified in
 * 				"request_header".
 * 				
 * <=GLU_SHORTOUTBUF>		the message could not be unpacked, because
 * 				"unpacked_len_max" was smaller than the space
 *				required.  "unpacked_len" is contains the
 *				appropriate length.  Reallocate "unpacked_data"
 * 				to at least "unpacked_len" bytes.
 * 				
 * <=GLU_BADPREPBUF>		"prep" is invalid.  Either the memory
 * 				is corrupt or "GLU_INTERFACE_PREPARE" was
 *				not called.
 *
 * <=GLU_NOSUCHOP>		the operation specified in "request_header"
 *				could not be found.  Either the name was 
 * 				not found or the operation synopsis did not
 * 				match, i.e. the operation's type signature
 *				defined in "prep" is not the same as the
 *				type signature used to pack the request.
 * 				
 * <=GLU_SHORTPV>		"pv_len_max" is shorter than required to
 * 				unpack all the parameters for the operation.
 *				"*local_op_idx" is valid.  The correct size
 *				should be two plus the parameter count
 *				for the operation.  GLU_GET_NR_PARAMETERS
 *				may be called to get the parameter count.
 *				Note that the "result" is treated as an
 *				"out" parameter and need not be handled
 *				specially.
 * 				
 * <=GLU_LONGINBUF>		the message was unpacked successfully, but
 *				"to_unpack_len" was greater than the data
 *				required to successfully unmarshal the
 * 				request.  This is probably a protocol
 * 				violation. 
 * 				
 * <=GLU_SHORTINBUF>		the message could not be unpacked, because
 * 				"to_unpack_len" was smaller than the data
 *				required.  This is probably a protocol
 * 				violation. 
 * 				
 * <=GLU_BADSEQSIZE>		while unmarshalling a parameter or exception,
 * 				a bounded sequence was encountered the
 *				length of which was greater than the bound.
 *				This is probably a protocol violation, because
 *				the sending ORB should have checked the length.
 * 				
 * <=GLU_BADSEQSIZE>		while unmarshalling a parameter or exception,
 * 				a bounded string was encountered the
 *				length of which was greater than the bound.
 *				This is probably a protocol violation, because
 *				the sending ORB should have checked the length.
 * 				
 * <=GLU_UNIMPLCONV>		while unmarshalling a parameter or exception,
 * 				a data type was encountered that could not
 *				be converted to the native format.  This is
 *				likely to be caused by a conversion between
 *				two different floating point (real) formats.
 *				For example, the client sent a NaN in IEEE
 *				format and the server's native format is
 *				Tandem format which doesn't have a
 * 				representation for NaN.
 *
 * <=GLU_NOTREQUEST>		the header type is not GLU_TYPE_REQUEST.
 * 				This status is only returned if
 *				"GLU_HEADER_DEF" is called implicitly.
 * 
 * <=GLU_UNKNOWN>		an unexpected PCU error occured.  This is
 *				probably a protocol violation.
 */
extern GLU_status
GLU_REQUEST_BODY_UNPACK(
  /* In  */ const GLU_data_format_def		       *data_format,
  /* In  */ const GLU_request_header_def	       *request_header,
  /* In  */ const void     	       		       *prep,
  /* In  */ IDL_boolean       				synch,
  /* In  */ IDL_unsigned_long 				pv_len_max,
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_len_max,
  /* Out */ void				       *unpacked_data,
  /* Out */ IDL_unsigned_long			       *unpacked_len,
  /* Out */ void            			      **pv,
  /* Out */ IDL_unsigned_long 			       *local_op_idx);

extern GLU_status
GLU_REQUEST_COPY(
  /* In  */ const void      			       *prep,
  /* In  */ IDL_unsigned_long            		local_op_idx,
  /* In  */ IDL_boolean					synch_impl,
  /* In  */ const void *const 			       *pv,
  /* In  */ IDL_unsigned_long				max_msglen,
  /* Out */ void            			       *msgbuf,
  /* Out */ IDL_unsigned_long 			       *msglen);

/* If SHORTOUTBUF, then everything unpacked except service context */
extern GLU_status
GLU_REQUEST_HEADER_UNPACK_BY_REF(
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_len_max,
  /* Out */ void				       *unpacked_data,
  /* Out */ IDL_unsigned_long			       *unpacked_len,
  /* Out */ GLU_data_format_def		       	       *data_format,
  /* Out */ GLU_request_header_def		       *request_header,
  /* Out */ IDL_unsigned_long			       *to_unpack_used);

extern GLU_status
GLU_REQUEST_PACK(
  /* In  */ IDL_unsigned_long				request_id,
  /* In  */ const GLU_service_context_list_def	       *service_context_list,
  /* In  */ const char				       *oid,
  /* In  */ IDL_unsigned_long			        oid_len,
  /* In  */ const void      	       		       *prep,
  /* In  */ IDL_unsigned_long 				local_op_idx,
  /* In  */ IDL_boolean      				synch,
  /* In  */ const void *const 	       		       *pv,
  /* In  */ IDL_unsigned_long				packed_len_max,
  /* Out */ IDL_octet         	       		       *packed_buf,
  /* Out */ IDL_unsigned_long 	       		       *packed_len);

/* If data_format AND response_header are NULL,
   GLU_RESPONSE_HEADER_UNPACK_BY_REF will be called. */
extern GLU_status
GLU_RESPONSE_BODY_UNPACK(
  /* In  */ const GLU_data_format_def		       *data_format,
  /* In  */ const GLU_response_header_def	       *response_header,
  /* In  */ const void     	       		       *prep,
  /* In  */ IDL_unsigned_long 			        local_op_idx,
  /* In  */ IDL_boolean       				synch,
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_len_max,
  /* Out */ void				       *unpacked_data,
  /* Out */ IDL_unsigned_long			       *unpacked_len,
  /* Out */ void            			      **pv);

extern GLU_status
GLU_RESPONSE_COPY(
  /* In  */ const void      			       *prep,
  /* In  */ IDL_unsigned_long            		local_op_idx,
  /* In  */ IDL_boolean           			synch_impl,
  /* In  */ const void *const 			       *pv,
  /* In  */ IDL_unsigned_long				max_msglen,
  /* Out */ void            			       *msgbuf,
  /* Out */ IDL_unsigned_long			       *msglen);


/* If SHORTOUTBUF, then everything unpacked except service context */
extern GLU_status
GLU_RESPONSE_HEADER_UNPACK_BY_REF(
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_len_max,
  /* Out */ void				       *unpacked_data,
  /* Out */ IDL_unsigned_long			       *unpacked_len,
  /* Out */ GLU_data_format_def		       	       *data_format,
  /* Out */ GLU_response_header_def		       *response_header,
  /* Out */ IDL_unsigned_long			       *to_unpack_used);

extern GLU_status
GLU_RESPONSE_PACK(
  /* In  */ IDL_unsigned_long				request_id,
  /* In  */ const GLU_service_context_list_def	       *service_context_list,
  /* In  */ char			        	status,
  /* In  */ const void      	       		       *prep,
  /* In  */ IDL_unsigned_long 				local_op_idx,
  /* In  */ IDL_boolean      				synch,
  /* In  */ const void *const 	       		       *pv,
  /* In  */ IDL_unsigned_long				packed_len_max,
  /* Out */ IDL_octet          	       		       *packed_buf,
  /* Out */ IDL_unsigned_long 	       		       *packed_len);

extern GLU_status
GLU_ENCAPSULATION_PACK(
  /* In  */ void				       *pcu_prep,
  /* In  */ void				       *to_pack_data,
  /* In  */ IDL_unsigned_long			       	packed_len_max,
  /* Out */ IDL_octet				       *packed_buf,
  /* Out */ IDL_unsigned_long			       *packed_len);

extern GLU_status
GLU_ENCAPSULATION_UNPACK(
  /* In  */ void				       *pcu_prep,
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_len_max,
  /* Out */ void				       *unpacked_data,
  /* Out */ IDL_unsigned_long			       *unpacked_len);

extern GLU_status
GLU_ENCAPSULATION_UNPACK_SCATTER(
  /* In  */ void				       *pcu_prep,
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_app_len_max,
  /* Out */ void				       *unpacked_base,
  /* Out */ void				       *unpacked_appendages,
  /* Out */ IDL_unsigned_long			       *unpacked_app_len);

/*
 * "GLU_STATUS_TO_TEXT" returns the address of a string
 * containing a description of the specified GLU status.
 * 
 * <sts>             is the return status code whose description is required.
 *
 * <=descr>          is the address of a zero terminated string containing
 *                   a description of "sts" 
 */
extern char *
GLU_STATUS_TO_TEXT(
  /* In  */ GLU_status  				sts);

/*
 * "GLU_STDEXC_TO_TEXT" returns the address of a string
 * containing a description of the specified standard exception number.
 * 
 * <exnr>             is the exception number whose description is required.
 *
 * <=descr>          is the address of a zero terminated string containing
 *                   a description of "exnr" 
 */
extern char *
GLU_STDEXC_TO_TEXT(
  /* In  */ GLU_exception_nr  		     		exnr);

extern GLU_status
GLU_STRUCT_REQUEST_PACK(
  /* In  */ IDL_unsigned_long				request_id,
  /* In  */ const GLU_service_context_list_def	       *service_context_list,
  /* In  */ const char				       *oid,
  /* In  */ IDL_unsigned_long			        oid_len,
  /* In  */ const void      	       		       *prep,
  /* In  */ IDL_unsigned_long 				local_op_idx,
  /* In  */ const void		 	       	       *to_pack_data,
  /* In  */ IDL_unsigned_long				packed_len_max,
  /* Out */ void            	       		       *packed_buf,
  /* Out */ IDL_unsigned_long 	       		       *packed_len);

extern GLU_status
GLU_STRUCT_REQUEST_BODY_UNPACK(
  /* In  */ const GLU_data_format_def		       *data_format,
  /* In  */ const GLU_request_header_def	       *request_header,
  /* In  */ const void      	       		       *prep,
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_len_max,
  /* Out */ void				       *unpacked_data,
  /* Out */ IDL_unsigned_long			       *unpacked_len,
  /* Out */ IDL_unsigned_long 			       *local_op_idx);

extern GLU_status
GLU_STRUCT_RESPONSE_PACK(
  /* In  */ IDL_unsigned_long				request_id,
  /* In  */ const GLU_service_context_list_def	       *service_context_list,
  /* In  */ char			        	status,
  /* In  */ const void      	       		       *prep,
  /* In  */ IDL_unsigned_long 				local_op_idx,
  /* In  */ const void		 	       	       *to_pack_data,
  /* In  */ IDL_unsigned_long				packed_len_max,
  /* Out */ void            	       		       *packed_buf,
  /* Out */ IDL_unsigned_long 	       		       *packed_len);


extern GLU_status
GLU_STRUCT_RESPONSE_BODY_UNPACK(
  /* In  */ const GLU_data_format_def		       *data_format,
  /* In  */ const GLU_response_header_def	       *response_header,
  /* In  */ const void      	       		       *prep,
  /* In  */ IDL_unsigned_long 				local_op_idx,
  /* In  */ const IDL_octet			       *to_unpack_buf,
  /* In  */ IDL_unsigned_long				to_unpack_len,
  /* In  */ IDL_unsigned_long			       	unpacked_len_max,
  /* Out */ void				       *unpacked_data,
  /* Out */ IDL_unsigned_long			       *unpacked_len);

#ifdef __cplusplus
}
#endif
#endif