with System;
with DCE_Base;
with DCE_Status;

package RPC is
-- ****************************************************************************
-- Package RPC provides Ada bindings to services in OSF's DCE RPC component.
-- ****************************************************************************

  type RPCBase_v0_0_0 is private;
  type RPC_Opaque_Ptr_Type is access RPCBase_v0_0_0;

  type RPC_Auth_Identity_Type is private;

  type Handle_Type is private;
  type RPC_Binding_Handle_Type is access Handle_Type;

  type Binding_Vector_Record_Type is private;
  type RPC_Binding_Vector_Type is access Binding_Vector_Record_Type;

  type RPC_EP_Inquiry_Handle_Type is private;

  type RPC_Interface_Handle_Type is new RPC_Opaque_Ptr_Type;

  type RPC_Interface_Id_Type is private;

  type RPC_Interface_Id_Vector_Type is private;

  type RPC_Manager_EPV_Type is private;

  type RPC_NS_Handle_Type is private;

  type RPC_Protseq_Vector_Type is private;

  type RPC_SS_Thread_Handle_Type is private;

  type RPC_Statistics_Vector_Type is private;

  type RPC_String_Binding_Type is private;

  type UUID_Type is private;

  type UUID_Array_Type is array (positive range <>) of UUID_Type;

  type UUID_Vector_Record_Type is private;
  type UUID_Vector_Type is access UUID_Vector_Record_Type;
  
  EP_Map_Annotation_Length : constant integer := 64;
  subtype EP_Map_Annotation_Type is string(1..EP_Map_Annotation_Length);

  NS_Entry_Name_Length : constant integer := 128;
  subtype NS_Entry_Name_Type is string(1..NS_Entry_Name_Length);

  NS_Expanded_Name_Length : constant integer := 128;
  subtype NS_Expanded_Name_Type is string(1..NS_Expanded_Name_Length);

  NS_Group_Name_Length : constant integer := 128;
  subtype NS_Group_Name_Type is string(1..NS_Group_Name_Length);

  NS_Member_Name_Length : constant integer := 128;
  subtype NS_Member_Name_Type is string(1..NS_Member_Name_Length);

  NS_Profile_Annotation_Length : constant integer := 17;
  subtype NS_Profile_Annotation_Type is string(1..NS_Profile_Annotation_Length);

  NS_Profile_Name_Length : constant integer := 128;
  subtype NS_Profile_Name_Type is string(1..NS_Profile_Name_Length);

  Principal_Name_Length : constant integer := 128;
  subtype Principal_Name_Type is string(1..Principal_Name_Length);

  Protocol_Sequence_Length : constant integer := 32;
  subtype Protocol_Sequence_Type is string(1..Protocol_Sequence_Length);

  NCACN_IP_TCP : constant Protocol_Sequence_Type
                   := "ncacn_ip_tcp" & Ascii.NUL & "                   ";

  NCADG_IP_UDP : constant Protocol_Sequence_Type
                   := "ncadg_ip_udp" & Ascii.NUL & "                   ";
 
  UUID_String_Length : constant natural := 37;
  subtype UUID_String_Type is string(1..UUID_String_Length);  

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_Binding_*  ////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_Binding_Handle_Display(
  Binding_Handle : in RPC_Binding_Handle_Type);
-- ****************************************************************************
-- Display the binding handle content.
--
-- Input:
--   Binding_Handle : Binding handle to display
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

procedure RPC_Binding_Copy(
  Source_Binding : in     RPC_Binding_Handle_Type;
  Dest_Binding   :    out RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Make a copy of the binding handle.
--
-- Input:
--   Source_Binding : Binding handle to copy
--
-- Output:
--   Dest_Binding : The returned binding handle copy
--
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_copy(
--          rpc_binding_handle_t src_binding_handle,
--          rpc_binding_handle_t *dst_binding_handle,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_Free(
  Binding_Handle : in out RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Free the binding handle resources.
--
-- Input/Output:
--   Binding_Handle : Binding handle to free. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_free(
--          rpc_binding_handle_t *binding_handle,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_from_String_Binding(
  String_Binding : in     RPC_String_Binding_Type;
  Binding_Handle :    out RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Return a binding handle from a string representation of a bindling handle.
--
-- Input:
--   String_Binding : The formatted string binding with delimiters
--
-- Output:
--   Binding_Handle : The new binding handle
--
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_arg
--     rpc_s_invalid_endpoint_format
--     rpc_s_invalid_rpc_protseq
--     rpc_s_invalid_string_binding
--     rpc_s_protseq_not_supported
--     uuid_s_bad_version
--     uuid_s_invalid_string_uuid
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_from_string_binding(
--          unsigned_char_t *string_binding,
--          rpc_binding_handle_t *binding_handle,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_Inq_Auth_Client(
  Binding_Handle    : in     RPC_Binding_Handle_Type;
  Privs             :    out System.Address;
  Server_Princ_Name :    out Principal_Name_Type;
  Protect_Level     :    out DCE_Base.RPC_Protect_Level_Type;
  Authn_Service     :    out DCE_Base.RPC_Authentication_Service_Type;
  Authz_Service     :    out DCE_Base.RPC_Authorization_Service_Type;
  Status            :    out DCE_Status.Status_Type;
  No_Server_Name    : in     boolean := FALSE;
  No_Protect_Level  : in     boolean := FALSE;
  No_Authn_Service  : in     boolean := FALSE;
  No_Authz_Service  : in     boolean := FALSE);
-- ****************************************************************************
-- Returns authentication and authorization information from an
-- AUTHENTICATED CLIENT binding handle.
--
-- Input:
--   Binding_Handle   : The CLIENT binding handle
--   No_Server_Name   : If TRUE, the server principal name is not returned
--   No_Protect_Level : If TRUE, the protection level is not returned
--   No_Authn_Service : If TRUE, the authentication service is not returned
--   No_Authz_Service : If TRUE, the authorization service is not returned
--
-- Output:
--   Privs :
--     The handle to the authorization information. The server must convert
--     this to one that is appropriate for the Authz_Service, as follows:
--
--     +-----------------------------------------------------------+
--     |               | Privs Contains      |                     |
--     | Authz_Service | Calling Client's... | Convert To...       |
--     +-----------------------------------------------------------+
--     | Authz_None    | NULL_ADDRESS        | Nothing             |
--     | Authz_Name    | Pricipal Name       | Principal_Name_Ptr  |
--     | Authz_DCE     | Privilege Attribute | Sec_ID_Pac_Ptr      |
--     |               |   Certificate       |                     |
--     +-----------------------------------------------------------+
--
--   Server_Princ_Name : The server principal name
--   Protect_Level     : Requested protection level
--   Authn_Service     : Requested authentication service
--   Authz_Service     : Requested authorization service
--
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--     rpc_s_binding_has_no_auth
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_inq_auth_client(
--          rpc_binding_handle_t binding,
--          rpc_authz_handle_t *privs,
--          unsigned_char_t **server_princ_name,
--          unsigned32 *protect_level,
--          unsigned32 *authn_svc,
--          unsigned32 *authz_svc,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_Inq_Auth_Info(
  Binding_Handle    : in     RPC_Binding_Handle_Type;
  Server_Princ_Name :    out Principal_Name_Type;
  Protect_Level     :    out DCE_Base.RPC_Protect_Level_Type;
  Authn_Service     :    out DCE_Base.RPC_Authentication_Service_Type;
  Auth_Identity     :    out RPC_Auth_Identity_Type;
  Authz_Service     :    out DCE_Base.RPC_Authorization_Service_Type;
  Status            :    out DCE_Status.Status_Type;
  No_Server_Name    : in     boolean := FALSE;
  No_Protect_Level  : in     boolean := FALSE;
  No_Authn_Service  : in     boolean := FALSE;
  No_Auth_Identity  : in     boolean := FALSE;
  No_Authz_Service  : in     boolean := FALSE);
-- ****************************************************************************
-- Returns authentication and authorization information from a SERVER binding
-- handle.
--
-- Input:
--   Binding_Handle   : The SERVER binding handle
--   No_Server_Name   : If TRUE, the server principal name is not returned
--   No_Protect_Level : If TRUE, the protection level is not returned
--   No_Authn_Service : If TRUE, the authentication service is not returned
--   No_Auth_Identity : If TRUE, the client's credentials appropriate for the
--                      selected authentication and authorization services are
--                      not returned
--   No_Authz_Service : If TRUE, the authorization service is not returned
--
-- Output:
--   Server_Princ_Name : The server principal name
--   Protect_Level     : Requested protection level
--   Authn_Service     : Requested authentication service
--   Auth_Identity     : The client's credentials appropriate for the selected
--                       authentication and authorization services. The client
--                       must convert this to a type that is appropriate for the
--                       authentication and authorization services (established
--                       via RPC_Binding_Set_Auth_Info)
--   Authz_Service     : Requested authorization service
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--     rpc_s_binding_has_no_auth
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_inq_auth_info(
--          rpc_binding_handle_t binding,
--          unsigned_char_t **server_princ_name,
--          unsigned32 *protect_level,
--          unsigned32 *authn_svc,
--          rpc_auth_identity_handle_t *auth_identity,
--          unsigned32 *authz_svc,
--          unsigned32 *status);
--
-- ****************************************************************************
-- Test Note: Without a login context for the call to setup the auth info (with
--            "RPC_Binding_Set_Auth_Info"), this function cannot be tested.
-- ****************************************************************************

procedure RPC_Binding_Inq_Object(
  Binding_Handle    : in     RPC_Binding_Handle_Type;
  Object_UUID       :    out UUID_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Return the object UUID from a binding handle.
--
-- Input:
--   Binding_Handle : The binding handle
--
-- Output:
--   Object_UUID : The object UUID
--
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_inq_object(
--          rpc_binding_handle_t binding,
--          uuid_t *object_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_Reset(
  Binding_Handle : in     RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Reset the binding handle by removing the endpoint information, resulting in
-- a partially bound SERVER binding handle.
--
-- Input:
--   Binding_Handle : The binding handle
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_inq_object(
--          rpc_binding_handle_t binding,
--          uuid_t *object_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_Server_from_Client(
  Client_Binding : in     RPC_Binding_Handle_Type;
  Server_Binding :    out RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Converts a CLIENT binding handle to a SERVER binding handle.
--
-- Input:
--   Client_Binding : The client binding handle
--
-- Output:
--   Server_Binding : The server binding handle
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_getpeername
--     rpc_s_connection_closed
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_server_from_client(
--          rpc_binding_handle_t client_binding,
--          rpc_binding_handle_t *server_binding,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_Set_Auth_Info(
  Binding_Handle    : in     RPC_Binding_Handle_Type;
  Server_Princ_Name : in     Principal_Name_Type;
  Protect_Level     : in     DCE_Base.RPC_Protect_Level_Type;
  Authn_Service     : in     DCE_Base.RPC_Authentication_Service_Type;
  Auth_Identity     : in     RPC_Auth_Identity_Type;
  Authz_Service     : in     DCE_Base.RPC_Authorization_Service_Type;
  Status            :    out DCE_Status.Status_Type;
  Default_Identity  : in     boolean := FALSE);
-- ****************************************************************************
-- Set authentication and authorization information for a SERVER binding handle.
--
-- Input:
--   Binding_Handle    : The binding handle
--   Server_Princ_Name : Principal name of the server
--   Protect_Level     : The protection level of RPC's made with Binding_Handle
--   Authn_Service     : The authentication service
--   Auth_Identity     : The client's credentials appropriate for the selected
--                       authentication and authorization services
--   Authz_Service     : The authorization service
--   Default_Identity  : If TRUE, uses the default security login context
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--     rpc_s_unknown_authn_service
--     rpc_s_authn_authz_mismatch
--     rpc_s_unsupported_protect_level
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_set_auth_info(
--          rpc_binding_handle_t binding,
--          unsigned_char_t *server_princ_name,
--          unsigned32 protect_level,
--          unsigned32 authn_svc,
--          rpc_auth_identity_handle_t auth_identity,
--          unsigned32 authz_svc,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_Set_Object(
  Binding_Handle    : in     RPC_Binding_Handle_Type;
  Object_UUID       : in     UUID_Type;
  Status            :    out DCE_Status.Status_Type;
  Use_NIL_Obj_UUID  : in     boolean := FALSE);
-- ****************************************************************************
-- Set the object UUID into a SERVER binding handle.
--
-- Input:
--   Binding_Handle   : The SERVER binding handle
--   Object_UUID      : The object UUID
--   Use_NIL_Obj_UUID : If TRUE, use a NIL UUID instead of the one supplied
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_set_object(
--          rpc_binding_handle_t binding,
--          uuid_t *object_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Binding_to_String_Binding(
  Binding_Handle : in     RPC_Binding_Handle_Type;
  String_Binding :    out RPC_String_Binding_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Return the string representation of a binding handle.
--
-- Input:
--   Binding_Handle : The binding handle
--
-- Output:
--   String_Binding : The formatted string binding with delimiters
--
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_getpeername
--     rpc_s_connection_closed
--     rpc_s_invalid_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_to_string_binding(
--          rpc_binding_handle_t binding_handle,
--          unsigned_char_t **string_binding,
--          unsigned32 *status);
--
-- ****************************************************************************

function RPC_Binding_Vector_Count(
  Binding_Vector : in RPC_Binding_Vector_Type) return natural;
-- ****************************************************************************
-- Returns the number of elements in the vector of binding handles.
--
-- Input:
--   Binding_Vector : The vector of binding handles
--
-- Output:
--   None
--
-- Return values:
--   The number of elements in the binding vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

function RPC_Binding_Vector_Element(
  Binding_Vector : in RPC_Binding_Vector_Type;
  Element_Number : in positive := 1
  ) return RPC_Binding_Handle_Type;
-- ****************************************************************************
-- Returns the specified element from the vector of binding handles.
--
-- Input:
--   Binding_Vector : The vector of binding handles
--
--   Element_Number : The element number (index value) to return
--
-- Return Value:
--   The binding handle
--
-- Exceptions:
--   CONSTRAINT_ERROR :
--     Raised if Element_Number is greater than number of elements in vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

procedure RPC_Binding_Vector_Free(
  Binding_Vector : in out RPC_Binding_Vector_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Frees the memory used to store a vector of binding handles.
--
-- Input/Output:
--   Binding_Vector : The binding vector to free. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_arg
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_binding_vector_free(
--          rpc_binding_vector_t **binding_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_EP_*  /////////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_EP_Register(
  IF_Handle            : in     RPC_Interface_Handle_Type;
  Binding_Vector       : in     RPC_Binding_Vector_Type;
  Object_UUID_Vector   : in     UUID_Vector_Type;
  Annotation           : in     EP_Map_Annotation_Type;
  Status               :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Add to, or replace, SERVER address information in the local endpoint map.
--
-- Input:
--   IF_Handle         : The interface spec to register with local endpoint map
--   Binding_Vector    : A vector of server binding handles over which the
--                       server can receive remote procedure calls
--   Object_UUID_Vector: A vector of object UUIDs that the server offers.
--                       Specify NULL if there are no object UUIDs to register
--   Annotation        : A text comment used for informational purposes only.
--                       Specify a string containing Ascii.NULs if no string
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_access
--     rpc_s_cant_create
--     rpc_s_cant_perform_op
--     rpc_s_database_invalid
--     rpc_s_invalid_entry
--     rpc_s_update_failed
--     rpc_s_comm_failure
--     rpc_s_invalid_binding
--     rpc_s_no_bindings
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ep_register(
--          rpc_if_handle_t if_spec,
--          rpc_binding_vector_t *binding_vec,
--          uuid_vector_t *object_uuid_vec,
--          unsigned_char_t *annotation,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_EP_Register_No_Replace(
  IF_Handle            : in     RPC_Interface_Handle_Type;
  Binding_Vector       : in     RPC_Binding_Vector_Type;
  Object_UUID_Vector   : in     UUID_Vector_Type;
  Annotation           : in     EP_Map_Annotation_Type;
  Status               :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Add to SERVER address information in the local endpoint map.
--
-- Input:
--   IF_Handle         : The interface spec to register with local endpoint map
--   Binding_Vector    : A vector of server binding handles over which the
--                       server can receive remote procedure calls
--   Object_UUID_Vector: A vector of object UUIDs that the server offers
--                       Specify NULL if there are no object UUIDs to register
--   Annotation        : A text comment used for informational purposes only.
--                       Specify a string containing Ascii.NULs if no string
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_access
--     rpc_s_cant_create
--     rpc_s_cant_perform_op
--     rpc_s_database_invalid
--     rpc_s_invalid_entry
--     rpc_s_update_failed
--     rpc_s_comm_failure
--     rpc_s_invalid_binding
--     rpc_s_no_bindings
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ep_register_no_replace(
--          rpc_if_handle_t if_spec,
--          rpc_binding_vector_t *binding_vec,
--          uuid_vector_t *object_uuid_vec,
--          unsigned_char_t *annotation,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_EP_Resolve_Binding(
  Binding_Handle : in out RPC_Binding_Handle_Type;
  IF_Handle      : in out RPC_Interface_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Resolves a partially bound SERVER binding handle into a fully bound SERVER
-- binding handle.
--
-- Input/Output:
--   Binding_Handle : The SERVER binding handle
--   IF_Handle      : The interface handle of interest
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_not_registered
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ep_resolve_binding(
--          rpc_binding_handle_t binding_h,
--          rpc_if_handle_t if_spec,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_EP_Unregister(
  IF_Handle            : in     RPC_Interface_Handle_Type;
  Binding_Vector       : in     RPC_Binding_Vector_Type;
  Object_UUID_Vector   : in     UUID_Vector_Type;
  Status               :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Removes SERVER address information in the local endpoint map.
--
-- Input:
--   IF_Handle         : The interface to remove from the local endpoint map
--   Binding_Vector    : A vector of server binding handles to remove
--   Object_UUID_Vector: A vector of object UUIDs to remove. Specify NULL if
--                       there are no object UUIDs to remove
--   Annotation        : A text comment used for informational purposes only
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_access
--     rpc_s_cant_create
--     rpc_s_cant_perform_op
--     rpc_s_database_invalid
--     rpc_s_invalid_entry
--     rpc_s_update_failed
--     rpc_s_comm_failure
--     rpc_s_invalid_binding
--     rpc_s_no_bindings
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ep_unregister(
--          rpc_if_handle_t if_spec,
--          rpc_binding_vector_t *binding_vec,
--          uuid_vector_t *object_uuid_vec,
--          unsigned32 *status);

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_IF_*  /////////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_IF_Id_Display(
  IF_Identifier : in RPC_Interface_Id_Type);
-- ****************************************************************************
-- Display the contents of te interface identifier, formatted as follows:
--     uuid,major_vesrion.minor_version
--
-- Input:
--   IF_Identifier : The IF Id to display
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

function RPC_IF_Id_Vector_Count(
  IF_Id_Vector : in RPC_Interface_Id_Vector_Type) return natural;
-- ****************************************************************************
-- Returns the number of elements in the vector of interface identifiers.
--
-- Input:
--   IF_Id_Vector : The vector of interface identifiers
--
-- Output:
--   None
--
-- Return values:
--   The number of elements in the vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

function RPC_IF_Id_Vector_Element(
  IF_Id_Vector   : in RPC_Interface_Id_Vector_Type;
  Element_Number : in positive := 1
  ) return RPC_Interface_Id_Type;
-- ****************************************************************************
-- Returns the specified element from the vector of interface identifiers.
--
-- Input:
--   IF_Id_Vector : The vector of interface identifiers
--
--   Element_Number : The element number (index value) to return
--
-- Return Value:
--   The interface identifier
--
-- Exceptions:
--   CONSTRAINT_ERROR :
--     Raised if Element_Number is greater than number of elements in vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************


procedure RPC_IF_Id_Vector_Free(
  IF_Id_Vector : in out RPC_Interface_Id_Vector_Type;
  Status       :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Frees the interface identifier vector structure.
--
-- Input/Output:
--   IF_Id_Vector : The interface identifier vector. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_arg
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_if_id_vector_free(
--          rpc_if_id_vector_p_t *if_id_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_IF_Inq_Id(
  IF_Handle     : in     RPC_Interface_Handle_Type;
  IF_Identifier :    out RPC_Interface_Id_Type;
  Status        :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns the interface identifier for an interface specification.
--
-- Input:
--   IF_Handle : The SERVER binding handle
--
-- Output:
--   IF_Identifier : The interface identifier
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_if_inq_id(
--          rpc_if_handle_t if_spec,
--          rpc_if_id_t *if_id,
--          unsigned32 *status);
--
-- ****************************************************************************

-- DCE RPC Equivalent Declaration:
--
--   void rpc_if_register_auth_info(
--          rpc_if_handle_t if_spec,
--          unsigned_char_t *server_princ_name,
--          unsigned32 protect_level,
--          unsigned32 authn_svc,
--          rpc_auth_identity_handle_t auth_identity,
--          unsigned32 authz_svc,
--          unsigned32 *status);
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_Mgmt_*  ///////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_Mgmt_EP_Elt_Inq_Begin(
  EP_Binding      : in     RPC_Binding_Handle_Type;
  Inquiry_Type    : in     DCE_Base.EP_Inquiry_Type_Type;
  Interface_ID    : in     RPC_Interface_Id_Type;
  Version_Option  : in     DCE_Base.Version_Option_Type;
  Object_UUID     : in     UUID_Type;
  Inquiry_Context :    out RPC_EP_Inquiry_Handle_Type;
  Status          :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Creates an inquiry context for viewing the elements in the endpoint map.
--
-- Input:
--   EP_Binding     : Binding handle to host whose endpoint to receive
--                    Specify NULL to use the endpoint map from same host as
--                    the calling application
--   Inquiry_Type   : Type of inquiry to perform
--   Interface_ID   : The IF id of the endpoint map elements returned from the
--                    call(s) to RPC_Mgmt_EP_Elt_Inq_Next()
--   Version_Option : The comparison method used by RPC_Mgmt_EP_Elt_Inq_Next()
--                    if Inquiry_Type is EP_MATCH_BY_BOTH or EP_MATCH_BY_IF
--   Object_UUID    : The Object UUID that RPC_Mgmt_EP_Elt_Inq_Next() looks for
--                    in endpoint map elements
--
-- Output:
--   Inquiry_Context: The inquiry context to use with RPC_Mgmt_EP_Elt_Inq_Next()
--                    and RPC_Mgmt_EP_Elt_Inq_Done()
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_inquiry_context
--     rpc_s_invalid_inquiry_type
--     rpc_s_invalid_vers_option
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_ep_elt_inq_begin(
--          rpc_binding_handle_t ep_binding,
--          unsigned32 inquiry_type,
--          rpc_if_id_t *if_id,
--          unsigned32 vers_option,
--          uuid_t *object_uuid,
--          rpc_ep_inq_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_EP_Elt_Inq_Done(
  Inquiry_Context : in out RPC_EP_Inquiry_Handle_Type;
  Status          :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes the inquiry context for viewing the elements in the endpoint map.
--
-- Input/Output:
--   Inquiry_Context : The inquiry context to delete. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_inquiry_context
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_ep_elt_inq_done(
--          rpc_ep_inq_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_EP_Elt_Inq_Next(
  Inquiry_Context : in     RPC_EP_Inquiry_Handle_Type;
  Interface_ID    : in     RPC_Interface_Id_Type;
  Binding_Handle  :    out RPC_Binding_Handle_Type;
  Object_UUID     :    out UUID_Type;
  Annotation      :    out EP_Map_Annotation_Type;
  Status          :    out DCE_Status.Status_Type;
  No_Binding      : in     boolean := FALSE;
  No_Obj_UUID     : in     boolean := FALSE;
  No_Annotation   : in     boolean := FALSE);
-- ****************************************************************************
-- Returns one element from an endpoint map
--
-- Input:
--   Inquiry_Context : The inquiry context to use
--   Interface_ID    : The IF id of the endpoint map element
--   Object_UUID     : The Object UUID of the endpoint map element
--   Annotation      : The annoation string of the endpoint map element
--   No_Binding      : If TRUE, the Binding_Handle is NOT returned
--   No_Obj_UUID     : If TRUE, the Object_UUID is NOT returned
--   No_Annotation   : If TRUE, the Annotation is NOT returned
--
-- Output:
--   Binding_Handle : The binding handle of the local endpoint map element
--   Object_UUID    : The object UUID from the local endpoint map element
--   Annotation     : The annotation string for the local endpoint map element
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_perform_op
--     rpc_s_comm_failure
--     rpc_s_database_invalid
--     rpc_s_falut_context_mismatch
--     rpc_s_invalid_context
--     rpc_s_invalid_entry
--     rpc_s_invalid_arg
--     rpc_s_invalid_inquiry_context
--     rpc_s_invalid_inquiry_type
--     rpc_s_no_more_elements
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_ep_elt_inq_next(
--          rpc_ep_inq_handle_t inquiry_context,
--          rpc_if_id_t *if_id,
--          rpc_binding_handle_t *binding,
--          uuid_t *object_uuid,
--          unsigned_char_t **annotation,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_EP_Unregister(
  EP_Binding      : in     RPC_Binding_Handle_Type;
  Interface_ID    : in     RPC_Interface_Id_Type;
  Binding_Handle  : in     RPC_Binding_Handle_Type;
  Object_UUID     : in     UUID_Type;
  Status          :    out DCE_Status.Status_Type;
  No_Obj_UUID     : in     boolean := FALSE);
-- ****************************************************************************
-- Unregisters (remove) server address information from an endpoint map.
--
-- Input:
--   EP_Binding     : The host whose local endpoint map elements to unregister 
--   Interface_ID   : The IF id to remove from the local endpoint map
--   Binding_Handle : The binding handle to remove
--   Object_UUID    : The object UUID to remove
--   No_Obj_UUID    : If TRUE, no object UUIDs are considered in the removal
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_access
--     rpc_s_cant_perform_op
--     rpc_s_comm_failure
--     rpc_s_database_invalid
--     rpc_s_invalid_entry
--     rpc_s_not_registered
--     rpc_s_update_failed
--     rpc_s_invalid_binding
--     rpc_s_no_interfaces
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_ep_unregister(
--          rpc_binding_handle_t ep_binding,
--          rpc_if_id_t *if_id,
--          rpc_binding_handle_t binding,
--          uuid_t *object_uuid,
--          unsigned32 *status);
--          
-- ****************************************************************************

procedure RPC_Mgmt_Inq_Com_Timeout(
  Binding_Handle : in     RPC_Binding_Handle_Type;
  Timeout        :    out DCE_Base.Unsigned32;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Return the communications time-out value in a SERVER binding handle.
--
-- Input:
--   Binding_Handle : The binding handle
--
-- Output:
--   Timeout : The time-out value
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_inq_com_timeout(
--          rpc_binding_handle_t binding,
--          unsigned32 *timeout
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_Inq_Dflt_Protect_Level(
  Authn_Service : in     DCE_Base.RPC_Authentication_Service_Type;
  Protect_Level :    out DCE_Base.RPC_Protect_Level_Type;
  Status        :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns the default protection level for an authentication service.
--
-- Input:
--   Authn_Service : The authentication service for which the default
--                   protection level is to be returned
--
-- Output:
--   Protect_Level : The default protection level
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_unknown_authn_service
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_inq_dflt_protect_level(
--          unsigned32 authn_svc,
--          unsigned32 *protect_level,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_Inq_IF_Ids(
  Binding_Handle : in     RPC_Binding_Handle_Type;
  IF_Id_Vector   :    out RPC_Interface_Id_Vector_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns a vector of interface identifiers of interfaces a SERVER offers.
--
-- Input:
--   Binding_Handle : The binding handle to the remote application. Specify
--                    NULL to receive ID ids from your own (local) application
--
-- Output:
--   IF_Id_Vector : The interface identifier vector
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_binding_incomplete
--     rpc_s_comm_failure
--     rpc_s_invalid_binding
--     rpc_s_mgmt_op_disallowed
--     rpc_s_no_interfaces
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--  void rpc_mgmt_inq_if_ids(
--         rpc_binding_handle binding,
--         rpc_if_id_vector_t **if_id_vector,
--         unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_Inq_Server_Princ_Name(
  Binding_Handle    : in     RPC_Binding_Handle_Type;
  Authn_Service     : in     DCE_Base.RPC_Authentication_Service_Type;
  Server_Princ_Name :    out Principal_Name_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Return a SERVER's principal name.
--
-- Input:
--   Binding_Handle : The binding handle to the remote application. Specify
--                    NULL to receive the principal name of the server itself
--   Authn_Service  :
--     The authentication service for which the server principal name is to be
--     returned
--
-- Output:
--   Server_Princ_Name :
--     The server principal name registered for the authentication service by
--     the srever in the binding. If the server registered more than one
--     principal name, only one is returned
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_binding_incomplete
--     rpc_s_comm_failure
--     rpc_s_mgmt_op_disallowed
--     rpc_s_unknown_authn_service
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_inq_server_princ_name(
--          rpc_binding_handle binding,
--          unsigned32 authn_svc,
--          unsigned_char_t **server_princ_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_Inq_Stats(
  Binding_Handle : in     RPC_Binding_Handle_Type;
  Statistics     :    out RPC_Statistics_Vector_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Return RPC runtime statistics.
--
-- Input:
--   Binding_Handle : The binding handle to the remote application. Specify
--                    NULL to get statistics from your own (local) application
--
-- Output:
--   Statistics : The statistics vector
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_binding_incomplete
--     rpc_s_comm_failure
--     rpc_s_invalid_binding
--     rpc_s_mgmt_op_disallowed
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_inq_stats(
--          rpc_binding_handle binding,
--          rpc_stats_vector_t **statistics,
--          unsigned32 *status);
--
-- ****************************************************************************

function RPC_Mgmt_Is_Server_Listening(
  Binding_Handle : in RPC_Binding_Handle_Type;
  Status         : in DCE_Status.Status_Type)
return DCE_Base.boolean32;
-- ****************************************************************************
-- Tells whether the SERVER is listening for remote procedure calls.
--
-- Input:
--   Binding_Handle : The binding handle to the remote application. Specify
--                    NULL to tell whether your own (local) application is
--                    listening for remote procedure calls
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_binding_incomplete
--     rpc_s_comm_failure
--     rpc_s_invalid_binding
--     rpc_s_mgmt_op_disallowed
--     rpc_s_wrong_kind_of_binding
--
-- Returned Value:
--    TRUE  : The SERVER is listening
--    FALSE : The SERVER is NOT listening, or cannot be reached
--
-- DCE RPC Equivalent Declaration:
--
--   boolean32 rpc_mgmt_inq_stats(
--               rpc_binding_handle binding,
--               unsigned32 *status);
--
-- ****************************************************************************

--procedure RPC_Mgmt_Set_Authorization_Fn(
--  RPC_Mgmt_Authorization_Fn_Address : in     DCE_Base.Function_Pointer_Type;
--  Status                            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Establishes an authorization function for processing remote calls to a
-- SERVER's management routines.
--
-- Input:
--   RPC_Mgmt_Authorization_Fn_Address : The 'ADDRESS of the of the function
--     RPC_Mgmt_Authorization_Fn(). The body is created and compiled separately
--     by the application developer to replace the existing body in the library.
--     Use System.NULL_ADDRESS to unregister a previously registered function;
--     the default RPC runtime function will be used in its place.
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_set_authorization_fn(
--          rpc_mgmt_authorization_fn_t authorization_fn,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_Set_Cancel_Timeout(
  Seconds : in     DCE_Base.Signed32;
  Status  :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Sets the lower bound on the time to wait before timing out after forwarding
-- a cancel request.
--
-- Input:
--   Seconds : Number of seconds to wait for a SERVER to acknowledge a cancel
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_set_cancel_timeout(
--          signed32 seconds,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_Set_Com_Timeout(
  Binding_Handle : in     RPC_Binding_Handle_Type;
  Timeout        : in     DCE_Base.Unsigned32;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Sets the communications time-out value in a SERVER binding handle.
--
-- Input:
--   Binding_Handle : The binding handle whose comm time-out is set
--   Timeout        : The time-out value
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_binding
--     rpc_s_invalid_timeout
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_set_com_timeout(
--          rpc_binding_handle binding,
--          unsigned32 timeout,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Mgmt_Set_Server_Stack_Size(
  Thread_Stack_Size : in     DCE_Base.Unsigned32;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Specifies the stack size for each SERVER thread
--
-- Input:
--   Thread_Stack_Size : The stack size, in bytes, allocated for each thread
--                       created by RPC_Server_Listen(). This value is applied
--                       to all threads created for the server
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_arg
--     rpc_s_not_supported
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_set_server_stack_size(
--          unsigned32 thread_stack_size,
--          unsigned32 *status);
--
-- ****************************************************************************

function RPC_Mgmt_Stats_Vector_Element(
  Statistics : in RPC_Statistics_Vector_Type;
  Element    : in DCE_Base.Stats_Type_Type
  ) return DCE_Base.Unsigned32;
-- ****************************************************************************
-- Return the specified element in the statistics vector.
--
-- Input:
--   Stats_Vector : The statistics vector
--   Element      : The element in the statistics vector to return
--
-- Returned Value:
--   The value of the specified element in the statistics vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

procedure RPC_Mgmt_Stats_Vector_Free(
  Statistics : in out RPC_Statistics_Vector_Type;
  Status     :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Free the statistics vector.
--
-- Input/Outout:
--   Stats_Vector : The statistics vector. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

procedure RPC_Mgmt_Stop_Server_Listening(
  Binding_Handle : in     RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells a SERVER to stop listening for remote procedure calls.
--
-- Input:
--   Binding_Handle : The binding handle to the remote application. Specify
--                    NULL to stop your own (local) SERVER from listening
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_binding_incomplete
--     rpc_s_comm_failure
--     rpc_s_invalid_binding
--     rpc_s_mgmt_op_disallowed
--     rpc_s_unkown_if
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_mgmt_stop_server_listening(
--          rpc_binding_handle binding,
--          unsigned32 *status);

-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_Network_*  ////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_Network_Inq_Protseqs(
  Protseq_Vector : out RPC_Protseq_Vector_Type;
  Status         : out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns a vector of all protocol sequences supported by both the RPC runtime
-- and the operating system.
--
-- Input:
--   None
--
-- Output:
--   Protseq_Vector : A vector of protocol sequences supported by the RPC
--                    runtime and the operating system
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_no_protseqs
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_network_inq_protseqs(
--          rpc_protseq_vector_t **protseq,
--          unsigned32 *status);
--
-- ****************************************************************************

function RPC_Network_Is_Protseq_Valid(
  Protocol_Seq : in Protocol_Sequence_Type;
  Status       : in DCE_Status.Status_Type
  ) return DCE_Base.boolean32;
-- ****************************************************************************
-- Tells whether the specified protocol sequence is supported by both the RPC
-- runtime and the operating system.
--
-- Input:
--   Protocol_Seq : The protocol sequence
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_rpc_protseq
--     rpc_s_protseq_not_supported
--
-- Return Value:
--   TRUE  : The specified protocol sequence is supported
--   FALSE : The specified protocol sequence is NOT supported
--
-- DCE RPC Equivalent Declaration:
--   boolean32 rpc_network_is_protseq_valid(
--               unsigned_char_t *protseq,
--               unsigned32 *status);
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_NS_*  /////////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_NS_Binding_Export(
  Entry_Name_Syntax       : in     DCE_Base.NS_Syntax_Type;
  Entry_Name              : in     NS_Entry_Name_Type;
  IF_Handle               : in     RPC_Interface_Handle_Type;
  Binding_Vector          : in     RPC_Binding_Vector_Type;
  Object_UUID_Vector      : in     UUID_Vector_Type;
  Status                  :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Create a name service database entry with binding handles or object UUIDs
-- for a SERVER.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value in the
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name to which binding handles and object
--                       UUIDs are exported
--   IF_Handle         : The interface spec to emport. Specify NULL if there are
--                       no IF handles to export (only object UUIDs); In this
--                       case, the Binding_Vector parameter is ignored
--   Binding_Vector    : A vector of server binding handles to export. Specify
--                       NULL if there are no binding handles to export
--   Object_UUID_Vector: A vector of object UUIDs. Specify NULL if there are
--                       no object UUIDs to export
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--     rpc_s_invalid_binding
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_nothing_to_export
--     rpc_s_unsupported_name_syntax
--     rpc_s_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_export(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          rpc_if_handle_t if_spec,
--          rpc_binding_vector_t *binding_vector,
--          uuid_vector_t *object_uuid_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Import_Begin(
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        : in     NS_Entry_Name_Type;
  IF_Handle         : in     RPC_Interface_Handle_Type;
  Object_UUID       : in     UUID_Type;
  Import_Context    :    out RPC_NS_Handle_Type;
  Status            :    out DCE_Status.Status_Type;
  Use_NIL_Obj_UUID  : in     boolean := FALSE);
-- ****************************************************************************
-- Create an import context for an interface and object in the name service
-- database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value in the
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name where the search for compatible binding
--                       handles begins. Specify a string of Ascii.NULs to use
--                       value in the RPC_DEFAULT_ENTRY environment variable.
--                       parameter to TRUE
--   IF_Handle         : The interface spec to export
--   Object_UUID       : An optional object UUID
--   Use_NIL_Obj_UUID  : If TRUE, use a NIL UUID instead of the Object_UUID
--
-- Output:
--   Import_Context : The context for use with RPC_NC_Binding_Import_Next() and
--                    RPC_NC_Binding_Import_Done()
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_invalid_object
--     rpc_s_no_env_setup
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_import_begin(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          rpc_if_handle_t if_spec,
--          uuid_p_t object_uuid,
--          rpc_ns_handle_t *import_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Import_Done(
  Import_Context : in out RPC_NS_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes the import context.
--
-- Input/Output:
--   Import_Context : The context to delete. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_ns_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_import_done(
--          rpc_ns_handle_t *import_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Import_Next(
  Import_Context : in     RPC_NS_Handle_Type;
  Binding_Handle :    out RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Return a binding handle of a compatible SERVER (if found) from the name
-- service database.
--
-- Input:
--   Import_Context : The name service context
--
-- Output:
--   Binding_Handle : A compatible binding handle
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_entry_not_found
--     rpc_s_invalid_ns_handle
--     rpc_s_name_service_unavailable
--     rpc_s_no_more_bindings
--     rpc_s_no_ns_permission
--     rpc_s_not_rpc_entry
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_import_next(
--          rpc_ns_handle_t import_context,
--          rpc_binding_handle_t *binding,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Inq_Entry_Name(
  Binding_Handle    : in     RPC_Binding_Handle_Type;
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        :    out NS_Entry_Name_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns the name of an entry in the name service database from which the
-- SERVER binding handle came.
--
-- Input:
--   Binding_Handle    : A SERVER binding handle whose entry in the name service
--                       database is returned
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--
-- Output:
--   Entry_Name : The entry (global) name in the name service database in which
--                the Binding_Handle was found
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--     rpc_s_invalid_binding
--     rpc_s_invalid_name_syntax
--     rpc_s_no_entry_name
--     rpc_s_unsupported_name_syntax
--     rpc_wrong_kind_of_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_inq_entry_name(
--          rpc_binding_handle_t binding,
--          unsigned32 entry_name_syntax,
--          unsigned_char_t **entry_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Lookup_Begin(
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        : in     NS_Entry_Name_Type;
  IF_Handle         : in     RPC_Interface_Handle_Type;
  Object_UUID       : in     UUID_Type;
  Binding_Max_Count : in     DCE_Base.Unsigned32;
  Lookup_Context    :    out RPC_NS_Handle_Type;
  Status            :    out DCE_Status.Status_Type;
  Use_NIL_Obj_UUID  : in     boolean := FALSE);
-- ****************************************************************************
-- Create a lookup context for an interface and object in the name service
-- database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable
--   Entry_Name        : The entry name where the search for compatible binding
--                       handles begins. Specify a string of Ascii.NUL to use
--                       value in the RPC_DEFAULT_ENTRY environment variable
--   IF_Handle         : The interface spec to import. Specify NULL if the
--                       IF Spec has not been exported or is no concern to call
--   Object_UUID       : An optional object UUID
--   Binding_Max_Count : The maximum number of binding handles returned from
--                       RPC_NS_Binding_Lookup_Next(). Specify 
--                       BINDING_MAX_COUNT_DEFAULT to use the default count
--   Use_NIL_Obj_UUID  : If TRUE, a NIL Object UUID will be used in place of the
--                       Object_UUID parameter
--
-- Output:
--   Lookup_Context : The context for use with RPC_NC_Binding_Import_Next() and
--                    RPC_NC_Binding_Import_Done()
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_invalid_object
--     rpc_s_no_env_setup
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_lookup_begin(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          rpc_if_handle_t if_spec,
--          uuid_p_t object_uuid,
--          unsigned32 binding_max_count,
--          rpc_ns_handle_t *lookup_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Lookup_Done(
  Lookup_Context : in out RPC_NS_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes the lookup context.
--
-- Input/Output:
--   Lookup_Context : The context to delete. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_ns_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_lookup_done(
--          rpc_ns_handle_t *lookup_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Lookup_Next(
  Lookup_Context : in     RPC_NS_Handle_Type;
  Binding_Vector :    out RPC_Binding_Vector_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns a list of binding handles of one or more compatible SERVERS
-- (if found) from the name service database.
--
-- Input:
--   Lookup_Context : The lookup context from RPC_NS_Binding_Lookup_Begin()
--
-- Output:
--   Binding_Vector : A vector of compatible SERVER binding handles
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_entry_not_found
--     rpc_s_invalid_ns_handle
--     rpc_s_name_service_unavailable
--     rpc_s_no_more_bindings
--     rpc_s_no_ns_permission
--     rpc_s_not_rpc_entry
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_lookup_next(
--          rpc_ns_handle_t lookup_context,
--          rpc_binding_vector_t **binding_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Select(
  Binding_Vector : in out RPC_Binding_Vector_Type;
  Binding_Handle :    out RPC_Binding_Handle_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns a binding handle from a list of compatible SERVER binding handles.
--
-- Input:
--   Binding_Vector : A vector of compatible SERVER binding handles
--
-- Output:
--   Binding_Handle : A randomly selected SERVER binding handle
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_no_more_bindings
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_select(
--          rpc_binding_vector_t *binding_vector,
--          rpc_binding_handle_t *binding,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Binding_Unexport(
  Entry_Name_Syntax    : in     DCE_Base.NS_Syntax_Type;
  Entry_Name           : in     NS_Entry_Name_Type;
  IF_Handle            : in     RPC_Interface_Handle_Type;
  Object_UUID_Vector   : in     UUID_Vector_Type;
  Status               :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Removes the binding handles for an interface, or the object UUIDs, from an
-- entry in the name service database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name whose binding handles or object UUIDs
--                       are removed.
--   IF_Handle         : The interface spec to remove. Specify NULL if there are
--                       no binding handles to remove, only object UUIDs
--   Object_UUID_Vector: A vector of object UUIDs to remove. Specify NULL if there
--                       are no Object UUIDs to remove (only binding handles)
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_interface_not_found
--     rpc_s_invalid_name_syntax
--     rpc_s_invalid_vers_option
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_not_all_objs_unexported
--     rpc_s_nothing_to_unexport
--     rpc_s_not_rpc_entry
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_binding_unexport(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          rpc_if_handle_t if_spec,
--          uuid_vector_t *object_uuid_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Entry_Expand_Name(
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        : in     NS_Entry_Name_Type;
  Expanded_Name     :    out NS_Expanded_Name_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Expands the name of a name service entry.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name where the search for compatible binding
--                       handles begins. Specifying a string of Ascii.NUL has
--                       the same effect as Use_Default_Entry => TRUE
-- Output:
--   Expanded_Name  : The fully expanded entry name
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_entry_expand_name(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          unsigned_char_t **expanded_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Entry_Object_Inq_Begin(
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        : in     NS_Entry_Name_Type;
  Inquiry_Context   :    out RPC_NS_Handle_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Creates an inquiry context for viewing the objects of an entry in the name
-- service database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name where the search for compatible binding
--                       handles begins. Specifying a string of Ascii.NUL has
--                       the same effect as Use_Default_Entry => TRUE
-- Output:
--   Inquiry_Context : The inquiry context for use with the routines
--                     RPC_NS_Entry_Object_Next() and RPC_NS_Entry_Object_Done()
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_entry_object_inq_begin(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          rpc_ns_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Entry_Object_Inq_Done(
  Inquiry_Context : in out RPC_NS_Handle_Type;
  Status          :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes the inquiry context.
--
-- Input:
--   Inquiry_Context : The inquiry context to delete. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_ns_handle
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_entry_object_inq_done(
--          rpc_ns_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Entry_Object_Inq_Next(
  Inquiry_Context : in out RPC_NS_Handle_Type;
  Object_UUID     :    out UUID_Type;
  Status          :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns one object at a time from an entry in the name service database.
--
-- Input:
--   Inquiry_Context : The inquiry context
--
-- Output:
--   Object_UUID : An exported object UUID
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_ns_handle
--     rpc_s_name_service_unavailable
--     rpc_s_no_more_members
--     rpc_s_no_ns_permission
--     rpc_s_not_rpc_entry
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_entry_object_inq_next(
--          rpc_ns_handle_t inquiry_context,
--          uuid_t *object_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Group_Delete(
  Group_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Group_Name        : in     NS_Group_Name_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes a group attribute.
--
-- Input:
--   Group_Name_Syntax : The syntax used for the Group_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Group_Name        : The group name to delete (global or cell-relative name)
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_group_delete(
--          unsigned32 group_name_syntax,
--          unsigned_char_t *group_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Group_Mbr_Add(
  Group_Name_Syntax  : in     DCE_Base.NS_Syntax_Type;
  Group_Name         : in     NS_Group_Name_Type;
  Member_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Member_Name        : in     NS_Member_Name_Type;
  Status             :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Adds an entry name to a group; creating the entry if necessary.
--
-- Input:
--   Group_Name_Syntax  : The syntax used for the Group_Name parameter. Specify
--                        NS_SYNTAX_DEFAULT to use the value found in the 
--                        RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Group_Name         : The group name to receive the new member (global or
--                        cell-relative name)
--   Member_Name_Syntax : The syntax used for the Member_Name parameter. Specify
--                        NS_SYNTAX_DEFAULT to use the value found in the 
--                        RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Member_Name        : The name of the new member (global or cell-relative
--                        name)
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_group_mbr_add(
--          unsigned32 group_name_syntax,
--          unsigned_char_t *group_name,
--          unsigned32 member_name_syntax,
--          unsigned_char_t *member_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Group_Mbr_Inq_Begin(
  Group_Name_Syntax  : in     DCE_Base.NS_Syntax_Type;
  Group_Name         : in     NS_Group_Name_Type;
  Member_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Inquiry_Context    :    out RPC_NS_Handle_Type;
  Status             :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Create an inquiry context for a group in the CDS.
--
-- Input:
--   Group_Name_Syntax  : The syntax used for the Group_Name parameter. Specify
--                        NS_SYNTAX_DEFAULT to use the value in the
--                        RPC_DEFAULT_ENTRY_SYNTAX environment variable
--   Group_Name         : The group name to create the context for (global
--                        or cell-relative name)
--   Member_Name_Syntax : The syntax used for the Member_Name parameter. Specify
--                        NS_SYNTAX_DEFAULT to use the value in the
--                        RPC_DEFAULT_ENTRY_SYNTAX environment variable
--
-- Output:
--   Inquiry_Context : The inquiry context for use with the routines
--                     RPC_NS_Group_Mbr_Inq_Next() and
--                     RPC_NS_Group_Mbr_Inq_Done()
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_group_mbr_inq_begin(
--          unsigned32 group_name_syntax,
--          unsigned_char_t *group_name,
--          unsigned32 member_name_syntax,
--          rpc_ns_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Group_Mbr_Inq_Done(
  Inquiry_Context : in out RPC_NS_Handle_Type;
  Status          :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes the inquiry context for a group.
--
-- Input:
--   Inquiry_Context : The inquiry context to delete. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_ns_handle
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_group_mbr_inq_done(
--          rpc_ns_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Group_Mbr_Inq_Next(
  Inquiry_Context : in     RPC_NS_Handle_Type;
  Member_Name     :    out NS_Member_Name_Type;
  Status          :    out DCE_Status.Status_Type;
  No_Return_Name  : in     boolean := FALSE);
-- ****************************************************************************
-- Returns one member name at a time from a group.
--
-- Input:
--   Inquiry_Context : The inquiry context to delete. If successful, set to NULL
--   No_Return_Name  : If TRUE, the member name is not returned
--
-- Output:
--   Member_Name : The (global) name of the group member
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_entry_not_found
--     rpc_s_invalid_ns_handle
--     rpc_s_name_service_unavailable
--     rpc_s_no_more_members
--     rpc_s_no_ns_permission
--     rpc_s_not_rpc_entry
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_group_mbr_inq_next(
--          rpc_ns_handle_t inquiry_context,
--          unsigned_char_t **member_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Group_Mbr_Remove(
  Group_Name_Syntax  : in     DCE_Base.NS_Syntax_Type;
  Group_Name         : in     NS_Group_Name_Type;
  Member_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Member_Name        : in     NS_Member_Name_Type;
  Status             :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Removes an entry name from a group.
--
-- Input:
--   Group_Name_Syntax  : The syntax used for the Group_Name parameter. Specify
--                        NS_SYNTAX_DEFAULT to use the value found in the 
--                        RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Group_Name         : The group name to from which to remove the member
--                        (global or cell-relative name)
--   Member_Name_Syntax : The syntax used for the Member_Name parameter. Specify
--                        NS_SYNTAX_DEFAULT to use the value found in the 
--                        RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Member_Name        : The name of the member to remove from the name service
--                        interface group attribute in the Group_Name entry
--                        (global or cell-relative name)
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_not_found
--     rpc_s_group_member_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_group_mbr_remove(
--          unsigned32 group_name_syntax,
--          unsigned_char_t *group_name,
--          unsigned32 member_name_syntax,
--          unsigned_char_t *member_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Mgmt_Binding_Unexport(
  Entry_Name_Syntax    : in     DCE_Base.NS_Syntax_Type;
  Entry_Name           : in     NS_Entry_Name_Type;
  Interface_ID         : in     RPC_Interface_Id_Type;
  Version_Option       : in     DCE_Base.Version_Option_Type;
  Object_UUID_Vector   : in     UUID_Vector_Type;
  Status               :    out DCE_Status.Status_Type;
  Use_NULL_IF_Id       : in     boolean := FALSE);
-- ****************************************************************************
-- Remove multiple binding handles, or object UUIDs, from an entry in the name
-- service database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name whose bindings or UUIDs are removed
--   Interface_ID      : The IF id for the binding handles to be removed
--   Version_Option    : Specifies how the vers_major and vers_minor are used
--   Object_UUID_Vector: A vector of Object UUIDs to remove. Specify NULL if
--                       there are no object UUIDs to remove
--   Use_NULL_IF_Id    : If TRUE, use a NULL Interface_ID, signifying that no
--                       binding handles for the interface are to be removed
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_not_found
--     rpc_s_interface_not_found
--     rpc_s_invalid_name_syntax
--     rpc_s_invalid_vers_option
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_not_all_objs_unexported
--     rpc_s_nothing_to_unexport
--     rpc_s_not_rpc_entry
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_mgmt_binding_unexport(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          rpc_if_id_p_t if_id,
--          unsigned32 vers_option,
--          uuid_vector_t *object_uuid_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Mgmt_Entry_Create(
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        : in     NS_Entry_Name_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Creates an entry in the name service database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name to create (global or cell-relative name)
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_already_exists
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_mgmt_entry_create(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Mgmt_Entry_Delete(
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        : in     NS_Entry_Name_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes an entry in the name service database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name to create (global or cell-relative name)
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_not_rpc_entry
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_mgmt_entry_delete(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Mgmt_Entry_Inq_IF_Ids(
  Entry_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Entry_Name        : in     NS_Entry_Name_Type;
  IF_Id_Vector      :    out RPC_Interface_ID_Vector_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns a list of interfaces exported to an entry in the name service
-- database.
--
-- Input:
--   Entry_Name_Syntax : The syntax used for the Entry_Name parameter. Specify
--                       NS_SYNTAX_DEFAULT to use the value found in the 
--                       RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Entry_Name        : The entry name in the name service database for which
--                       an interface id vector is to be returned (global or
--                       cell-relative name)
--
-- Output:
--   IF_Id_Vector : A vector of interface identifiers
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_interfaces_exported
--     rpc_s_no_ns_permission
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_mgmt_entry_inq_if_ids(
--          unsigned32 entry_name_syntax,
--          unsigned_char_t *entry_name,
--          rpc_if_id_vector_p_t *if_id_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Mgmt_Handle_Set_Exp_Age(
  NS_Handle      : in     RPC_NS_Handle_Type;
  Expiration_Age : in     DCE_Base.Unsigned32;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Sets a handle's expiration age for local copies of name service data.
--
-- Input:
--   NS_Handle      : The name service handle to set the expirartion age
--   Expiration_Age : The age, in seconds
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_ns_handle
---- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_mgmt_handle_set_exp_age(
--          rpc_ns_handle_t ns_handle,
--          unsigned32 expiration_age,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Mgmt_Inq_Exp_Age(
  Expiration_Age : out DCE_Base.Unsigned32;
  Status         : out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns the application's global expiration age for local copies of name
-- service data.
--
-- Input:
--   None
--
-- Output:
--   Expiration_Age : The default expiration age, in seconds
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_mgmt_inq_exp_age(
--          unsigned32 *expiration_age,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Mgmt_Set_Exp_Age(
  Expiration_Age : in     DCE_Base.Signed32;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Modifies the application's global expiration age for local copies of name
-- service data.
--
-- Input:
--   None
--
-- Output:
--   Expiration_Age : The default expiration age, in seconds. Specify the value
--                    NS_DEFAULT_EXP_AGE to reset the expiration age to an RPC-
--                    assigned value
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--  void rpc_ns_mgmt_set_exp_age(
--         unsigned32 expiration_age,
--         unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Profile_Delete(
  Profile_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Profile_Name        : in     NS_Profile_Name_Type;
  Status              :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes a profile attribute.
--
-- Input:
--   Profile_Name_Syntax : The syntax used for the Profile_Name parameter.
--                         Specify NS_SYNTAX_DEFAULT to use the value found in
--                         the RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Profile_Name        : The profile name to delete (global or cell-relative
--                         name)
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_profile_delete(
--          unsigned32 profile_name_syntax,
--          unsigned_char_t *profile_name,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Profile_Elt_Add(
  Profile_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Profile_Name        : in     NS_Profile_Name_Type;
  Interface_ID        : in     RPC_Interface_ID_Type;
  Member_Name_Syntax  : in     DCE_Base.NS_Syntax_Type;
  Member_Name         : in     NS_Member_Name_Type;
  Priority            : in     DCE_Base.NS_Element_Priority_Type;
  Annotation          : in     NS_Profile_Annotation_Type;
  Status              :    out DCE_Status.Status_Type;
  Use_Default_Element : in     boolean := FALSE);
-- ****************************************************************************
-- Adds an element to a profile; creating the entry if necessary.
--
-- Input:
--   Profile_Name_Syntax : The syntax used for the Profile_Name parameter.
--                         Specify NS_SYNTAX_DEFAULT to use the value found in
--                         the RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Profile_Name        : The profile name to which the element will be added
--                         (global or cell-relative name)
--   Interface_ID        : The interface id of the element to add to the profile
--   Member_Name_Syntax  : The syntax used for Member_Name parameter. Specify
--                         NS_SYNTAX_DEFAULT to use the value found in the 
--                         RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Member_Name         : The name of the member to include in the new profile
--                         element (global or cell-relative name)
--   Priority            : The relative priority for using the new profile
--                         element during the import and lookup operations.
--   Annotation          : An annotation string
--   Use_Default_Element : If TRUE, add or replace the default element in the
--                         profile, ignoring the Interface_ID and Priority
--                         parameters supplied.
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_invalid_priority
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_profile_elt_add(
--          unsigned32 profile_name_syntax,
--          unsigned_char_t *profile_name,
--          rpc_if_id_p_t if_id,
--          unsigned32 member_name_syntax,
--          unsigned_char_t *member_name,
--          unsigned32 priority,
--          unsigned_char_p_t annotation,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Profile_Elt_Inq_Begin(
  Profile_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Profile_Name        : in     NS_Profile_Name_Type;
  Inquiry_Type        : in     DCE_Base.NS_Profile_Inquiry_Type;
  Interface_ID        : in     RPC_Interface_ID_Type;
  Version_Option      : in     DCE_Base.Version_Option_Type;
  Member_Name_Syntax  : in     DCE_Base.NS_Syntax_Type;
  Member_Name         : in     NS_Member_Name_Type;
  Inquiry_Context     :    out RPC_NS_Handle_Type;
  Status              :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Adds an element to a profile; creating the entry if necessary.
--
-- Input:
--   Profile_Name_Syntax : The syntax used for the Profile_Name parameter.
--                         Specify NS_SYNTAX_DEFAULT to use the value found in
--                         the RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Profile_Name        : The profile name to view (global or cell-relative
--                         name)
--   Inquiry_Type        : The type of inquiry to perform on the profile
--   Interface_ID        : The interface identifier of the profile elements to
--                         be returned by RPC_NS_Profile_Elt_Next().
--   Member_Name_Syntax  : The syntax used for the Member_Name parameter. Specify
--                         NS_SYNTAX_DEFAULT to use the value found in the 
--                         RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Member_Name         : The name of the member to search for in the profile
--                         elements (global or cell-relative name)
--
-- Output:
--   Inquiry_Context : The inquiry context for use with the routines
--                     RPC_NS_Profile_Elt_Inq_Next() and
--                     RPC_NS_Profile_Elt_Inq_Done()
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_incomplete_name
--     rpc_s_invalid_inquiry_type
--     rpc_s_invalid_name_syntax
--     rpc_s_invalid_vers_option
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_profile_elt_inq_begin(
--          unsigned32 profile_name_syntax,
--          unsigned_char_p_t profile_name,
--          unsigned32 inquiry_type,
--          rpc_if_id_p_t if_id,
--          unsigned32 if_vers_option,
--          unsigned32 member_name_syntax,
--          unsigned_char_t *member_name,
--          rpc_ns_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Profile_Elt_Inq_Done(
  Inquiry_Context : in out RPC_NS_Handle_Type;
  Status          :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Deletes the inquiry context for a profile.
--
-- Input:
--   Inquiry_Context : The inquiry context to delete. If successful, set to NULL
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_ns_handle
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_profile_elt_inq_done(
--          rpc_ns_handle_t *inquiry_context,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Profile_Elt_Inq_Next(
  Inquiry_Context    : in     RPC_NS_Handle_Type;
  Interface_ID       :    out RPC_Interface_ID_Type;
  Member_Name        :    out NS_Member_Name_Type;
  Priority           :    out DCE_Base.NS_Element_Priority_Type;
  Annotation         :    out NS_Profile_Annotation_Type;
  Status             :    out DCE_Status.Status_Type;
  No_Member_Name     : in     boolean := FALSE;
  No_Annotation      : in     boolean := FALSE);
-- ****************************************************************************
-- Returns one element at a time from a profile.
--
-- Input:
--   Inquiry_Context : The inquiry context
--
-- Output:
--   Interface_ID : The interface identifier of the profile element
--   Member_Name  : The profile element's member name
--   Priority     : The relative priority of the profile element
--   Annotation   : The annotation string
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_class_version_mismatch
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_ns_handle
--     rpc_s_name_service_unavailable
--     rpc_s_no_more_elements
--     rpc_s_no_ns_permission
--     rpc_s_not_rpc_entry
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_profile_elt_inq_next(
--          rpc_ns_handle_t inquiry_context,
--          rpc_if_id_t *if_id,
--          unsigned_char_t **member_name,
--          unsigned32 *priority,
--          unsigned_char_t **annotation,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_NS_Profile_Elt_Remove(
  Profile_Name_Syntax : in     DCE_Base.NS_Syntax_Type;
  Profile_Name        : in     NS_Profile_Name_Type;
  Interface_ID        : in     RPC_Interface_ID_Type;
  Member_Name_Syntax  : in     DCE_Base.NS_Syntax_Type;
  Member_Name         : in     NS_Member_Name_Type;
  Status              :    out DCE_Status.Status_Type;
  Use_Default_Element : in     boolean := FALSE);
-- ****************************************************************************
-- Removes an element from a profile.
--
-- Input:
--   Profile_Name_Syntax : The syntax used for the Profile_Name parameter.
--                         Specify NS_SYNTAX_DEFAULT to use the value found in
--                         the RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Profile_Name        : The profile name from which to remove an element
--                         (global or cell-relative name)
--   Interface_ID        : The interface identifier of the profile elements to
--                         remove.
--   Member_Name_Syntax  : The syntax used for the Member_Name parameter. Specify
--                         NS_SYNTAX_DEFAULT to use the value found in the 
--                         RPC_DEFAULT_ENTRY_SYNTAX environment variable.
--   Member_Name         : The name of the member in the profile element to
--                         remove (global or cell-relative name)
--   Use_Default_Element : If TRUE, add or replace the default element in the
--                         profile, ignoring the Interface_ID and Priority
--                         parameters supplied.
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_entry_not_found
--     rpc_s_incomplete_name
--     rpc_s_invalid_name_syntax
--     rpc_s_name_service_unavailable
--     rpc_s_no_ns_permission
--     rpc_s_profile_element_not_found
--     rpc_s_unsupported_name_syntax
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ns_profile_elt_remove(
--          unsigned32 profile_name_syntax,
--          unsigned_char_t *profile_name,
--          rpc_if_id_p_t if_id,
--          unsigned32 member_name_syntax,
--          unsigned_char_t *member_name,
--          unsigned32 *status);
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_Object_*  /////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_Object_Inq_Type(
  Obj_UUID         : in     UUID_Type;
  Type_UUID        :    out UUID_Type;
  Status           :    out DCE_Status.Status_Type;
  Use_NIL_Obj_UUID : in     boolean := FALSE;
  No_Return_Type   : in     boolean := FALSE);
-- ****************************************************************************
-- This will return the registered type UUID of the Object UUID.
--
-- Input:
--   Obj_UUID         : The object UUID
--   Use_NIL_Obj_UUID : If TRUE, replace the Obj_UUID with a NIL UUID
--   No_Return_Type   : If TRUE, do not return the type UUID
--
-- Output:
--   Type_UUID : The registered type UUID of the object UUID
--
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_object_not_found
--     uuid_s_bad_version
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_object_inq_type(
--          uuid_t *obj_uuid,
--          uuid_t *type_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Object_Set_Type(
  Obj_UUID          : in     UUID_Type;
  Type_UUID         : in     UUID_Type;
  Status            :    out DCE_Status.Status_Type;
  Use_NIL_Type_UUID : in     boolean := FALSE);
-- ****************************************************************************
-- This will register the type of the Object UUID.
--
-- Input:
--   Obj_UUID          : The object UUID
--   Type_UUID         : The type of the object UUID
--   Use_NIL_Type_UUID : If TRUE, replace the Obj_UUID with a NIL UUID
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_already_registered
--     rpc_s_invalid_object
--     uuid_s_bad_version
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_object_set_type(
--          uuid_t *obj_uuid,
--          uuid_t *type_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

--procedure RPC_Object_Set_Inq_Function(
--  RPC_Object_Inq_Fn_Address : in     DCE_Base.Function_Pointer_Type;
--  Status                    :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Registers a function that determines the type of the Object UUID.
--
-- Input:
--   RPC_Object_Inq_Fn_Address : The 'ADDRESS of the instantiation of
--     the generic function RPC_Object_Inq_Fn(). Use System.NULL_ADDRESS
--     to unregister a previously registered function; the default RPC runtime
--     function will be used in its place.
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declarations:
--
--   void rpc_object_set_inq_fn(
--          rpc_object_inq_fn_t inquiry_fn,
--          unsigned32 *status);
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_ProtSeq_*  ////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

function RPC_Protseq_Vector_Count(
  Protseq_Vector : in RPC_Protseq_Vector_Type) return natural;
-- ****************************************************************************
-- Returns the number of elements in the vector of binding handles.
--
-- Input:
--   Protseq_Vector : A vector of protocol sequences
--
-- Return values:
--   The number of elements in the vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

function RPC_Protseq_Vector_Element(
  Protseq_Vector : in RPC_Protseq_Vector_Type;
  Element_Number : in positive := 1
  ) return Protocol_Sequence_Type;
-- ****************************************************************************
-- Returns the specified element from the vector of protocol sequences.
--
-- Input:
--   Protseq_Vector : A vector of protocol sequences
--   Element_Number : The element number (index value) to return
--
-- Return Value:
--   The protocol sequence
--
-- Exceptions:
--   CONSTRAINT_ERROR : Raised if Element_Number is greater than the number
--                      of elements in the vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

procedure RPC_Protseq_Vector_Free(
  Protseq_Vector : in     RPC_Protseq_Vector_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Free the memory used by the protocol sequence vector.
--
-- Input:
--   Protseq_Vector : A vector of protocol sequences supported by the RPC
--                    runtime and the operating system
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_protseq_vector_free(
--          rpc_protseq_vector_t **protseq,
--          unsigned32 *status);
--          
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_Server_*  /////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_Server_Inq_Bindings(
  Binding_Vector : out RPC_Binding_Vector_Type;
  Status         : out DCE_Status.Status_Type);
-- ****************************************************************************
-- Returns a vector of binding handles.
--
-- Input:
--   None
--
-- Output:
--   Binding_Vector : The vector of binding handles
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_no_bindings
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_inq_binding(
--          rpc_binding_vector_t **binding_vector,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Inq_IF(
  Interface_Handle : in     RPC_Interface_Handle_Type;
  Mgr_Type_UUID    : in     UUID_Type;
  Mgr_EPV          :    out RPC_Manager_EPV_Type;
  Status           :    out DCE_Status.Status_Type;
  Use_NIL_UUID     : in     boolean := FALSE);
-- ****************************************************************************
-- Returns a manager endpoint vector registered for an interface.
--
-- Input:
--   Interface_Handle  : Interface handle
--   Mgr_Type_UUID     : The type UUID for the manager whose EPV pointer is
--                       returned in the Mgr_EPV parameter.
--   Use_NIL_UUID      : If TRUE, return the manager whose EPV pointer which is
--                       registered for the Interface_Handle and the NIL type
--                       UUID
--
-- Output:
--   Mgr_EPV : The address of the manager EPV which is registered for the
--             Interface_Handle and the Mgr_Type_UUID
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_unknown_if
--     rpc_s_unknown_mgr_type
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_inq_if(
--          rpc_if_handle_t if_handle,
--          uuid_t *mgr_type_uuid,
--          rpc_mgr_epv_t *mgr_epv,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Listen(
  Max_Calls_Exec : in     DCE_Base.Unsigned32;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells the DCE RPC runtime to listen for remote procedure calls for the SERVER.
--
-- Input:
--   Max_Calls_Exec : Maximum number of concurrently executing RPCs
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_already_listening
--     rpc_s_max_calls_to_small
--     rpc_s_no_protseqs_registered
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_listen(
--          unsigned32 max_calls_exec,
--          unsigned32 *status);
--
-- ****************************************************************************


procedure RPC_Server_Register_Auth_Info(
  Server_Princ_Name    : in     Principal_Name_Type;
  Authn_Service        : in     DCE_Base.RPC_Authentication_Service_Type;
  Get_Key_Function     : in     DCE_Base.Function_Pointer_Type;
  Key_Function_Arg     : in     System.Address;
  Status               :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells the DCE RPC runtime to use all supported protocol sequences for
-- receiving remote procedure calls for the SERVER.
--
-- Input:
--  Server_Princ_Name : The server principal name to use for RPC authentication
--  Authn_Service     : The authentication service
--  Get_Key_Function  : The address of the function that returns encryption keys
--  Key_Function_Arg  : The address of an optional argument to pass to the
--                      Get_Key_Function
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_unknown_authn_service
--     rpc_s_key_func_not_allowed
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_register_auth_info(
--          unsigned_char_t *server_princ_name,
--          unsigned32 authn_svc,
--          rpc_auth_key_retrieval_fn_t *get_key_fn,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Register_IF(
  Interface_Handle : in     RPC_Interface_Handle_Type;
  Mgr_Type_UUID    : in     UUID_Type;
  Mgr_EPV          : in     RPC_Manager_EPV_Type;
  Status           :    out DCE_Status.Status_Type;
  Use_NIL_UUID     : in     boolean := TRUE);
-- ****************************************************************************
-- Registers an interface with the DCE RPC.
--
-- Input:
--   Interface_Handle  : Interface handle
--   Mgr_Type_UUID     : The type UUID to associate with the Mgr_EPV.
--   Mgr_EPV           : The address of the manager's EPV
--   Use_NIL_UUID      : If TRUE, register a NIL UUID with the Interface_Handle
--   Use_Default_EPV   : If TRUE, use the default EPV
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_type_already_registered
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_register_if(
--          rpc_if_handle_t if_handle,
--          uuid_t *mgr_type_uuid,
--          rpc_mgr_epv_t *mgr_epv,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Unregister_IF(
  Interface_Handle        : in     RPC_Interface_Handle_Type;
  Mgr_Type_UUID           : in     UUID_Type;
  Status                  :    out DCE_Status.Status_Type;
  Remove_All_IF_With_UUID : in     boolean := FALSE;
  Remove_IF_With_All_UUID : in     boolean := FALSE);
-- ****************************************************************************
-- Registers an interface with the DCE RPC.
--
-- Input:
--   Interface_Handle        : Interface handle
--   Mgr_Type_UUID           : The type UUID for the Mgr_EPV to remove.
--   Remove_All_IF_With_UUID : If TRUE, remove ALL interfaces previously
--                             registered with the the Mgr_Type_UUID
--   Remove_IF_With_All_UUID : If TRUE, remove only the specified
--                             Interface_Handle for ALL previously registered
--                             with the Mgr_Type_UUID
--   Remove_All_NIL_IF       : If TRUE, remove default manager EPV, leaving only
--                             manager EPVs with non-NIL type UUID
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_unknown_if
--     rpc_s_unknown_mgr_type
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_unregister_if(
--          rpc_if_handle_t if_handle,
--          uuid_t *mgr_type_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Use_All_Protseqs(
  Max_Call_Requests : in     DCE_Base.Unsigned32;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells the DCE RPC runtime to use all supported protocol sequences for
-- receiving remote procedure calls for the SERVER.
--
-- Input:
--   Max_Call_Requests : Maximum number of concurrent RPC requests that the
--                       SERVER can accept
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_create_socket
--     rpc_s_max_descs_exceeded
--     rpc_s_no_protseqs
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_use_all_protseqs(
--          unsigned32 max_call_requests,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Use_All_Protseqs_IF(
  Max_Call_Requests : in     DCE_Base.Unsigned32;
  Interface_Handle  : in     RPC_Interface_Handle_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells the DCE RPC runtime to use all supported protocol sequences and
-- endpoints in the Interface_Handle for receiving remote procedure calls
-- for the SERVER.
--
-- Input:
--   Max_Call_Requests : Maximum number of concurrent RPC requests that the
--                       SERVER can accept
--   Interface_Handle  : Interface handle
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_calls_too_large_for_wk_ep
--     rpc_s_cant_bind_socket
--     rpc_s_cant_create_socket
--     rpc_s_invalid_endpoint_format
--     rpc_s_max_descs_exceeded
--     rpc_s_no_protseqs
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_use_all_protseqs_if(
--          unsigned32 max_call_requests,
--          rpc_if_handle_type if_handle,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Use_Protseq(
  Protocol_Seq      : in     Protocol_Sequence_Type;
  Max_Call_Requests : in     DCE_Base.Unsigned32;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells the DCE RPC runtime to use the specified protocol sequence for
-- receiving remote procedure calls for the SERVER.
--
-- Input:
--   Protocol_Seq      : Protocol sequence to use
--   Max_Call_Requests : Maximum number of concurrent RPC requests that the
--                       SERVER can accept
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_cant_create_socket
--     rpc_s_invalid_rpc_protseq
--     rpc_s_max_descs_exceeded
--     rpc_s_no_protseqs
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_use_protseq(
--          unsigned_char_t *protseq,
--          unsigned32 max_call_requests,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Use_Protseq_EP(
  Protocol_Seq      : in     Protocol_Sequence_Type;
  Max_Call_Requests : in     DCE_Base.Unsigned32;
  Endpoint          : in     string;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells the DCE RPC runtime to use the specified protocol sequence and endpoint
-- for receiving remote procedure calls for the SERVER.
--
-- Input:
--   Protocol_Seq      : Protocol sequence to use
--   Max_Call_Requests : Maximum number of concurrent RPC requests that the
--                       SERVER can accept
--   Endpoint          : Address information for an endpoint
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_calls_too_large_for_wk_ep
--     rpc_s_cant_bind_socket
--     rpc_s_cant_create_socket
--     rpc_s_invalid_endpoint_format
--     rpc_s_invalid_rpc_protseq
--     rpc_s_max_descs_exceeded
--     rpc_s_protseq_not_supported
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_use_protseq_ep(
--          unsigned_char_t *protseq,
--          unsigned32 max_call_requests,
--          unsigned_char_t *endpoint,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_Server_Use_Protseq_IF(
  Protocol_Seq      : in     Protocol_Sequence_Type;
  Max_Call_Requests : in     DCE_Base.Unsigned32;
  Interface_Handle  : in     RPC_Interface_Handle_Type;
  Status            :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Tells the DCE RPC runtime to use the specified protocol sequence and the
-- endpoints in the interface handle for receiving remote procedure calls
-- for the SERVER.
--
-- Input:
--   Protocol_Seq      : Protocol sequence to use
--   Max_Call_Requests : Maximum number of concurrent RPC requests that the
--                       SERVER can accept
--   Interface_Handle  : Interface handle
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_calls_too_large_for_wk_ep
--     rpc_s_cant_bind_socket
--     rpc_s_invalid_endpoint_format
--     rpc_s_invalid_rpc_protseq
--     rpc_s_max_descs_exceeded
--     rpc_s_protseq_not_supported
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_server_use_protseq_if(
--          unsigned_char_t *protseq,
--          unsigned32 max_call_requests,
--          rpc_if_handle_type if_handle,
--          unsigned32 *status);
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_SM_*  /////////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

function RPC_SM_Allocate(
  Size   : in DCE_Base.Unsigned32;
  Status : in DCE_Status.Status_Type
  ) return DCE_Base.Memory_Pointer_Type;
-- ****************************************************************************
-- Allocates memory within the RPC stub memory management scheme.
--
-- Input:
--   Size : Bytes of memory to be allocated
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- Return Value:
--   A pointer to the allocated memory
--
-- DCE RPC Equivalent Declaration:
--
--   idl_void_p_t rpc_sm_allocate(
--                  idl_size_t size,
--                  idl_ulong_int *p_st);
--
-- ****************************************************************************

procedure RPC_SM_Client_Free(
  Node_To_Free : in     DCE_Base.Memory_Pointer_Type;
  Status       :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Free memory returned from a client.
--
-- Input:
--   Node_To_Free : Pointer to memory returned froma client stub
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_client_free(
--          idl_void_p_t p_mem,
--          idl_ulong_int *p_st);
--
-- ****************************************************************************

procedure RPC_SM_Destroy_Client_Context(
  Unusable_Context_Handle : in     DCE_Base.Memory_Pointer_Type;
  Status                  :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Reclaims the client memory resources for a context handle, setting the
-- context handle to null.
--
-- Input:
--   Unusable_Context_Handle : Context handle that can no longer be accessed
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_destroy_client_context(
--          rpc_ss_context_t *p_unusable_context_handle,
--          idl_ulong_int *p_st);
--
-- ****************************************************************************

procedure RPC_SM_Disable_Allocate(
  Status : out DCE_Status.Status_Type);
-- ****************************************************************************
-- Releases resources and allocated memory within the stub memory management
-- scheme.
--
-- Input:
--   None
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_disable_allocate(
--          idl_ulong_int *p_st);
--
-- ****************************************************************************

procedure RPC_SM_Enable_Allocate(
  Status : out DCE_Status.Status_Type);
-- ****************************************************************************
-- Enables the stub memory management environment.
--
-- Input:
--   None
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_enable_allocate(
--          idl_ulong_int *p_st);
--
-- ****************************************************************************

procedure RPC_SM_Free(
  Node_To_Free : in     DCE_Base.Memory_Pointer_Type;
  Status       :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Free memory allocated by the RPC_SM_Allocate() routine.
--
-- Input:
--   Node_To_Free : Pointer to memory alloacted by RPC_SM_Allocate()
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_free(
--          idl_void_p_t node_to_free,
--          idl_ulong_int *p_st);
--
-- ****************************************************************************

function RPC_SM_Get_Thread_Handle(Status : in DCE_Status.Status_Type
  ) return RPC_SS_Thread_Handle_Type;
-- ****************************************************************************
-- Get a thread handle for the stub memory management environment.
--
-- Input:
--   None
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- Return Value:
--   A thread handle
--
-- DCE RPC Equivalent Declaration:
--
--   rpc_ss_thread_handle_t rpc_sm_get_thread_handle(
--                            idl_ulong_int *p_st);
--
-- ****************************************************************************

--procedure RPC_SM_Set_Client_Alloc_Free(
--  ...IN pointer to memory allocator routine;
--  ...IN pointer to memory free routine;
--  Status       :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Sets the memory allocation and freeing mechanisms used by the client stubs.
--
-- Input:
--   ? : pointer to memory allocator routine
--   ? : pointer to memory free routine
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_set_client_alloc_free(
--          idl_void_p_t (*p_allocate)(idl_size_t size),
--          void (*p_free)(idl_void_p_t ptr),
--          idl_ulong_int *p_st);
--
-- ****************************************************************************
 
procedure RPC_SM_Set_Thread_Handle(
  Thread_Handle : in     RPC_SS_Thread_Handle_Type; 
  Status        :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Sets a thread handle for the stub memory management environment.
--
-- Input:
--   Thread_Handle : A thread handle returned by RPC_SM_Get_Thread_Handle()
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_set_thread_handle(
--          rpc_ss_thread_handle_t thread_handle,
--          idl_ulong_int *p_st);
--
-- ****************************************************************************
 
--procedure RPC_SM_Swap_Client_Alloc_Free(
--  ... IN  pointer to new memory allocator routine;
--  ... IN  pointer to new memory free routine;
--  ... OUT address of pointer to old memory allocator routine;
--  ... OUT address of pointer to old memory free routine;
--  Status       :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- Exchanges the current memory allocation and freeing mechanism used by the
-- client stubs with ones supplied by the client.
--
-- Input:
--   ? : pointer to new memory allocator routine
--   ? : pointer to new memory free routine
--
-- Output:
--   ? : address of pointer to old memory allocator routine
--   ? : address of pointer to old memory free routine
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_sm_swap_client_alloc_free(
--           idl_void_p_t (*p_allocate)(idl_size_t size),
--           void (*p_free)(idl_void_p_t ptr),
--           idl_void_p_t (**p_p_old_allocate)(idl_size_t size),
--           void (**p_p_old_free)(idl_void_p_t ptr),
--           idl_ulong_int *p_st);  
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_SS_*  /////////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

RPC_X_NO_MEMORY : exception;

function RPC_SS_Allocate(Size : in DCE_Base.Unsigned32
  ) return DCE_Base.Memory_Pointer_Type;
-- ****************************************************************************
-- Allocates memory within the RPC stub memory management scheme.
--
-- Input:
--   Size : Bytes of memory to be allocated
--
-- Output:
--   None
--
-- Returned Value:
--   A pointer to the allocated memory
--
-- Exceptions:
--   RPC_X_NO_MEMORY : Raised when no memory is available for allocation
--
-- DCE RPC Equivalent Declaration:
--
--   idl_void_p_t rpc_ss_allocate(idl_size_t size);
--
-- ****************************************************************************

procedure RPC_SS_Client_Free(
  Node_To_Free : in DCE_Base.Memory_Pointer_Type);
pragma INTERFACE (C, rpc_ss_client_free);
-- ****************************************************************************
-- Free memory returned from a client.
--
-- Input:
--   Node_To_Free : Pointer to memory returned froma client stub
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_client_free(idl_void_p_t node_to_free);
--
-- ****************************************************************************

procedure RPC_SS_Destroy_Client_Context(
  Unusable_Context_Handle : in DCE_Base.Memory_Pointer_Type);
pragma INTERFACE (C, rpc_ss_destroy_client_context);
-- ****************************************************************************
-- Reclaims the client memory resources for a context handle, setting the
-- context handle to null.
--
-- Input:
--   Unusable_Context_Handle : Context handle that can no longer be accessed
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_destroy_client_context(
--          rpc_ss_context_t *p_unusable_context_handle);
--
-- ****************************************************************************

procedure RPC_SS_Disable_Allocate;
pragma INTERFACE (C, rpc_ss_disable_allocate);
-- ****************************************************************************
-- Releases resources and allocated memory.
--
-- Input:
--   None
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_disable_allocate(void);
--
-- ****************************************************************************

procedure RPC_SS_Enable_Allocate;
-- ****************************************************************************
-- Enables the allocation of memory by the RPC_SS_Allocate() routine when not
-- in manager code.
--
-- Input:
--   None
--
-- Output:
--   None
--
-- Exceptions:
--   RPC_X_NO_MEMORY : Raised when there is insufficient memory available to
--                     set up necessary data structures
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_enable_allocate(void);
--
-- ****************************************************************************

procedure RPC_SS_Free(Node_To_Free : in DCE_Base.Memory_Pointer_Type);
pragma INTERFACE (C, rpc_ss_free);
-- ****************************************************************************
-- Frees memory allocated by the RPC_SS_Allocate() routine.
--
-- Input:
--   Node_To_Free : Pointer to memory allocated by RPC_SS_Allocate()
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_free(idl_void_p_t node_to_free);
--
-- ****************************************************************************

function RPC_SS_Get_Thread_Handle return RPC_SS_Thread_Handle_Type;
pragma INTERFACE (C, rpc_ss_get_thread_handle);
-- ****************************************************************************
-- Gets a thread handle for the manager code before it spawns additional
-- threads, or for the client code when it becomes a server.
--
-- Input:
--   None
--
-- Output:
--   None
--
-- Returned Value:
--   A thread handle
--
-- DCE RPC Equivalent Declaration:
--
--   rpc_ss_thread_handle_t rpc_ss_get_thread_handle(void); 
--
-- ****************************************************************************

--procedure RPC_SS_Set_Client_Alloc_Free(
--  ...IN pointer to memory allocator routine;
--  ...IN pointer to memory free routine);
-- ****************************************************************************
-- Sets the memory allocation and freeing mechanism used by the client stubs,
-- thereby overriding the default routines the client stub uses to manage
-- memory for pointed-to nodes.
--
-- Input:
--   ? : pointer to memory allocator routine
--   ? : pointer to memory free routine
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_set_client_alloc_free(
--          idl_void_p_t (*p_allocate)(idl_size_t size),
--          void (*p_free)(idl_void_p_t ptr) );
--
-- ****************************************************************************

procedure RPC_SS_Set_Thread_Handle(Thread_Handle : in RPC_SS_Thread_Handle_Type);
-- ****************************************************************************
-- Sets the thread handle for either a newly craeted spawned thread or for a
-- server that was formerly a client and is ready to be a client again.
--
-- Input:
--   Thread_Handle : A thread handle returned by RPC_SS_Get_Thread_Handle()
--
-- Output:
--   None
--
-- Exceptions:
--   RPC_X_NO_MEMORY : Raised when there is insufficient memory available to
--                     set up necessary data structures
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_set_thread_handle(
--          rpc_ss_thread_handle_t thread_handle);
--
-- ****************************************************************************
 
--procedure RPC_SS_Swap_Client_Alloc_Free(
--  ... IN  pointer to new memory allocator routine;
--  ... IN  pointer to new memory free routine;
--  ... OUT address of pointer to old memory allocator routine;
--  ... OUT address of pointer to old memory free routine);
-- ****************************************************************************
-- Exchanges the current memory allocation and freeing mechanism used by the
-- client stubs with ones supplied by the client.
--
-- Input:
--   ? : pointer to new memory allocator routine
--   ? : pointer to new memory free routine
--
-- Output:
--   ? : address of pointer to old memory allocator routine
--   ? : address of pointer to old memory free routine
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_ss_swap_client_alloc_free(
--           idl_void_p_t (*p_allocate)(idl_size_t size),
--           void (*p_free)(idl_void_p_t ptr),
--           idl_void_p_t (**p_p_old_allocate)(idl_size_t size),
--           void (**p_p_old_free)(idl_void_p_t ptr),
--           idl_ulong_int *p_st);  
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  RPC_String_Binding_*  /////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure RPC_String_Binding_Display(
  String_Binding : in RPC_String_Binding_Type);
-- ****************************************************************************
-- Display the String_Binding.
--
-- Input:
--   String_Binding : String binding to display, formatted with deliimiters as:
--                    uuid@rpc-protocol-sequence:network-addr[endpoint,options]
--
-- Output:
--   None
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

procedure RPC_String_Binding_Compose(
  UUID_String    : in     UUID_String_Type;
  Protocol_Seq   : in     Protocol_Sequence_Type;
  Network_Addr   : in     string;
  Endpoint       : in     string;
  Options        : in     string;
  String_Binding :    out RPC_String_Binding_Type;
  Status         :    out DCE_Status.Status_Type);
-- ****************************************************************************
-- This will combine the components of a string binding into a string binding
-- handle.
--
-- Input:
--   UUID         : A valid UUID string representation
--   Protocol_Seq : The protocol sequence
--   Network_Addr : The network address. This may be expressed as either an
--                  Internet address (common Internet address notation, such
--                  as 128.10.2.30 or #126.15.1.28) or as a hostname.
--   Endpoint     : The Internet port number. This may be preceeded with an
--                  optional 'endpoint='.
--   Options      : Options. Currently there are NO Internet options.
--
-- NOTE: All strings MUST be null terminated. Specify an empty string
--       ("" & Ascii.NUL) for any input that has no data.
--
-- Output:
--   String_Binding : Formatted with delimiters as follows:
--                    uuid@rpc-protocol-sequence:network-addr[endpoint,options]
--
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_string_binding_compose(
--          unsigned_char_t *obj_uuid,
--          unsigned_char_t *protseq,
--          unsigned_char_t *network_addr,
--          unsigned_char_t *endpoint,
--          unsigned_char_t *options,
--          unsigned_char_t **string_binding,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure RPC_String_Binding_Parse(
  String_Binding : in     RPC_String_Binding_Type;
  UUID_String    :    out UUID_String_Type;
  Protocol_Seq   :    out Protocol_Sequence_Type;
  Network_Addr   :    out string;
  Endpoint       :    out string;
  Options        :    out string;
  Status         :    out DCE_Status.Status_Type;
  No_UUID_String : in     boolean := FALSE;
  No_ProtoSeq    : in     boolean := FALSE;
  No_Network_Addr: in     boolean := FALSE;
  No_Endpoint    : in     boolean := FALSE;
  No_Options     : in     boolean := FALSE);
-- ****************************************************************************
-- This will return, as separate components, the contents of a string binding
--
-- Input:
--   String_Binding : The formatted string binding with delimiters
--   No_UUID_String : If TRUE, returns a NULL UUID string ("" & Ascii.NUL)
--   No_ProtoSeq    : If TRUE, returns a NULL protocol sequence string
--   No_Network_Addr: If TRUE, returns a NULL network address string
--   No_Endpoint    : If TRUE, returns a NULL endpoint string
--   No_Options     : If TRUE, returns a NULL options string
--
-- Output:
--   UUID         : A valid UUID string representation
--   Protocol_Seq : The protocol sequence (ncacn_ip_tcp or ncadg_ip_udp)
--   Network_Addr : The network address. This may be expressed as either an
--                  Internet address (comon Internet address notation, such
--                  as 128.10.2.30 or #126.15.1.28) or as a hostname.
--   Endpoint     : The Internet port number. This may be preceeded with an
--                  optional 'endpoint='.
--   Options      : Options. Currently there are NO Internet options.
--
--                  NOTE: All strings are null terminated.
--
--   Status : The status code, which may be one of:
--     error_status_ok
--     rpc_s_invalid_string_binding
--
-- DCE RPC Equivalent Declaration:
--
--   void rpc_string_binding_parse(
--          unsigned_char_t *string_binding,
--          unsigned_char_t **obj_uuid,
--          unsigned_char_t **protseq,
--          unsigned_char_t **network_addr,
--          unsigned_char_t **endpoint,
--          unsigned_char_t **options,
--          unsigned32 *status);
--
-- ****************************************************************************

-- ////////////////////////////////////////////////////////////////////////////
-- ///////////////////////////  UUID_*  ///////////////////////////////////////
-- ////////////////////////////////////////////////////////////////////////////

procedure UUID_Display(UUID : in UUID_Type);
-- ****************************************************************************
-- Display the contents of the UUID.
-- ****************************************************************************

procedure UUID_Display_String(
  UUID_String : in UUID_String_Type;
  Line_Feed   : in boolean := TRUE);
-- ****************************************************************************
-- Display the contents of the UUID string.
-- ****************************************************************************

procedure UUID_Create(
  UUID   : out UUID_Type;
  Status : out DCE_Status.Status_Type);
-- ****************************************************************************
-- This will create a new UUID.
--
-- Input:
--   None
--
-- Output:
--   UUID : The new UUID, in its binary format
--   Status : The status code, which may be one of:
--     error_status_ok
--     uuid_s_getconf_failure
--     uuid_s_no_address
--     uuid_s_socket_failure
--
-- DCE RPC Equivalent Declaration:
--
--   void uuid_create(
--          uuid_t *uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure UUID_Create_Nil(
  UUID   : out UUID_Type;
  Status : out DCE_Status.Status_Type);
-- ****************************************************************************
-- This will create a new, NIL UUID.
--
-- Input:
--   None
--
-- Output:
--   UUID : The NIL UUID, in its binary format
--   Status : The status code, which may be one of:
--     error_status_ok
--
-- DCE RPC Equivalent Declaration:
--
--   void uuid_create_nil(
--          uuid_t *uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure UUID_To_String(
  UUID             : in     UUID_Type;
  UUID_String      :    out UUID_String_Type;
  Status           :    out DCE_Status.Status_Type;
  Use_NIL_UUID     : in     boolean := FALSE;
  No_String_Return : in     boolean := FALSE);
-- ****************************************************************************
-- This will return a string representation of a binary UUID.
--
-- Input:
--   UUID             : A UUID in its binary format
--   Use_NIL_UUID     : Ignore the UUID supplied, replacing it with a NIL UUID
--   No_String_Return : Do not return a valid UUID string representation
--
-- Output:
--   UUID_String : The string representation of the UUID.
--   Status : The status code, which may be one of:
--     error_status_ok
--     uuid_s_bad_version
--
-- DCE RPC Equivalent Declaration:
--
--   void uuid_to_string(
--          uuid_t *uuid,
--          unsigned_char_t **string_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

procedure UUID_From_String(
  UUID_String      : in     UUID_String_Type;
  UUID             :    out UUID_Type;
  Status           :    out DCE_Status.Status_Type;
  Use_NULL_String  : in     boolean := FALSE);
-- ****************************************************************************
-- This will convert a string representation into a binary UUID.
--
-- Input:
--   UUID_String      : The string representation of the UUID
--   Use_NULL_String  : Ignore the UUID string supplied, replacing it with a
--                      null ("\0") string to create a new, NIL UUID
--
-- Output:
--   UUID             : A UUID in its binary format.
--   Status : The status code, which may be one of:
--     error_status_ok
--     uuid_s_bad_version
--     uuid_s_invalid_string_uuid
--
-- DCE RPC Equivalent Declaration:
--
--   void uuid_to_string(
--          uuid_t *uuid,
--          unsigned_char_t **string_uuid,
--          unsigned32 *status);
--
-- ****************************************************************************

function UUID_Hash(
  UUID   : in UUID_Type;
  Status : in DCE_Status.Status_Type
  ) return DCE_Base.Unsigned16;
-- ****************************************************************************
-- This will create a hash value for the UUID.
--
-- Input:
--   UUID : A UUID in its binary format
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     uuid_s_bad_version
--
-- Returned Value:
--    The hash value
--
-- DCE RPC Equivalent Declaration:
--
--   unsigned16 uuid_hash(
--                uuid_t *uuid,
--                unsigned32 *status);
--
-- ****************************************************************************


function UUID_Compare(
  UUID1         : in UUID_Type;
  UUID2         : in UUID_Type;
  Status        : in DCE_Status.Status_Type;
  Use_NIL_UUID1 : in boolean := FALSE;
  Use_NIL_UUID2 : in boolean := FALSE
  ) return DCE_Base.Signed32;
-- ****************************************************************************
-- This will compare two UUIDs and determine their order.
--
-- Input:
--   UUID1            : A UUID in its binary format.
--   UUID2            : A UUID in its binary format.
--   Use_NIL_UUID1    : Ignore the UUID1 supplied, replacing it with a NIL UUID
--   Use_NIL_UUID2    : Ignore the UUID2 supplied, replacing it with a NIL UUID
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok
--     uuid_s_bad_version
--
-- Returned Value:
--   -1 : UUID1 precedes UUID2      (Also if UUID1 is NIL, UUID is not NIL)
--    0 : UUID1 and UUID2 are equal (Also if UUID1 is NIL, UUID is NIL)
--    1 : UUID1 follows UUID2       (Also if UUID1 is not NIL, UUID is NIL)
--
-- DCE RPC Equivalent Declaration:
--
--   signed32 uuid_compare(
--              uuid_t *uuid1,
--              uuid_t *uuid2,
--              unsigned32 *status);
--
-- ****************************************************************************

function UUID_Equal(
  UUID1  : in UUID_Type;
  UUID2  : in UUID_Type;
  Status : in DCE_Status.Status_Type
  ) return DCE_Base.boolean32;
-- ****************************************************************************
-- This will compare two UUIDs and determine if they are equal.
--
-- Input:
--   UUID1 : A UUID in its binary format.
--   UUID2 : A UUID in its binary format.
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok - Only if returned value is TRUE
--
-- Returned Value:
--    TRUE  : UUID1 and UUID2 are equal
--    FALSE : UUID1 and UUID2 are not equal
--
-- DCE RPC Equivalent Declaration:
--
--   boolean32 uuid_equal(
--               uuid_t *uuid1,
--               uuid_t *uuid2,
--               unsigned32 *status);
--
-- ****************************************************************************

function UUID_is_NIL(
  UUID   : in UUID_Type;
  Status : in DCE_Status.Status_Type
  ) return DCE_Base.boolean32;
-- ****************************************************************************
-- This will determine if the UUID is NIL.
--
-- Input:
--   UUID : A UUID in its binary format.
--
-- Output:
--   Status : The status code, which may be one of:
--     error_status_ok - Only if returned value is TRUE
--     uuid_s_bad_version
--
-- Returned Value:
--    TRUE  : UUID is a NIL UUID
--    FALSE : UUID is not a NIL UUID
--
-- DCE RPC Equivalent Declaration:
--
--   boolean32 uuid_is_nil(
--               uuid_t *uuid,
--               unsigned32 *status);
--
-- ****************************************************************************

function UUID_Vector_Create(UUID_Array : in UUID_Array_Type)
  return UUID_Vector_Type;
-- ****************************************************************************
-- Create and return a UUID Vector from the UUIDs in the array.
--
-- Input:
--   UUID_Array : An array of UUIDs
--
-- Output:
--   None
--
-- Returned value:
--   A vector of UUIDs
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************

procedure UUID_Vector_Free(UUID_Vector : in out UUID_Vector_Type);
-- ****************************************************************************
-- Release the UUID vector resources.
--
-- Input/Output:
--   UUID_vector : A UUID vector
--
-- DCE RPC Equivalent Declaration:
--   None
--
-- ****************************************************************************


private
 
  -- ///////////////////////////////
  -- /// RPC Opaque Pointer Type ///
  -- ///////////////////////////////
  --
  -- /// C define ///
  --
  -- typedef struct {
  --   unsigned32 dummy;
  -- } rpcbase_v_0_0_0;
  --
  -- typedef rpcbase_v_0_0_0 *rpc_opaque_ptr_t;

  type RPCBase_v0_0_0 is record
    Dummy : DCE_Base.Unsigned32;
  end record;
  for RPCBase_v0_0_0 use record
    Dummy at 0 range 0 .. 31;
  end record;
  for RPCBase_v0_0_0'SIZE use 32;

  -- ////////////////////////////////////////////////////////////////
  -- /// The authentication and authorization service credentials ///
  -- ////////////////////////////////////////////////////////////////

  type RPC_Auth_Identity_Type is new RPC_Opaque_Ptr_Type;

  -- ///////////////////////////////
  -- /// RPC Binding Handle Type ///
  -- ///////////////////////////////
  --
  -- /// C define ///
  --
  -- typedef struct {
  --   unsigned short data_offset;
  -- } *handle_t;
  --
  -- typedef handle_t rpc_binding_handle_t;

  type Handle_Type is record
    Data_Offset : DCE_Base.Unsigned16;
  end record;
  for Handle_Type use record
    Data_Offset at 0 range 0 .. 15;
  end record;
  for Handle_Type'SIZE use 16;

  -- ///////////////////////////////
  -- /// RPC Binding Vector Type ///
  -- ///////////////////////////////
  --
  -- /// C define ///
  --
  -- typedef struct {
  --   unsigned32 count;
  --   rpc_binding_handle_t binding_h[1];
  -- } rpc_binding_vector_t;
  --
  -- typedef rpc_binding_vector_t *rpc_binding_vector_p_t;

  type Binding_Vector_Record_Type is record
    Count  : DCE_Base.Unsigned32;
    Vector : RPC_Binding_Handle_Type;
  end record;
  for Binding_Vector_Record_Type use record
    Count  at 0 range 0 .. 31;
    Vector at 4 range 0 .. 31;
  end record;
  for Binding_Vector_Record_Type'SIZE use 64;

  -- ////////////////////////////////////////////
  -- /// RPC Endpoint Map Inquiry Handle Type ///
  -- ////////////////////////////////////////////

  type RPC_EP_Inquiry_Handle_Type is new RPC_Opaque_Ptr_Type;

  -- ////////////////////////////////////////////
  -- /// RPC Interface Identifier Vector Type ///
  -- ////////////////////////////////////////////

  type IF_Id_Vector_Record_Type;
  type RPC_Interface_Id_Vector_Type is access IF_Id_Vector_Record_Type;

  -- /////////////////////////////////////
  -- /// Protocol Sequence Vector Type ///
  -- /////////////////////////////////////
  
  type Protseq_Vector_Record_Type;
  type RPC_Protseq_Vector_Type is access Protseq_Vector_Record_Type;

  -- ///////////////////////////////////////////
  -- /// Server Manager Endpoint Vector Type ///
  -- ///////////////////////////////////////////

  type RPC_Manager_EPV_Type is new System.Address;

  -- ////////////////////////////////
  -- /// Name Service Handle Type ///
  -- ////////////////////////////////

  type RPC_NS_Handle_Type is new RPC_Opaque_Ptr_Type;

  -- //////////////////////////////
  -- /// Statistics Vector Type ///
  -- //////////////////////////////

  type Statistics_Record_Type;
  type RPC_Statistics_Vector_Type is access Statistics_Record_Type;

  -- ///////////////////////////////////////////////////
  -- /// Stub Support Memory Mgmt Thread Handle Type ///
  -- ///////////////////////////////////////////////////

  type RPC_SS_Thread_Handle_Type is new DCE_Base.Memory_Pointer_Type;

  -- ///////////////////////////////
  -- /// RPC String Binding Type ///
  -- ///////////////////////////////

  Max_String_Binding_Length : constant integer := 128;
  type RPC_String_Binding_Type is new string(1 .. Max_String_Binding_Length);

  -- //////////////////////////
  -- /// The UUID Data Type ///
  -- //////////////////////////
  --
  -- /// C define ///
  --
  -- #define ndr_byte unsigned char;
  --
  -- #define idl_byte ndr_byte;
  --
  -- typedef struct {
  --   unsigned32 time_low;
  --   unsigned16 time_mid;
  --   unsigned16 time_hi_and_version;
  --   unsigned8 clock_seq_hi_and_reserved;
  --   unsigned8 clock_seq_low;
  --   idl_byte node[6];
  -- } uuid_t;
  --
  -- typedef uuid_t *uuid_p_t;
  
  type IDL_Byte is new natural range 0 .. 255;
  for IDL_Byte'SIZE use 8;

  Max_Node_Count : constant integer := 6;
  type Node_Array is array(1 .. Max_Node_Count) of IDL_Byte;

  type UUID_Type is record
    Time_Low                  : DCE_Base.Unsigned32 := 0;
    Time_Mid                  : DCE_Base.Unsigned16 := 0;
    Time_Hi_and_Version       : DCE_Base.Unsigned16 := 0;
    Clock_Seq_Hi_and_Reserved : DCE_Base.Unsigned8  := 0;
    Clock_Seq_Low             : DCE_Base.Unsigned8  := 0;
    Node                      : Node_Array := (0, 0, 0, 0, 0, 0);
  end record;

  for UUID_Type use record
    Time_Low                  at 0  range 0  .. 31;
    Time_Mid                  at 4  range 0  .. 15;
    Time_Hi_and_Version       at 4  range 16 .. 31;
    Clock_Seq_Hi_and_Reserved at 8  range 0  .. 7;
    Clock_Seq_Low             at 8  range 8  .. 15;
    Node                      at 10 range 0  .. 47;
  end record;
  for UUID_Type'SIZE use 128;

  -- ////////////////////////
  -- /// UUID Vector Type ///
  -- ////////////////////////
  --
  -- /// C define ///
  --
  -- typedef struct {
  --   unsigned32 count;
  --   uuid_t     *uuid[1];
  -- } uuid_vector_t;

  type UUID_Access_Type is access UUID_Type;

  type UUID_Vector_Record_Type is record
    Count  : DCE_Base.Unsigned32;
    Vector : UUID_Access_Type;
  end record;
  for UUID_Vector_Record_Type use record
    Count  at 0 range 0 .. 31;
    Vector at 4 range 0 .. 31;
  end record;
  for UUID_Vector_Record_Type'SIZE use 64;

  -- /////////////////////////////////////
  -- /// RPC Interface Identifier Type ///
  -- /////////////////////////////////////
  --
  -- /// C define ///
  -- 
  -- typedef struct {
  --   uuid_t uuid;
  --   unsigned16 vers_major;
  --   unsigned16 vers_minor;
  -- } rpc_if_id_t;  
  
  type RPC_Interface_Id_Type is record
    UUID       : UUID_Type;
    Vers_Major : DCE_Base.Unsigned16;
    Vers_Minor : DCE_Base.Unsigned16;
  end record;
  for RPC_Interface_Id_Type use record
    UUID       at 0  range 0  .. 127;
    Vers_Major at 16 range 0  .. 15;
    Vers_Minor at 16 range 16 .. 31;
  end record;
  type RPC_IF_Id_Access_Type is access RPC_Interface_Id_Type;
  
end RPC;