From 0425aadc78680e53000fd0108b540d6eca048516 Mon Sep 17 00:00:00 2001 From: gmcdonald Date: Sat, 13 Feb 2010 01:32:03 +0000 Subject: Moving axis svn, part of TLP move INFRA-2441 git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68 --- include/Makefile.am | 1 + include/axis2_addr.h | 173 +++ include/axis2_addr_mod.h | 77 ++ include/axis2_any_content_type.h | 117 ++ include/axis2_async_result.h | 98 ++ include/axis2_callback.h | 263 ++++ include/axis2_callback_recv.h | 117 ++ include/axis2_client.h | 44 + include/axis2_conf.h | 822 ++++++++++++ include/axis2_conf_ctx.h | 327 +++++ include/axis2_conf_init.h | 74 ++ include/axis2_const.h | 445 +++++++ include/axis2_core_dll_desc.h | 68 + include/axis2_core_utils.h | 113 ++ include/axis2_ctx.h | 147 +++ include/axis2_defines.h | 51 + include/axis2_desc.h | 228 ++++ include/axis2_description.h | 148 +++ include/axis2_disp.h | 174 +++ include/axis2_endpoint_ref.h | 319 +++++ include/axis2_engine.h | 264 ++++ include/axis2_flow.h | 125 ++ include/axis2_flow_container.h | 176 +++ include/axis2_handler.h | 184 +++ include/axis2_handler_desc.h | 274 ++++ include/axis2_http_accept_record.h | 117 ++ include/axis2_http_client.h | 270 ++++ include/axis2_http_header.h | 110 ++ include/axis2_http_out_transport_info.h | 250 ++++ include/axis2_http_request_line.h | 122 ++ include/axis2_http_response_writer.h | 193 +++ include/axis2_http_sender.h | 226 ++++ include/axis2_http_server.h | 66 + include/axis2_http_simple_request.h | 229 ++++ include/axis2_http_simple_response.h | 337 +++++ include/axis2_http_status_line.h | 131 ++ include/axis2_http_svr_thread.h | 121 ++ include/axis2_http_transport.h | 1164 +++++++++++++++++ include/axis2_http_transport_sender.h | 59 + include/axis2_http_transport_utils.h | 487 +++++++ include/axis2_http_worker.h | 115 ++ include/axis2_listener_manager.h | 136 ++ include/axis2_module.h | 161 +++ include/axis2_module_desc.h | 386 ++++++ include/axis2_msg.h | 298 +++++ include/axis2_msg_ctx.h | 2098 +++++++++++++++++++++++++++++++ include/axis2_msg_info_headers.h | 466 +++++++ include/axis2_msg_recv.h | 268 ++++ include/axis2_op.h | 724 +++++++++++ include/axis2_op_client.h | 445 +++++++ include/axis2_op_ctx.h | 307 +++++ include/axis2_options.h | 848 +++++++++++++ include/axis2_out_transport_info.h | 115 ++ include/axis2_phase.h | 352 ++++++ include/axis2_phase_holder.h | 170 +++ include/axis2_phase_meta.h | 89 ++ include/axis2_phase_resolver.h | 275 ++++ include/axis2_phase_rule.h | 216 ++++ include/axis2_phases_info.h | 238 ++++ include/axis2_policy_include.h | 215 ++++ include/axis2_raw_xml_in_out_msg_recv.h | 59 + include/axis2_relates_to.h | 129 ++ include/axis2_simple_http_svr_conn.h | 204 +++ include/axis2_stub.h | 200 +++ include/axis2_svc.h | 1236 ++++++++++++++++++ include/axis2_svc_client.h | 642 ++++++++++ include/axis2_svc_ctx.h | 196 +++ include/axis2_svc_grp.h | 368 ++++++ include/axis2_svc_grp_ctx.h | 194 +++ include/axis2_svc_name.h | 135 ++ include/axis2_svc_skeleton.h | 182 +++ include/axis2_svr_callback.h | 95 ++ include/axis2_thread_mutex.h | 112 ++ include/axis2_transport_in_desc.h | 329 +++++ include/axis2_transport_out_desc.h | 327 +++++ include/axis2_transport_receiver.h | 256 ++++ include/axis2_transport_sender.h | 173 +++ include/axis2_util.h | 61 + 78 files changed, 21531 insertions(+) create mode 100644 include/Makefile.am create mode 100644 include/axis2_addr.h create mode 100644 include/axis2_addr_mod.h create mode 100644 include/axis2_any_content_type.h create mode 100644 include/axis2_async_result.h create mode 100644 include/axis2_callback.h create mode 100644 include/axis2_callback_recv.h create mode 100644 include/axis2_client.h create mode 100644 include/axis2_conf.h create mode 100644 include/axis2_conf_ctx.h create mode 100644 include/axis2_conf_init.h create mode 100644 include/axis2_const.h create mode 100644 include/axis2_core_dll_desc.h create mode 100644 include/axis2_core_utils.h create mode 100644 include/axis2_ctx.h create mode 100644 include/axis2_defines.h create mode 100644 include/axis2_desc.h create mode 100644 include/axis2_description.h create mode 100644 include/axis2_disp.h create mode 100644 include/axis2_endpoint_ref.h create mode 100644 include/axis2_engine.h create mode 100644 include/axis2_flow.h create mode 100644 include/axis2_flow_container.h create mode 100644 include/axis2_handler.h create mode 100644 include/axis2_handler_desc.h create mode 100644 include/axis2_http_accept_record.h create mode 100644 include/axis2_http_client.h create mode 100644 include/axis2_http_header.h create mode 100644 include/axis2_http_out_transport_info.h create mode 100644 include/axis2_http_request_line.h create mode 100644 include/axis2_http_response_writer.h create mode 100644 include/axis2_http_sender.h create mode 100644 include/axis2_http_server.h create mode 100644 include/axis2_http_simple_request.h create mode 100644 include/axis2_http_simple_response.h create mode 100644 include/axis2_http_status_line.h create mode 100644 include/axis2_http_svr_thread.h create mode 100644 include/axis2_http_transport.h create mode 100644 include/axis2_http_transport_sender.h create mode 100644 include/axis2_http_transport_utils.h create mode 100644 include/axis2_http_worker.h create mode 100644 include/axis2_listener_manager.h create mode 100644 include/axis2_module.h create mode 100644 include/axis2_module_desc.h create mode 100644 include/axis2_msg.h create mode 100644 include/axis2_msg_ctx.h create mode 100644 include/axis2_msg_info_headers.h create mode 100644 include/axis2_msg_recv.h create mode 100644 include/axis2_op.h create mode 100644 include/axis2_op_client.h create mode 100644 include/axis2_op_ctx.h create mode 100644 include/axis2_options.h create mode 100644 include/axis2_out_transport_info.h create mode 100644 include/axis2_phase.h create mode 100644 include/axis2_phase_holder.h create mode 100644 include/axis2_phase_meta.h create mode 100644 include/axis2_phase_resolver.h create mode 100644 include/axis2_phase_rule.h create mode 100644 include/axis2_phases_info.h create mode 100644 include/axis2_policy_include.h create mode 100644 include/axis2_raw_xml_in_out_msg_recv.h create mode 100644 include/axis2_relates_to.h create mode 100644 include/axis2_simple_http_svr_conn.h create mode 100644 include/axis2_stub.h create mode 100644 include/axis2_svc.h create mode 100644 include/axis2_svc_client.h create mode 100644 include/axis2_svc_ctx.h create mode 100644 include/axis2_svc_grp.h create mode 100644 include/axis2_svc_grp_ctx.h create mode 100644 include/axis2_svc_name.h create mode 100644 include/axis2_svc_skeleton.h create mode 100644 include/axis2_svr_callback.h create mode 100644 include/axis2_thread_mutex.h create mode 100644 include/axis2_transport_in_desc.h create mode 100644 include/axis2_transport_out_desc.h create mode 100644 include/axis2_transport_receiver.h create mode 100644 include/axis2_transport_sender.h create mode 100644 include/axis2_util.h (limited to 'include') diff --git a/include/Makefile.am b/include/Makefile.am new file mode 100644 index 0000000..e7c4de3 --- /dev/null +++ b/include/Makefile.am @@ -0,0 +1 @@ +TESTS= diff --git a/include/axis2_addr.h b/include/axis2_addr.h new file mode 100644 index 0000000..32521bd --- /dev/null +++ b/include/axis2_addr.h @@ -0,0 +1,173 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_ADDR_H +#define AXIS2_ADDR_H + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * @defgroup axis2_addr WS-Addressing + * @ingroup axis2 + * @{ + * @} + */ + + /** + * @defgroup axis2_addr_consts WS-Addressing related constants + * @ingroup axis2_addr + * @{ + */ + + /** @file axis2_addr.h */ + + /* ====================== Common Message Addressing Properties =========== */ + + /** WS-Addressing Message ID */ +#define AXIS2_WSA_MESSAGE_ID "MessageID" + + /** WS-Addressing Relates To */ +#define AXIS2_WSA_RELATES_TO "RelatesTo" + + /** WS-Addressing Relates To Relationship Type */ +#define AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE "RelationshipType" + + /** WS-Addressing To */ +#define AXIS2_WSA_TO "To" + + /** WS-Addressing From */ +#define AXIS2_WSA_FROM "From" + + /** WS-Addressing Reply To */ +#define AXIS2_WSA_REPLY_TO "ReplyTo" + + /** WS-Addressing Fault To */ +#define AXIS2_WSA_FAULT_TO "FaultTo" + + /** WS-Addressing Action */ +#define AXIS2_WSA_ACTION "Action" + + /** WS-Addressing Mapping */ +#define AXIS2_WSA_MAPPING "wsamapping" + + /* ====================== Common EPR Elements ============================ */ + + /** End Pointer Reference Address */ +#define EPR_ADDRESS "Address" + + /** End Pointer Reference Reference Parameters */ +#define EPR_REFERENCE_PARAMETERS "ReferenceParameters" + + /** End Pointer Reference Service Name */ +#define EPR_SERVICE_NAME "ServiceName" + + /** End Pointer Reference Reference Properties */ +#define EPR_REFERENCE_PROPERTIES "ReferenceProperties" + + /** End Pointer Reference Port Type */ +#define EPR_PORT_TYPE "PortType" + + /** End Pointer Reference Port Name */ +#define EPR_SERVICE_NAME_PORT_NAME "PortName" + + /* ====================== Addressing Submission Version Constants ======== */ + + /** WS-Addressing Namespace for Submission Version */ +#define AXIS2_WSA_NAMESPACE_SUBMISSION "http://schemas.xmlsoap.org/ws/2004/08/addressing" + + /** WS-Addressing Relates To Relationship Type Default Value for Submission Version */ +#define AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION "wsa:Reply" + + /** WS-Addressing Anonymous URL for Submission Version */ +#define AXIS2_WSA_ANONYMOUS_URL_SUBMISSION "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous" + + /** WS-Addressing None URL for Submission Version */ +#define AXIS2_WSA_NONE_URL_SUBMISSION "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/none" + + /* =====================Addressing 1.0 Final Version Constants =========== */ + + /** WS-Addressing Namespace for 1.0 Final Version */ +#define AXIS2_WSA_NAMESPACE "http://www.w3.org/2005/08/addressing" + + /** WS-Addressing Relates To Relationship Type Default Value for 1.0 Final Version */ +#define AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE "http://www.w3.org/2005/08/addressing/reply" + + /** WS-Addressing Anonymous URL for 1.0 Final Version */ +#define AXIS2_WSA_ANONYMOUS_URL "http://www.w3.org/2005/08/addressing/anonymous" + + /** WS-Addressing None URL for 1.0 Final Version */ +#define AXIS2_WSA_NONE_URL "http://www.w3.org/2005/08/addressing/none" + + /* ======================================================================= */ + + /** WS-Addressing Is Reference Parameter Attribute */ +#define AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE "IsReferenceParameter" + + /** WS-Addressing Type Attribute Value */ +#define AXIS2_WSA_TYPE_ATTRIBUTE_VALUE "true" + + /** WS-Addressing Interface Name */ +#define AXIS2_WSA_INTERFACE_NAME "InterfaceName" + + /** WS-Addressing Service/Endpoint Name */ +#define AXIS2_WSA_SERVICE_NAME_ENDPOINT_NAME "EndpointName" + + /** WS-Addressing Policies */ +#define AXIS2_WSA_POLICIES "Policies" + + /** WS-Addressing Metadata */ +#define AXIS2_WSA_METADATA "Metadata" + + /* ======================================================================= */ + + /** WS-Addressing Version */ +#define AXIS2_WSA_VERSION "WSAddressingVersion" + + /** WS-Addressing Default Prefix */ +#define AXIS2_WSA_DEFAULT_PREFIX "wsa" + + /** WS-Addressing Prefixes for faults*/ +#define AXIS2_WSA_PREFIX_FAULT_TO AXIS2_WSA_DEFAULT_PREFIX":"AXIS2_WSA_FAULT_TO + + /** WS-Addressing Prefixes for faults*/ +#define AXIS2_WSA_PREFIX_REPLY_TO AXIS2_WSA_DEFAULT_PREFIX":"AXIS2_WSA_REPLY_TO + + /** WS-Addressing Prefixes for faults*/ +#define AXIS2_WSA_PREFIX_TO AXIS2_WSA_DEFAULT_PREFIX":"AXIS2_WSA_TO + + /** WS-Addressing Prefixes for faults*/ +#define AXIS2_WSA_PREFIX_MESSAGE_ID AXIS2_WSA_DEFAULT_PREFIX":"AXIS2_WSA_MESSAGE_ID + + /** WS-Addressing Prefixes for faults*/ +#define AXIS2_WSA_PREFIX_ACTION AXIS2_WSA_DEFAULT_PREFIX":"AXIS2_WSA_ACTION + + /* ======================================================================= */ + + /** WS-Addressing Param Service Group Context ID */ +#define PARAM_SERVICE_GROUP_CONTEXT_ID "ServiceGroupContextIdFromAddressing" + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_ADDR_H */ diff --git a/include/axis2_addr_mod.h b/include/axis2_addr_mod.h new file mode 100644 index 0000000..be7ad00 --- /dev/null +++ b/include/axis2_addr_mod.h @@ -0,0 +1,77 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_ADDR_MOD_H +#define AXIS2_ADDR_MOD_H + + /** + * @defgroup axis2_mod_addr WS-Addressing Module + * @ingroup axis2 + * @{ + * @} + */ + + /** + * @defgroup axis2_addr_mod addressing module interface + * @ingroup axis2_mod_addr + * @{ + */ + + /** + * @file axis2_addr_mod.h + */ + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +#define ADDR_IN_HANDLER "AddressingInHandler" +#define ADDR_OUT_HANDLER "AddressingOutHandler" + +/** + * Creates Addressing in handler + * @param env pointer to environment struct + * @param name name of handler + * @return returns reference to handler created + */ + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axis2_addr_in_handler_create( + const axutil_env_t * env, + axutil_string_t * name); + + /** + * Creates Addressing out handler + * @param env pointer to environment struct + * @param name name of handler + * @return returns reference to handler created + */ + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axis2_addr_out_handler_create( + const axutil_env_t * env, + axutil_string_t * name); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_ADDR_MOD_H */ diff --git a/include/axis2_any_content_type.h b/include/axis2_any_content_type.h new file mode 100644 index 0000000..eff890f --- /dev/null +++ b/include/axis2_any_content_type.h @@ -0,0 +1,117 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_ANY_CONTENT_TYPE_H +#define AXIS2_ANY_CONTENT_TYPE_H + +/** + * @defgroup axis2_any_content_type any content type + * @ingroup axis2_addr + * any content type acts as a container for any type reference parameters that + * could be associated with an endpoint reference. The values in the map are + * stored in string format, with QNames as key values. + * @{ + */ + +/** + * @file axis2_any_content_type.h + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for axis2_any_content_type */ + typedef struct axis2_any_content_type axis2_any_content_type_t; + + /** + * Creates an instance of any content type struct. + * @param env pointer to environment struct + * @return pointer to the newly created any content type instance + */ + AXIS2_EXTERN axis2_any_content_type_t *AXIS2_CALL + axis2_any_content_type_create( + const axutil_env_t * env); + + /** + * Adds given value to content value map with given QName. + * @param any_content_type pointer to any content type struct + * @param env pointer to environment struct + * @param qname pointer to QName to be used as key + * @param value value string to be added + * @return AXIS2_SUCCESS on success else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_any_content_type_add_value( + axis2_any_content_type_t * any_content_type, + const axutil_env_t * env, + const axutil_qname_t * qname, + const axis2_char_t * value); + + /** + * Gets the value corresponding to the given QName from the content + * value map. + * @param any_content_type pointer to any content type struct + * @param env pointer to environment struct + * @param qname pointer to QName of the corresponding value to be + * retrieved + * @return value string if present, else returns NULL + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_any_content_type_get_value( + const axis2_any_content_type_t * any_content_type, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Gets the map of all values. + * @param any_content_type pointer to any content type struct + * @param env pointer to environment struct + * @return pointer to hash table containing all values, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_any_content_type_get_value_map( + const axis2_any_content_type_t * any_content_type, + const axutil_env_t * env); + + /** + * Frees any content type struct. + * @param any_content_type pointer to any content type struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_any_content_type_free( + axis2_any_content_type_t * any_content_type, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_ANY_CONTENT_TYPE_H */ diff --git a/include/axis2_async_result.h b/include/axis2_async_result.h new file mode 100644 index 0000000..bd6e3d3 --- /dev/null +++ b/include/axis2_async_result.h @@ -0,0 +1,98 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_ASYNC_RESULT_H +#define AXIS2_ASYNC_RESULT_H + +/** + * @defgroup axis2_async_result async result + * @ingroup axis2_client_api + * async_result is used to capture the result of an asynchronous invocation. + * async_result stores the result in the form of a message context instance, + * the user can extract the resulting SOAP envelope from this message context. + * @{ + */ + +/** + * @file axis2_async_result.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_async_result */ + typedef struct axis2_async_result axis2_async_result_t; + + /** + * Gets the SOAP envelope stored inside the resulting message context. + * @param async_result pointer to async result struct + * @param env pointer to environment struct + * @return pointer to the result SOAP envelope in the message context. + */ + AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL + axis2_async_result_get_envelope( + axis2_async_result_t * async_result, + const axutil_env_t * env); + + /** + * Gets the result in the form of message context. + * @param async_result pointer to async result struct + * @param env pointer to environment struct + * @return pointer to result message context + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_async_result_get_result( + axis2_async_result_t * async_result, + const axutil_env_t * env); + + /** + * Frees the async result. + * @param async_result pointer to async result struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_async_result_free( + axis2_async_result_t * async_result, + const axutil_env_t * env); + + /** Creates an async result struct to help deal with results of asynchronous + * invocations. + * @param env pointer to environment struct + * @param result pointer to result message context into which the resulting + * SOAP message is to be captured + * @return newly created async_result struct + */ + AXIS2_EXTERN axis2_async_result_t *AXIS2_CALL + axis2_async_result_create( + const axutil_env_t * env, + axis2_msg_ctx_t * result); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_ASYNC_RESULT_H */ diff --git a/include/axis2_callback.h b/include/axis2_callback.h new file mode 100644 index 0000000..84d0906 --- /dev/null +++ b/include/axis2_callback.h @@ -0,0 +1,263 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_CALLBACK_H +#define AXIS2_CALLBACK_H + +/** + * @defgroup axis2_callback callback + * @ingroup axis2_client_api + * callback represents the callback mechanisms to be used in case of asynchronous + * invocations. It holds the complete status of the invocation, the resulting + * SOAP envelope and also callback specific data. One can define a function + * to be called on complete of the callback as well as a function to be called + * on error. + * @{ + */ + +/** + * @file axis2_callback.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for axis2_callback */ + typedef struct axis2_callback axis2_callback_t; + + /** Type name for function pointer to be called on complete of callback */ + typedef axis2_status_t AXIS2_CALL + axis2_on_complete_func_ptr( + axis2_callback_t *, + const axutil_env_t *); + + /** Type name for function pointer to be called on error of callback */ + typedef axis2_status_t AXIS2_CALL + axis2_on_error_func_ptr( + axis2_callback_t *, + const axutil_env_t *, + int); + + /** + * This function is called once the asynchronous operation is successfully + * completed and the result is available. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @param result pointer to async result + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_invoke_on_complete( + axis2_callback_t * callback, + const axutil_env_t * env, + axis2_async_result_t * result); + + /** + * This function is called once the asynchronous operation fails and + * the failure code returns. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @param exception error code representing the error + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_report_error( + axis2_callback_t * callback, + const axutil_env_t * env, + const int exception); + + /** + * Gets the complete status for the callback. This method is useful + * for polling (busy waiting). + * e.g. + * + * 
+     *          while(!axis2_callback_get_complete(callback, env)
+     *          {
+     *             sleep(10);
+     *          }
+     * do whatever you need here 
+     *
+ * + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if callback is complete, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_callback_get_complete( + const axis2_callback_t * callback, + const axutil_env_t * env); + + /** + * Sets the complete status. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @param complete bool value representing the status + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_set_complete( + axis2_callback_t * callback, + const axutil_env_t * env, + const axis2_bool_t complete); + + /** + * Gets the resulting SOAP envelope. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @return result SOAP envelope if present, else NULL + */ + AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL + axis2_callback_get_envelope( + const axis2_callback_t * callback, + const axutil_env_t * env); + + /** + * Sets the SOAP envelope. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @param envelope pointer to SOAP envelope + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_set_envelope( + axis2_callback_t * callback, + const axutil_env_t * env, + axiom_soap_envelope_t * envelope); + + /** + * Gets the resulting message context. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @return result message context if present, else NULL + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_callback_get_msg_ctx( + const axis2_callback_t * callback, + const axutil_env_t * env); + + /** + * Sets the message context. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_set_msg_ctx( + axis2_callback_t * callback, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Gets error code representing the error. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @return error code representing the error + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_callback_get_error( + const axis2_callback_t * callback, + const axutil_env_t * env); + + /** + * Sets the error code. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @param error error code representing the error + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_set_error( + axis2_callback_t * callback, + const axutil_env_t * env, + const int error); + + /** + * Sets the callback data. + * @param callback pointer to callback struct + * @param data pointer to data + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_set_data( + axis2_callback_t * callback, + void *data); + + /** + * Gets the callback data. + * @param callback pointer to callback struct + * @return pointer to callback data + */ + AXIS2_EXTERN void *AXIS2_CALL + axis2_callback_get_data( + const axis2_callback_t * callback); + + /** + * Sets the on complete callback function. + * @param callback pointer to callback struct + * @param f on complete callback function pointer + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_callback_set_on_complete( + axis2_callback_t * callback, + axis2_on_complete_func_ptr f); + + /** + * Sets the on error callback function. + * @param callback pointer to callback struct + * @param f on error callback function pointer + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_callback_set_on_error( + axis2_callback_t * callback, + axis2_on_error_func_ptr f); + + /** + * Frees callback struct. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_callback_free( + axis2_callback_t * callback, + const axutil_env_t * env); + + /** + * Creates a callback struct. + * @param env pointer to environment struct + * @return pointer to newly created callback struct + */ + AXIS2_EXTERN axis2_callback_t *AXIS2_CALL + axis2_callback_create( + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CALL_BACK_H */ diff --git a/include/axis2_callback_recv.h b/include/axis2_callback_recv.h new file mode 100644 index 0000000..0192c63 --- /dev/null +++ b/include/axis2_callback_recv.h @@ -0,0 +1,117 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_CALLBACK_RECV_H +#define AXIS2_CALLBACK_RECV_H + +/** + * @defgroup axis2_callback_recv callback message receiver. This can be considered as a + * message receiver implementation for application client side which is similar to + * server side message receivers like raw_xml_in_out_msg_recv. Messages received by + * listener manager will finally end up here. + * + * @ingroup axis2_client_api + * callback message receiver, that is used as the message receiver in the + * operation in case of asynchronous invocation for receiving the result. + */ + +/** + * @file axis2_axis2_callback_recv.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_callback_recv */ + typedef struct axis2_callback_recv axis2_callback_recv_t; + + /** + * Gets the base struct which is of type message receiver. + * @param callback_recv pointer to callback receiver struct + * @param env pointer to environment struct + * @return pointer to base message receiver struct + */ + AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL + axis2_callback_recv_get_base( + axis2_callback_recv_t * callback_recv, + const axutil_env_t * env); + + /** + * Frees the callback receiver struct. + * @param callback_recv pointer to callback receiver struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_callback_recv_free( + axis2_callback_recv_t * callback_recv, + const axutil_env_t * env); + + /** + * Adds a callback corresponding to given WSA message ID to message + * receiver. + * @param callback_recv pointer to callback receiver struct + * @param env pointer to environment struct + * @param msg_id message ID indicating which message the callback is + * supposed to deal with + * @param callback callback to be added. callback receiver assumes + * ownership of the callback + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_callback_recv_add_callback( + struct axis2_callback_recv *callback_recv, + const axutil_env_t * env, + const axis2_char_t * msg_id, + axis2_callback_t * callback); + + /** + * Creates a callback receiver struct. + * @param env pointer to environment struct + * @return a pointer to newly created callback receiver struct, + * or NULL on error with error code set in environment's error + */ + AXIS2_EXTERN axis2_callback_recv_t *AXIS2_CALL + axis2_callback_recv_create( + const axutil_env_t * env); + + /** Gets the base message receiver. */ +#define AXIS2_CALLBACK_RECV_GET_BASE(callback_recv, env) \ + axis2_callback_recv_get_base(callback_recv, env) + + /** Frees callback message receiver. */ +#define AXIS2_CALLBACK_RECV_FREE(callback_recv, env) \ + axis2_callback_recv_free(callback_recv, env) + + /** Adds callback to callback message receiver. */ +#define AXIS2_CALLBACK_RECV_ADD_CALLBACK(callback_recv, env, msg_id, callback)\ + axis2_callback_recv_add_callback(callback_recv, env, msg_id, callback) + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CALLBACK_RECV_H */ diff --git a/include/axis2_client.h b/include/axis2_client.h new file mode 100644 index 0000000..d31ab74 --- /dev/null +++ b/include/axis2_client.h @@ -0,0 +1,44 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_CLIENT_H +#define AXIS2_CLIENT_H + +/** + * @file axis2_clinet.h + * @brief + */ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CLIENT_H */ diff --git a/include/axis2_conf.h b/include/axis2_conf.h new file mode 100644 index 0000000..f525603 --- /dev/null +++ b/include/axis2_conf.h @@ -0,0 +1,822 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_CONFIG_H +#define AXIS2_CONFIG_H + +/** + * @defgroup axis2_engine engine + * @ingroup axis2 + * @{ + * @} + */ + +/** + * @defgroup axis2_config configuration + * @ingroup axis2_engine + * Axis2 configuration captures all configuration information. Configuration + * information includes user preferences along with module and + * service information that is either statically configured using axis2.xml + * file, service.xml files and module.xml files or dynamically using the + * functions defined in the ops struct related to this conf struct. + * @{ + */ + +/** + * @file axis2_config.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_conf */ + typedef struct axis2_conf axis2_conf_t; + + struct axis2_msg_recv; + struct axis2_phases_info; + struct axis2_svc_grp; + struct axis2_svc; + struct axis2_op; + struct axis2_dep_engine; + struct axis2_desp; + + /** + * Frees conf struct. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_conf_free( + axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Adds a service group to the configuration. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param svc_grp pointer to service group, conf takes over the + * ownership of the service group + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_add_svc_grp( + axis2_conf_t * conf, + const axutil_env_t * env, + struct axis2_svc_grp *svc_grp); + + /** + * Gets a named service group. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param svc_grp_name name of the service group to be accessed + * @return pointer to service group with the given name if exists, + * else NULL. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_svc_grp *AXIS2_CALL + axis2_conf_get_svc_grp( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * svc_grp_name); + + /** + * Gets all service group added to conf. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return pointer to hash table containing the service groups, returns + * a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_get_all_svc_grps( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Adds a service to configuration. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param svc pointer to service, conf takes over the ownership of the + * service + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_add_svc( + axis2_conf_t * conf, + const axutil_env_t * env, + struct axis2_svc *svc); + + /** + * Gets a service with given name. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param svc_name service name string + * @return pointer to service with the given name if exists, else NULL. + * Returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_conf_get_svc( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + /** + * Removes the named service from configuration. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param name name of service to be removed + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_remove_svc( + axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Adds a parameter to configuration. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param param pointer to parameter struct to be added + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_add_param( + axis2_conf_t * conf, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets a parameter with the given name. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param name name of the parameter to be accessed + * @return pointer to parameter with the given name if exists, else NULL. + * Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_conf_get_param( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Gets all the parameters added to the configuration. + * @param conf pointer to conf struct + * @param env pointer to environment + * @return pointer to array list containing parameters if exists, + * else NULL. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_conf_get_all_params( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Checks if the named parameter is locked. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param param_name name of the parameter + * @return AXIS2_TRUE if parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_conf_is_param_locked( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Gets in transport corresponding to the given transport QName. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param qname QName of transport + * @return pointer to transport in description if exists, + * else NULL. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL + + axis2_conf_get_transport_in( + const axis2_conf_t * conf, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Adds a transport in description. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param transport pointer to transport in description. conf assumes + * ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_add_transport_in( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_transport_in_desc_t * transport, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Gets out transport corresponding to the given transport QName. + * @param conf pointer to conf struct + * @param env pointer to environment strcut + * @param qname pointer to transport qname + * @return pointer to transport out description if exists, + * else NULL. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL + + axis2_conf_get_transport_out( + const axis2_conf_t * conf, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Adds a transport out description. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param transport pointer to transport out description. conf assumes + * ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_add_transport_out( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_transport_out_desc_t * transport, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Gets all in transports. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return hash table containing all transport in descriptions. + * Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_transport_in_desc_t **AXIS2_CALL + + axis2_conf_get_all_in_transports( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets all out transports. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return hash table containing all transport out descriptions. + * Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_transport_out_desc_t **AXIS2_CALL + + axis2_conf_get_all_out_transports( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets a module with given QName. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param qname pointer to qname + * @return module description corresponding to the given qname + */ + AXIS2_EXTERN struct axis2_module_desc *AXIS2_CALL + axis2_conf_get_module( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Gets the list of engaged modules. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the array list of engaged modules. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_conf_get_all_engaged_modules( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets the in phases up to and including port dispatch phase. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the array list of in phases up to post dispatch + * inclusive. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_conf_get_in_phases_upto_and_including_post_dispatch( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets the out flow. Out flow is a list of phases invoked in the out + * path of execution of the engine. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the array list of out flow phases. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_conf_get_out_flow( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets the in fault flow. In fault flow is a list of phases invoked in + * the in path of execution, if some fault happens. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the array list of in fault flow phases. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_conf_get_in_fault_flow( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets the out fault flow. Out fault flow is a list of phases invoked in + * the out path of execution, if some fault happens. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the array list of out fault flow phases. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_conf_get_out_fault_flow( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets faulty services. A faulty service is a service that does not + * meet the service configuration criteria or a service with errors in + * the service dynamic link library. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the hash table of faulty services. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_get_all_faulty_svcs( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets faulty modules. A faulty module is a module that does not + * meet the module configuration criteria or a module with errors in + * the service dynamic link library. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the hash table of faulty modules. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_get_all_faulty_modules( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets all the list of services loaded into configuration. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the hash table of services. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_get_all_svcs( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets all the list of services that need to be loaded into configuration + * at the start up of the axis2 engine. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the hash table of services. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_get_all_svcs_to_load( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Checks is the named module is engaged. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param module_name pointer to QName representing the module name + * @return AXIS2_TRUE if named module is engaged, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_conf_is_engaged( + axis2_conf_t * conf, + const axutil_env_t * env, + const axutil_qname_t * module_name); + + /** + * Gets phases information struct. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to the struct containing phases information. + * Returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_phases_info *AXIS2_CALL + + axis2_conf_get_phases_info( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Sets phases information struct. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param phases_info pointer to phases_info struct. conf assumes + * ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_phases_info( + axis2_conf_t * conf, + const axutil_env_t * env, + struct axis2_phases_info *phases_info); + + /** + * Adds message receiver with the given key. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param key key string with which the message receive is to be added + * @param msg_recv pointer to message receiver + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_add_msg_recv( + axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * key, + struct axis2_msg_recv *msg_recv); + + /** + * Gets message receiver with the given key. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param key key string corresponding to the message receiver to + * be retrieved + * @return pointer to the message receiver with the given key if it + * exists, else null. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL + axis2_conf_get_msg_recv( + const axis2_conf_t * conf, + const axutil_env_t * env, + axis2_char_t * key); + + /** + * Sets the list of out phases. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param out_phases pointer to array list of the phases. conf assumes + * ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_out_phases( + axis2_conf_t * conf, + const axutil_env_t * env, + axutil_array_list_t * out_phases); + + /** + * Gets the list of out phases. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return pointer to array list of out phases. Returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_conf_get_out_phases( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Sets fault phases for in path. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param list pointer to array list of phases + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_in_fault_phases( + axis2_conf_t * conf, + const axutil_env_t * env, + axutil_array_list_t * list); + + /** + * Sets fault phases for out path. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param list pointer to array list of phases + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_out_fault_phases( + axis2_conf_t * conf, + const axutil_env_t * env, + axutil_array_list_t * list); + + /** + * Gets all modules configured, + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return a pointer to hash table containing the list of modules. + * Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_get_all_modules( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Adds a module. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param module pointer to module struct to be added + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_add_module( + axis2_conf_t * conf, + const axutil_env_t * env, + struct axis2_module_desc *module); + + /** + * Sets the default dispatchers. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_conf_set_default_dispatchers( + axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Sets a custom dispatching phase. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param dispatch pointer to phase to be dispatched + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_dispatch_phase( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_phase_t * dispatch); + + /** + * Gets the repository location. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return returns repository location as a string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_conf_get_repo( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Sets the repository location. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param axis2_repo repository location as a string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_repo( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_char_t * axis2_repo); + + + /** + * Gets the axis2.xml location. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @return returns repository location as a string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_conf_get_axis2_xml( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Sets the axis2.xml location. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param axis2_xml repository location as a string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_axis2_xml( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_char_t * axis2_xml); + + /** + * Engages the named module. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param module_ref pointer to the QName of the module to be engaged + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_engage_module( + axis2_conf_t * conf, + const axutil_env_t * env, + const axutil_qname_t * module_ref); + + /** + * Sets the deployment engine. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param dep_engine pointer to dep_engine struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_dep_engine( + axis2_conf_t * conf, + const axutil_env_t * env, + struct axis2_dep_engine *dep_engine); + + /** + * Gets the default module version for the named module. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param module_name module name string + * @return default module version as a string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_conf_get_default_module_version( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * module_name); + + /** + * Gets the default module reference for the named module. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param module_name module name string + * @return pointer to the module description struct corresponding to + * the given name + */ + AXIS2_EXTERN struct axis2_module_desc *AXIS2_CALL + + axis2_conf_get_default_module( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * module_name); + + /** + * Adds a default module version for the named module. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param module_name name of the module + * @param module_version default version for the module + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_conf_add_default_module_version( + axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * module_name, + const axis2_char_t * module_version); + + /** + * Engages the module with the given version. + * @param conf pointer to conf struct + * @param env pointer to environment struct + * @param module_name name of the module to be engaged + * @param version_id version of the module to be engaged + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_conf_engage_module_with_version( + axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * module_name, + const axis2_char_t * version_id); + + /** + * Creates configuration struct. + * @param env pointer to environment struct + * @return pointer to newly created configuration + */ + AXIS2_EXTERN axis2_conf_t *AXIS2_CALL + axis2_conf_create( + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_conf_get_enable_mtom( + axis2_conf_t * conf, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_enable_mtom( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_bool_t enable_mtom); + + /** + * set a flag to mark conf created by axis2.xml + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_conf_get_axis2_flag( + axis2_conf_t * conf, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_axis2_flag( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_bool_t axis2_flag); + + /*The following two methods are used in Rampart to + *check whether security is engaed. */ + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_conf_get_enable_security( + axis2_conf_t * conf, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_enable_security( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_bool_t enable_security); + + AXIS2_EXTERN void *AXIS2_CALL + axis2_conf_get_security_context( + axis2_conf_t * conf, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_set_security_context( + axis2_conf_t * conf, + const axutil_env_t * env, + void *security_context); + + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + + axis2_conf_get_param_container( + const axis2_conf_t * conf, + const axutil_env_t * env); + + /** + * Gets base description. + * @param conf pointer to message + * @param env pointer to environment struct + * @return pointer to base description struct + */ + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_conf_get_base( + const axis2_conf_t * conf, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t * AXIS2_CALL + axis2_conf_get_handlers(const axis2_conf_t * conf, + const axutil_env_t * env); +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_CONFIG_H */ diff --git a/include/axis2_conf_ctx.h b/include/axis2_conf_ctx.h new file mode 100644 index 0000000..408e6a3 --- /dev/null +++ b/include/axis2_conf_ctx.h @@ -0,0 +1,327 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_CONF_CTX_H +#define AXIS2_CONF_CTX_H + +/** + * @defgroup axis2_conf_ctx configuration context + * @ingroup axis2_context + * configuration context is the holder for all the state information + * related to configuration. It holds all the service group context, service + * context and operation context that exists within an engine instance. + * An engine instance has only one configuration context associated with it + * (Singleton pattern). + * @{ + */ + +/** + * @file axis2_conf_ctx.h + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_conf_ctx */ + typedef struct axis2_conf_ctx axis2_conf_ctx_t; + + struct axis2_conf; + + /** + * Creates a configuration context struct instance. + * @param env pointer to environment struct + * @param conf pointer to configuration, configuration context assumes + * ownership of the configuration + * @return pointer to newly created configuration context + */ + AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL + axis2_conf_ctx_create( + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Sets the configuration associated with the engine instance. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param conf pointer to configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_ctx_set_conf( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Gets the base struct, which is of type context + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @return pointer to context struct, returns a reference not a cloned + * copy + */ + AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL + axis2_conf_ctx_get_base( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env); + + /** + * Gets the configuration of the engine. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @return pointer to configuration struct, returns a reference not a + * cloned copy + */ + AXIS2_EXTERN axis2_conf_t *AXIS2_CALL + axis2_conf_ctx_get_conf( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env); + + /** + * Gets the hash map of operation context instances. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @return pointer to hash map containing all operation contexts + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_ctx_get_op_ctx_map( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env); + + /** + * Gets the hash map of service context instances. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @return pointer to hash map containing all service contexts + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_ctx_get_svc_ctx_map( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env); + + /** + * Gets the hash map of service group context instances. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @return pointer to hash map containing all service group contexts + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_conf_ctx_get_svc_grp_ctx_map( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env); + + /** + * Registers an operation context with the given message ID. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param message_id message id related to the operation context + * @param op_ctx pointer to operation context, conf context assumes + * ownership of the operation context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_ctx_register_op_ctx( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id, + axis2_op_ctx_t * op_ctx); + + /** + * Gets operation context corresponding to the given message ID. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param message_id message ID related to the operation to be retrieved + * @return pointer to operation context related to the given message ID + */ + AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL + axis2_conf_ctx_get_op_ctx( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id); + + /** + * Registers a service context with the given service ID. + * @param conf_ctx pointer t configuration context + * @param env pointer to environment struct + * @param svc_id ID of the service to be added + * @param svc_ctx pointer to service context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_ctx_register_svc_ctx( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_id, + axis2_svc_ctx_t * svc_ctx); + + /** + * Gets service context with the given service ID + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param svc_id service ID + * @return pointer to service context with the given service ID + */ + AXIS2_EXTERN struct axis2_svc_ctx *AXIS2_CALL + axis2_conf_ctx_get_svc_ctx( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_id); + + /** + * Registers a service group context with the given service group ID. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param svc_grp_id service group id + * @param svc_grp_ctx pointer to service group context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_ctx_register_svc_grp_ctx( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_grp_id, + axis2_svc_grp_ctx_t * svc_grp_ctx); + + /** + * Gets service group with the given service group ID. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param svc_grp_id service group id + * @return pointer to service group context with the given ID + */ + AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL + axis2_conf_ctx_get_svc_grp_ctx( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_grp_id); + + /** + * Gets the root working directory. It is in this directory that the + * axis2.xml configuration file is located. The services and modules + * sub folders too are located in this directory. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @return pointer to string containing the root folder name + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_conf_ctx_get_root_dir( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env); + + /** + * Sets the root working directory. It is in this directory that the + * axis2.xml configuration file is located. The services and modules + * sub folders too are located in this directory. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param path string containing the path of root directory + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_ctx_set_root_dir( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * path); + + /** + * Initializes the configuration context. Within this function, it would + * initialize all the service group context, service context and + * operation context instances stored within configuration context. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param conf pointer to configuration struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_ctx_init( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + axis2_conf_t * conf); + + /** + * Frees configuration context struct. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_conf_ctx_free( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env); + + /** + * This method fills the context hierarchy (service group, service and + * operation contexts that is) for the service and operation found in + * the given message context. If the context hierarchy is not already + * built it will create the contexts and build the context hierarchy. + * @param conf_ctx pointer to configuration context + * @param env pointer to environment struct + * @param msg_ctx pointer to message context with service and operation + * for which the context hierarchy is to be built set + * @return pointer to the service group context, which is the root of + * the context hierarchy for given service and operation + */ + AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL + axis2_conf_ctx_fill_ctxs( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Sets a property with the given key. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @param key key string to store the property with + * @param value pointer to property to be stored, context assumes the + * ownership of the property + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_ctx_set_property( + axis2_conf_ctx_t *conf_ctx, + const axutil_env_t * env, + const axis2_char_t * key, + axutil_property_t * value); + + /** + * Gets the property with the given key. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @param key key string + * @return pointer to property struct corresponding to the given key + */ + AXIS2_EXTERN axutil_property_t *AXIS2_CALL + axis2_conf_ctx_get_property( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + const axis2_char_t * key); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CONF_CTX_H */ diff --git a/include/axis2_conf_init.h b/include/axis2_conf_init.h new file mode 100644 index 0000000..8884987 --- /dev/null +++ b/include/axis2_conf_init.h @@ -0,0 +1,74 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_CONF_INIT_H +#define AXIS2_CONF_INIT_H + +/** @defgroup axis2_conf_init configuration initilizing functions + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * Builds the configuration for the Server + * @param env Pointer to environment struct. MUST NOT be NULL + * @param repo_name repository name + * @return pointer to an instance of configuration context properly initialized + */ + AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL + axis2_build_conf_ctx( + const axutil_env_t * env, + const axis2_char_t * repo_name); + + /** + * Builds the configuration for the Server using axis2.xml file. + * @param env Pointer to environment struct. MUST NOT be NULL + * @param file path of the axis2.xml file + * @return pointer to an instance of configuration context properly initialized + */ + AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL + axis2_build_conf_ctx_with_file( + const axutil_env_t * env, + const axis2_char_t * file); + + /** + * Builds the Configuration for the Client + * @param env Pointer to environment struct. MUST NOT be NULL + * @param axis2_home axis2 home for client. + * @return pointer to an instance of configuration context properly initialized + */ + AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL + axis2_build_client_conf_ctx( + const axutil_env_t * env, + const axis2_char_t * axis2_home); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_CONF_INIT_H */ diff --git a/include/axis2_const.h b/include/axis2_const.h new file mode 100644 index 0000000..1923bab --- /dev/null +++ b/include/axis2_const.h @@ -0,0 +1,445 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_CONST_H +#define AXIS2_CONST_H + +/** + * @file axis2.h + * @brief Axis2c specific global declarations + */ + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @defgroup axis2 Axis2/C project + * @{ + * @} + */ + + /** \mainpage Axis2/C API Documentation + * + * \section intro_sec Introduction + * + * This is the API documetation of Axis2/C, a SOAP engine written in C. + * This implementation is based on the popular Axis2 architecture. + *

We welcome your feedback on this implementation and documentation. + * Please send your feedback to + * axis-c-user@ws.apache.org and please remember to prefix the subject + * of the mail with [Axis2]. + * + */ + + /******************************************************************************/ + + /********************Axis2 specific constants**********************************/ + + /******************************************************************************/ + + /** + * Field SOAP_STYLE_RPC_ENCODED + */ +#define AXIOM_SOAP_STYLE_RPC_ENCODED 1000 + + /** + * Field SOAP_STYLE_RPC_LITERAL + */ + + /*#define AXIOM_SOAP_STYLE_RPC_LITERAL 1001 */ + + /** + * Field SOAP_STYLE_DOC_LITERAL_WRAPPED + */ +#define AXIOM_SOAP_STYLE_DOC_LITERAL_WRAPPED 1002 + +#define AXIS2_SCOPE "scope" + + /** + * Field APPLICATION_SCOPE + */ +#define AXIS2_APPLICATION_SCOPE "application" + + /** + * Field SESSION_SCOPE + */ +#define AXIS2_SESSION_SCOPE "session" + + /** + * Field GLOBAL_SCOPE + */ +#define AXIS2_MESSAGE_SCOPE "message" + + /** + * Field PHASE_SERVICE + */ +#define AXIS2_PHASE_SERVICE "service" + + /** + * Field PHASE_TRANSPORT + */ +#define AXIS2_PHASE_TRANSPORT "transport" + + /** + * Field PHASE_GLOBAL + */ +#define AXIS2_PHASE_GLOBAL "global" + + /** + * Field SESSION_CONTEXT_PROPERTY + */ +#define AXIS2_SESSION_CONTEXT_PROPERTY "SessionContext" + + /** + * TRANSPORT constants + */ +#define AXIS2_TRANSPORT_HTTP "http" +#define AXIS2_TRANSPORT_SMTP "smtp" +#define AXIS2_TRANSPORT_TCP "tcp" +#define AXIS2_TRANSPORT_XMPP "xmpp" +#define AXIS2_TRANSPORT_HTTPS "https" +#define AXIS2_TRANSPORT_AMQP "amqp" +#define AXIS2_TRANSPORT_UDP "soap.udp" + typedef enum + { + AXIS2_TRANSPORT_ENUM_HTTP = 0, + AXIS2_TRANSPORT_ENUM_SMTP, + AXIS2_TRANSPORT_ENUM_TCP, + AXIS2_TRANSPORT_ENUM_XMPP, + AXIS2_TRANSPORT_ENUM_HTTPS, + AXIS2_TRANSPORT_ENUM_AMQP, + AXIS2_TRANSPORT_ENUM_UDP, + AXIS2_TRANSPORT_ENUM_MAX + } AXIS2_TRANSPORT_ENUMS; + + /** Service URL prefix */ +#ifndef AXIS2_REQUEST_URL_PREFIX +#define AXIS2_REQUEST_URL_PREFIX "/services" +#endif + +#define AXIS2_LISTSERVICES "listServices" + +#define AXIS2_LIST_SERVICE_FOR_MODULE_ENGAMNET "listop" + + /** + * List service for admin page + */ +#define AXIS2_ADMIN_LISTSERVICES "listService" + +#define AXIS2_LIST_MODULES "listModules" + +#define AXIS2_LIST_GLOABLLY_ENGAGED_MODULES "globalModules" + +#define AXIS2_LIST_PHASES "listPhases" + +#define AXIS2_ENGAGE_GLOBAL_MODULE "engagingglobally" +#define AXIS2_ENGAGE_MODULE_TO_SERVICE "engageToService" + +#define AXIS2_ENGAGE_MODULE_TO_SERVICE_GROUP "engageToServiceGroup" + +#define AXIS2_ADMIN_LOGIN "adminlogin" + +#define AXIS2_LIST_CONTEXTS "listContexts" +#define AXIS2_LOGOUT "logout" + +#define AXIS2_VIEW_GLOBAL_HANDLERS "viewGlobalHandlers" +#define AXIS2_SELECT_SERVICE "selectService" +#define AXIS2_EDIR_SERVICE_PARA "editServicepara" +#define AXIS2_SELECT_SERVICE_FOR_PARA_EDIT "selectServiceParaEdit" +#define AXIS2_VIEW_SERVICE_HANDLERS "viewServiceHandlers" +#define AXIS2_LIST_SERVIC_GROUPS "listServciceGroups" + + /** + * Field SERVICE_MAP + */ +#define AXIS2_SERVICE_MAP "servicemap" +#define AXIS2_SERVICE_GROUP_MAP "serviceGroupmap" + +#define AXIS2_CONFIG_CONTEXT "config_context" +#define AXIS2_ACTION_MAPPING "actionMapping" +#define AXIS2_OUTPUT_ACTION_MAPPING "outputActionMapping" +#define AXI2_FAULT_ACTION_MAPPING "faultActionMapping" + +#define AXIS2_SERVICE "service" + +#define AXIS2_OPEARTION_MAP "opmap" + + /** + * Field Available modules + */ +#define AXIS2_MODULE_MAP "modulemap" + +#define AXIS2_SELECT_SERVICE_TYPE "SELECT_SERVICE_TYPE" + +#define AXIS2_GLOBAL_HANDLERS "axisconfig" +#define AXIS2_SERVICE_HANDLERS "serviceHandlers" + +#define AXIS2_PHASE_LIST "phaseList" + +#define AXIS2_LIST_OPS_FOR_THE_SERVICE "listOperations" + +#define AXIS2_REMOVE_SERVICE "removeService" + +#define AXIS2_ENGAGE_STATUS "engagestatus" + + /** + * Errorness servcie + */ +#define AXIS2_ERROR_SERVICE_MAP "errprservicemap" +#define AXIS2_ERROR_MODULE_MAP "errormodulesmap" + +#define AXIS2_IS_FAULTY "Fault" + +#define AXIS2_MODULE_ADDRESSING "addressing" + +#define AXIS2_USE_SEPARATE_LISTENER "use_listener" + +#define AXIS2_USER_NAME "userName" +#define AXIS2_PASSWORD "password" + + /** + * Field SINGLE_SERVICE + */ +#define AXIS2_SINGLE_SERVICE "singleservice" +#define AXIS2_WSDL_CONTENT "wsdl" +#define AXIS2_REQUEST_WSDL "?wsdl" + +#define AXIS2_STYLE_RPC "rpc" +#define AXIS2_STYLE_DOC "doc" +#define AXIS2_STYLE_MSG "msg" + + typedef enum axis2_wsdl_msg_labels + { + AXIS2_WSDL_MESSAGE_LABEL_IN = 0, + AXIS2_WSDL_MESSAGE_LABEL_OUT, + AXIS2_WSDL_MESSAGE_LABEL_MAX + } axis2_wsdl_msg_labels_t; + + /*********************Message Exchange Pattern Constants***********************/ + + /** + * Field MEP_URI_IN_ONLY + */ +#define AXIS2_MEP_URI_IN_ONLY "http://www.w3.org/2004/08/wsdl/in-only" + +#define AXIS2_MEP_URI_IN_ONLY_WSDL2 "http://www.w3.org/ns/wsdl/in-only" + +#define AXIS2_MEP_CONSTANT_IN_ONLY 10 + + /** + * Field MEP_URI_ROBUST_IN_ONLY + */ +#define AXIS2_MEP_URI_ROBUST_IN_ONLY "http://www.w3.org/2004/08/wsdl/robust-in-only" +#define AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2 "http://www.w3.org/wsdl/robust-in-only" + + +#define AXIS2_MEP_CONSTANT_ROBUST_IN_ONLY 11 + + /** + * Field MEP_URI_IN_OUT + */ +#define AXIS2_MEP_URI_IN_OUT "http://www.w3.org/2004/08/wsdl/in-out" + +#define AXIS2_MEP_URI_IN_OUT_WSDL2 "http://www.w3.org/ns/wsdl/in-out" + +#define AXIS2_MEP_CONSTANT_IN_OUT 12 + + /** + * Field MEP_URI_IN_OPTIONAL_OUT + */ +#define AXIS2_MEP_URI_IN_OPTIONAL_OUT "http://www.w3.org/2004/08/wsdl/in-opt-out" + +#define AXIS2_MEP_URI_IN_OPTIONAL_OUT_WSDL2 "http://www.w3.org/wsdl/in-opt-out" + +#define AXIS2_MEP_CONSTANT_IN_OPTIONAL_OUT 13 + + /** + * Field MEP_URI_OUT_ONLY + */ +#define AXIS2_MEP_URI_OUT_ONLY "http://www.w3.org/2004/08/wsdl/out-only" + +#define AXIS2_MEP_URI_OUT_ONLY_WSDL2 "http://www.w3.org/wsdl/out-only" + +#define AXIS2_MEP_CONSTANT_OUT_ONLY 14 + + /** + * Field MEP_URI_ROBUST_OUT_ONLY + */ +#define AXIS2_MEP_URI_ROBUST_OUT_ONLY "http://www.w3.org/2004/08/wsdl/robust-out-only" + +#define AXIS2_MEP_URI_ROBUST_OUT_ONLY_WSDL2 "http://www.w3.org/wsdl/robust-out-only" + +#define AXIS2_MEP_CONSTANT_ROBUST_OUT_ONLY 15 + + /** + * Field MEP_URI_OUT_IN + */ +#define AXIS2_MEP_URI_OUT_IN "http://www.w3.org/2004/08/wsdl/out-in" + +#define AXIS2_MEP_URI_OUT_IN_WSDL2 "http://www.w3.org/wsdl/out-in" + +#define AXIS2_MEP_CONSTANT_OUT_IN 16 + + /** + * Field MEP_URI_OUT_OPTIONL_IN + */ +#define AXIS2_MEP_URI_OUT_OPTIONAL_IN "http://www.w3.org/2004/08/wsdl/out-opt-in" + +#define AXIS2_MEP_URI_OUT_OPTIONAL_IN_WSDL2 "http://www.w3.org/wsdl/out-opt-in" + +#define AXIS2_MEP_CONSTANT_OUT_OPTIONAL_IN 17 + +#define AXIS2_MEP_CONSTANT_INVALID -1 + + /** + * Field WSDL_MESSAGE_DIRECTION_IN + */ +#define AXIS2_WSDL_MESSAGE_DIRECTION_IN "in" + + /** + * Field WSDL_MESSAGE_DIRECTION_OUT + */ +#define AXIS2_WSDL_MESSAGE_DIRECTION_OUT "out" + + /** + * Field AXIS2_REST_HTTP_LOCATION + */ +#define AXIS2_REST_HTTP_LOCATION "RESTLocation" + + /** + * Field AXIS2_REST_HTTP_METHOD + */ +#define AXIS2_REST_HTTP_METHOD "RESTMethod" + + /** + * Field AXIS2_DEFAULT_REST_HTTP_METHOD + */ +#define AXIS2_DEFAULT_REST_HTTP_METHOD "defaultRESTMethod" + + /** + * Field METHOD_NAME_ESCAPE_CHARACTOR + */ + + /* static const char METHOD_NAME_ESCAPE_CHARACTOR '?' */ + +#define AXIS2_LOGGED "Logged" + + /* static const char SERVICE_NAME_SPLIT_CHAR':' */ + + /*********************Configuration *******************************************/ + +#define AXIS2_ENABLE_REST "enableREST" +#define AXIS2_ENABLE_REST_THROUGH_GET "restThroughGet" + +#define AXIS2_FORCE_PROXY_AUTH "forceProxyAuth" +#define AXIS2_FORCE_HTTP_AUTH "forceHTTPAuth" + +#define AXIS2_PROXY_AUTH_TYPE "proxyAuthType" +#define AXIS2_HTTP_AUTH_TYPE "HTTPAuthType" + + /** + * Constant for Testing Proxy Authentication + */ +#define AXIS2_TEST_PROXY_AUTH "testProxyAuth" + + /** + * Constant for Testing HTTP Authentication + */ +#define AXIS2_TEST_HTTP_AUTH "testHTTPAuth" + + /* add xml declaration */ +#define AXIS2_XML_DECLARATION "xml-declaration" +#define AXIS2_ADD_XML_DECLARATION "insert" + + /* globally enable MTOM */ +#define AXIS2_ENABLE_MTOM "enableMTOM" +#define AXIS2_ATTACHMENT_DIR "attachmentDIR" +#define AXIS2_MTOM_BUFFER_SIZE "MTOMBufferSize" +#define AXIS2_MTOM_MAX_BUFFERS "MTOMMaxBuffers" +#define AXIS2_MTOM_CACHING_CALLBACK "MTOMCachingCallback" +#define AXIS2_MTOM_SENDING_CALLBACK "MTOMSendingCallback" +#define AXIS2_ENABLE_MTOM_SERVICE_CALLBACK "EnableMTOMServiceCallback" + + /* op_ctx persistance */ +#define AXIS2_PERSIST_OP_CTX "persistOperationContext" + +#define AXIS2_EXPOSE_HEADERS "exposeHeaders" + + /******************************************************************************/ + +#define AXIS2_VALUE_TRUE "true" +#define AXIS2_VALUE_FALSE "false" +#define AXIS2_CONTAINER_MANAGED "ContainerManaged" +#define AXIS2_RESPONSE_WRITTEN "CONTENT_WRITTEN" + +#define AXIS2_TESTING_PATH "target/test-resources/" + +#define AXIS2_TESTING_REPOSITORY "target/test-resources/samples" + + /* Indicate whether the axis2 service should be loaded at start up */ +#define AXIS2_LOAD_SVC_STARTUP "loadServiceAtStartup" + + /*************************** REST_WITH_GET ************************************/ + +#define AXIS2_GET_PARAMETER_OP "op" +#define AXIS2_GET_PARAMETER_URL "http://ws.apache.org/goGetWithREST" + + /******************************************************************************/ + +#define AXIS2_NAMESPACE_PREFIX "axis2" +#define AXIS2_NAMESPACE_URI "http://ws.apache.org/namespaces/axis2" + +#define AXIS2_SVC_GRP_ID "ServiceGroupId" + +#define AXIS2_RESPONSE_SOAP_ENVELOPE "Axis2ResponseEnvelope" +#define AXIS2_HANDLER_ALREADY_VISITED "handler_already_visited" +#define AXIS2_IS_SVR_SIDE "axis2_is_svr_side" + +#define AXIS2_SERVICE_DIR "servicesDir" +#define AXIS2_MODULE_DIR "moduleDir" + +#define AXIS2_MESSAGE_ID_PREFIX "urn:uuid:" + +/** Name of anonymous service */ +#define AXIS2_ANON_SERVICE "__ANONYMOUS_SERVICE__" + +/** out-only MEP operation name */ +#define AXIS2_ANON_OUT_ONLY_OP "__OPERATION_OUT_ONLY__" + +/** out-only robust MEP operation name */ +#define AXIS2_ANON_ROBUST_OUT_ONLY_OP "__OPERATION_ROBUST_OUT_ONLY__" + +/** out-in MEP operation name */ +#define AXIS2_ANON_OUT_IN_OP "__OPERATION_OUT_IN__" + +/** wsdl location in repo*/ +#define AXIS2_WSDL_LOCATION_IN_REPO "woden" + +#define AXIS2_SVC_CLIENT_CLOSED "closed" + +#define AXIS2_STATISTICS_COUNT_ARG "stat_count_arg" + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CONST_H */ diff --git a/include/axis2_core_dll_desc.h b/include/axis2_core_dll_desc.h new file mode 100644 index 0000000..e87f8ec --- /dev/null +++ b/include/axis2_core_dll_desc.h @@ -0,0 +1,68 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_CORE_DLL_DESC_H +#define AXIS2_CORE_DLL_DESC_H + +/** + * @file axis2_core_dll_desc.h + * @brief Axis2 Core dll_desc interface + */ + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * @defgroup axis2_core_dll_desc Core DLL description + * @ingroup axis2_core_utils + * @{ + */ + + /* + * For DLL Types, starting index is 10000, and ending + * index is 10999, this is for unique indexing purposes. + * Indexes 10000-10099 are reserved for Axis2 Core. + */ + + /* service dll */ + #define AXIS2_SVC_DLL 10000 + + /* handler dll */ + #define AXIS2_HANDLER_DLL 10001 + + /* message receiver dll */ + #define AXIS2_MSG_RECV_DLL 10002 + + /* module dll */ + #define AXIS2_MODULE_DLL 10003 + + /* transport receiver dll */ + #define AXIS2_TRANSPORT_RECV_DLL 10004 + + /* transport sender dll */ + #define AXIS2_TRANSPORT_SENDER_DLL 10005 + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CORE_DLL_DESC_H */ diff --git a/include/axis2_core_utils.h b/include/axis2_core_utils.h new file mode 100644 index 0000000..6071771 --- /dev/null +++ b/include/axis2_core_utils.h @@ -0,0 +1,113 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_CORE_UTILS_H +#define AXIS2_CORE_UTILS_H + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf; + + /** + * @defgroup axis2_core_utils Core Utils + * @ingroup axis2_core_utils + * @{ + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + + axis2_core_utils_create_out_msg_ctx( + const axutil_env_t * env, + axis2_msg_ctx_t * in_msg_ctx); + + AXIS2_EXTERN void AXIS2_CALL + axis2_core_utils_reset_out_msg_ctx( + const axutil_env_t * env, + axis2_msg_ctx_t * out_msg_ctx); + + AXIS2_EXTERN axutil_qname_t *AXIS2_CALL + + axis2_core_utils_get_module_qname( + const axutil_env_t * env, + const axis2_char_t * name, + const axis2_char_t * version); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_core_utils_calculate_default_module_version( + const axutil_env_t * env, + axutil_hash_t * modules_map, + struct axis2_conf *axis_conf); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_core_utils_get_module_name( + const axutil_env_t * env, + axis2_char_t * module_name); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_core_utils_get_module_version( + const axutil_env_t * env, + axis2_char_t * module_name); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_core_utils_is_latest_mod_ver( + const axutil_env_t * env, + axis2_char_t * module_ver, + axis2_char_t * current_def_ver); + + AXIS2_EXTERN axis2_op_t *AXIS2_CALL + axis2_core_utils_get_rest_op_with_method_and_location(axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_char_t *method, + const axis2_char_t *location, + axutil_array_list_t *param_keys, + axutil_array_list_t *param_values); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_core_utils_prepare_rest_mapping ( + const axutil_env_t * env, + axis2_char_t * url, + axutil_hash_t *rest_map, + axis2_op_t *op_desc); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_core_utils_free_rest_map ( + const axutil_env_t * env, + axutil_hash_t *rest_map); + + + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CORE_UTILS_H */ diff --git a/include/axis2_ctx.h b/include/axis2_ctx.h new file mode 100644 index 0000000..0165ae3 --- /dev/null +++ b/include/axis2_ctx.h @@ -0,0 +1,147 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_CTX_H +#define AXIS2_CTX_H + +/** + * @defgroup axis2_context Context Hierarchy + * @ingroup axis2 + * @{ + * @} + */ + +/** + * @defgroup axis2_ctx context + * @ingroup axis2_context + * context is the base struct of all the context related structs. This struct + * encapsulates the common operations and data for all context types. All the + * context types, configuration, service group, service and operation has the + * base of type context. + * @{ + */ + +/** + * @file axis2_ctx.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_ctx */ + typedef struct axis2_ctx axis2_ctx_t; + + /** + * Creates a context struct. + * @param env pointer to environment struct + * @return pointer to newly created context + */ + AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL + axis2_ctx_create( + const axutil_env_t * env); + + /** + * Sets a property with the given key. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @param key key string to store the property with + * @param value pointer to property to be stored, context assumes the + * ownership of the property + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ctx_set_property( + struct axis2_ctx *ctx, + const axutil_env_t * env, + const axis2_char_t * key, + axutil_property_t * value); + + /** + * Gets the property with the given key. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @param key key string + * @return pointer to property struct corresponding to the given key + */ + AXIS2_EXTERN axutil_property_t *AXIS2_CALL + axis2_ctx_get_property( + const axis2_ctx_t * ctx, + const axutil_env_t * env, + const axis2_char_t * key); + + /** + * Gets the non-persistent map of properties. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @return pointer to the hash map which stores the non-persistent + * properties + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_ctx_get_property_map( + const axis2_ctx_t * ctx, + const axutil_env_t * env); + + /** + * Gets all properties stored within context. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @return pointer to hash table containing all properties + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_ctx_get_all_properties( + const axis2_ctx_t * ctx, + const axutil_env_t * env); + + /** + * Frees context struct. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_ctx_free( + axis2_ctx_t * ctx, + const axutil_env_t * env); + + /** + * Sets non-persistent map of properties. + * @param ctx pointer to context struct + * @param env pointer to environment struct + * @param map pointer to hash map, context assumes ownership of the map + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ctx_set_property_map( + struct axis2_ctx *ctx, + const axutil_env_t * env, + axutil_hash_t * map); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_CTX_H */ diff --git a/include/axis2_defines.h b/include/axis2_defines.h new file mode 100644 index 0000000..aa3e203 --- /dev/null +++ b/include/axis2_defines.h @@ -0,0 +1,51 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_DEFINES_H +#define AXIS2_DEFINES_H + +/** + * @file axis2_defines.h + * @brief Useful definitions, which may have platform concerns + */ + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Axis2 in flow */ +#define AXIS2_IN_FLOW 1 + + /** Axis2 out flow */ +#define AXIS2_OUT_FLOW 2 + + /** Axis2 fault in flow */ +#define AXIS2_FAULT_IN_FLOW 3 + + /** Axis2 fault out flow */ +#define AXIS2_FAULT_OUT_FLOW 4 + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_DEFINES_H */ diff --git a/include/axis2_desc.h b/include/axis2_desc.h new file mode 100644 index 0000000..fe2e9db --- /dev/null +++ b/include/axis2_desc.h @@ -0,0 +1,228 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_DESC_H +#define AXIS2_DESC_H + +/** + * @defgroup axis2_description description + * @ingroup axis2_desc + * Base struct of description hierarchy. Encapsulates common data and functions + * of the description hierarchy. + * @{ + */ + +/** + * @file axis2_desc.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name of struct axis2_desc */ + typedef struct axis2_desc axis2_desc_t; + + struct axis2_policy_include; + struct axis2_msg; + + /** + * Creates a description struct instance. + * @param env pointer to environment struct + * @return pointer to newly created description + */ + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_desc_create( + const axutil_env_t * env); + + /** + * Frees description struct. + * @param desc pointer to description + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_desc_free( + axis2_desc_t * desc, + const axutil_env_t * env); + + /** + * Adds given parameter to the list of parameters. + * @param desc pointer to description + * @param env pointer to environment struct + * @param param pointer to parameter + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_add_param( + axis2_desc_t * desc, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets named parameter. + * @param desc pointer to description + * @param env pointer to environment struct + * @param param_name parameter name string + * @return pointer to named parameter, NULL if it does not exist + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_desc_get_param( + const axis2_desc_t * desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Gets all parameters stored in description. + * @param desc pointer to description + * @param env pointer to environment struct + * @return pointer to array list containing the list of parameters + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_desc_get_all_params( + const axis2_desc_t * desc, + const axutil_env_t * env); + + /** + * Checks if a named parameter is locked. + * @param desc pointer to description + * @param env pointer to environment struct + * @param param_name parameter name string + * @return AXIS2_TRUE if parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_desc_is_param_locked( + const axis2_desc_t * desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Adds child to the description. The type of children is based on the + * level of the description hierarchy. As an example, service has + * children of type operation, service group has children of type + * service + * @param desc pointer to description + * @param env pointer to environment struct + * @param key key with which the child is to be added + * @param child child to be added + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_add_child( + const axis2_desc_t * desc, + const axutil_env_t * env, + const axis2_char_t * key, + const struct axis2_msg *child); + + /** + * Gets all children. + * @param desc pointer to description + * @param env pointer to environment struct + * @return pointer to hash map containing children + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_desc_get_all_children( + const axis2_desc_t * desc, + const axutil_env_t * env); + + /** + * Gets child with given key. + * @param desc pointer to description + * @param env pointer to environment struct + * @param key key with which the child is stored + * @return pointer to child, returned as a void* value, need to cast to + * correct type + */ + AXIS2_EXTERN void *AXIS2_CALL + axis2_desc_get_child( + const axis2_desc_t * desc, + const axutil_env_t * env, + const axis2_char_t * key); + + /** + * Removes the named child. + * @param desc pointer to description + * @param env pointer to environment struct + * @param key key that represents the child to be removed + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_remove_child( + const axis2_desc_t * desc, + const axutil_env_t * env, + const axis2_char_t * key); + + /** + * Sets parent description. + * @param desc pointer to description + * @param env pointer to environment struct + * @param parent pointer to parent description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_set_parent( + axis2_desc_t * desc, + const axutil_env_t * env, + axis2_desc_t * parent); + + /** + * Gets parent description. + * @param desc pointer to description + * @param env pointer to environment struct + * @return parent pointer to parent description + */ + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_desc_get_parent( + const axis2_desc_t * desc, + const axutil_env_t * env); + + /** + * Sets policy include + * @param desc pointer to description + * @param env pointer to environment struct + * @param policy_include policy include to be added to description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_set_policy_include( + axis2_desc_t * desc, + const axutil_env_t * env, + struct axis2_policy_include *policy_include); + + /** + * Gets policy include + * @param desc pointer to description + * @param env pointer to environment struct + * @return returns policy include that was added to description + * @sa axis2_policy_include + */ + AXIS2_EXTERN struct axis2_policy_include *AXIS2_CALL + axis2_desc_get_policy_include( + axis2_desc_t * desc, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_DESC_H */ diff --git a/include/axis2_description.h b/include/axis2_description.h new file mode 100644 index 0000000..3186a8c --- /dev/null +++ b/include/axis2_description.h @@ -0,0 +1,148 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_DESCRIPTION_H +#define AXIS2_DESCRIPTION_H + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * @defgroup axis2_desc description + * @ingroup axis2 + * @{ + * @} + */ + + /** + * @defgroup axis2_desc_constants description related constants + * @ingroup axis2_desc + * @{ + */ + + /** + * @file axis2_description.h + */ + + + /*********************************** Constansts *******************************/ + + /** + * Field EXECUTION_CHAIN_KEY + */ +#define AXIS2_EXECUTION_CHAIN_KEY "EXECUTION_CHAIN_KEY" + + /** + * Field EXECUTION_OUT_CHAIN_KEY + */ +#define AXIS2_EXECUTION_OUT_CHAIN_KEY "EXECUTION_OUT_CHAIN_KEY" + + /** + * Field EXECUTION_FAULT_CHAIN_KEY + */ +#define AXIS2_EXECUTION_FAULT_CHAIN_KEY "EXECUTION_FAULT_CHAIN_KEY" + + /** + * Field MODULEREF_KEY + */ +#define AXIS2_MODULEREF_KEY "MODULEREF_KEY" + + /** + * Field OP_KEY + */ +#define AXIS2_OP_KEY "OP_KEY" + + /** + * Field CLASSLOADER_KEY + */ +#define AXIS2_CLASSLOADER_KEY "CLASSLOADER_KEY" + + /** + * Field CONTEXTPATH_KEY + */ +#define AXIS2_CONTEXTPATH_KEY "CONTEXTPATH_KEY" + + /** + * Field PROVIDER_KEY + */ +#define AXIS2_MESSAGE_RECEIVER_KEY "PROVIDER_KEY" + + /** + * Field STYLE_KEY + */ +#define AXIS2_STYLE_KEY "STYLE_KEY" + + /** + * Field PARAMETER_KEY + */ +#define AXIS2_PARAMETER_KEY "PARAMETER_KEY" + + /** + * Field IN_FLOW_KEY + */ +#define AXIS2_IN_FLOW_KEY "IN_FLOW_KEY" + + /** + * Field OUT_FLOW_KEY + */ +#define AXIS2_OUT_FLOW_KEY "OUT_FLOW_KEY" + + /** + * Field IN_FAULTFLOW_KEY + */ +#define AXIS2_IN_FAULTFLOW_KEY "IN_FAULTFLOW_KEY" + + /** + * Field OUT_FAULTFLOW_KEY + */ +#define AXIS2_OUT_FAULTFLOW_KEY "OUT_FAULTFLOW_KEY" + + /** + * Field PHASES_KEY + */ +#define AXIS2_PHASES_KEY "PHASES_KEY" + + /** + * Field SERVICE_CLASS + */ +#define AXIS2_SERVICE_CLASS "ServiceClass" + + /** + * Field SERVICE_CLASS_NAME + */ +#define AXIS2_SERVICE_CLASS_NAME "SERVICE_CLASS_NAME" + + /******************************************************************************/ + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_DESCRIPTION_H */ diff --git a/include/axis2_disp.h b/include/axis2_disp.h new file mode 100644 index 0000000..2f801b8 --- /dev/null +++ b/include/axis2_disp.h @@ -0,0 +1,174 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_DISP_H +#define AXIS2_DISP_H + +/** + * @defgroup axis2_disp dispatcher + * @ingroup axis2_engine + * dispatcher is responsible for finding the service and operation for a given + * invocation. A Web service request would contain information that help + * locate the service and the operation serving the request. This information + * could be in various formats, and hence the mechanism to find the requested + * service and operation based on the available information could too vary. + * Hence there can be various types on dispatches involved in a dispatching + * phase of the engine, that implements the API given in this header. + * @{ + */ + +/** + * @file axis2_disp.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +#define AXIS2_DISP_NAMESPACE "http://axis.ws.apache.org" + + /** Type name for struct axis2_disp */ + typedef struct axis2_disp axis2_disp_t; + + /** + * Gets the base struct which is of type handler. + * @param disp pointer to dispatcher + * @param env pointer to environment struct + * @return pointer to base handler struct. Returns a reference, not a + * cloned copy + */ + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axis2_disp_get_base( + const axis2_disp_t * disp, + const axutil_env_t * env); + + /** + * Gets the name of the dispatcher. + * @param disp pointer to dispatcher + * @param env pointer to environment struct + * @return pointer to name. Returns a reference, not a + * cloned copy + */ + AXIS2_EXTERN axutil_string_t *AXIS2_CALL + axis2_disp_get_name( + const axis2_disp_t * disp, + const axutil_env_t * env); + + /** + * Sets the name of the dispatcher. + * @param disp pointer to dispatcher + * @param env pointer to environment struct + * @param name pointer to name, dispatcher assumes ownership of the + * name struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_disp_set_name( + axis2_disp_t * disp, + const axutil_env_t * env, + axutil_string_t * name); + + /** + * Frees dispatcher struct. + * @param disp pointer to dispatcher + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_disp_free( + axis2_disp_t * disp, + const axutil_env_t * env); + + /** + * Creates a dispatcher struct instance. + * @param env pointer to environment struct + * @param name pointer to QName. QName is cloned by create method. + * @return pointer to newly created dispatcher + */ + AXIS2_EXTERN axis2_disp_t *AXIS2_CALL + axis2_disp_create( + const axutil_env_t * env, + const axutil_string_t * name); + + axis2_status_t AXIS2_CALL + axis2_disp_find_svc_and_op( + struct axis2_handler *handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + + /** + * Creates a WS-Addressing based dispatcher. + * @param env pointer to environment struct + * @return pointer to the newly created dispatcher with find_svc and find_op + * methods implemented based on WS-Addressing + */ + AXIS2_EXTERN axis2_disp_t *AXIS2_CALL + axis2_addr_disp_create( + const axutil_env_t * env); + + /** + * Creates a request URI based dispatcher. + * @param env pointer to environment struct + * @return pointer to the newly created dispatcher with find_svc and find_op + * methods implemented based on request URI processing. + */ + AXIS2_EXTERN axis2_disp_t *AXIS2_CALL + axis2_req_uri_disp_create( + const axutil_env_t * env); + + /** + * Creates a REST based dispatcher. + * @param env pointer to environment struct + * @return pointer to the newly created dispatcher with find_svc and find_op + * methods implemented based on REST processing. + */ + AXIS2_EXTERN axis2_disp_t *AXIS2_CALL + axis2_rest_disp_create( + const axutil_env_t * env); + + /** + * Creates a SOAP body based dispatcher. + * @param env pointer to environment struct + * @return pointer to the newly created dispatcher with find_svc and find_op + * methods implemented based on SOAP body processing. + */ + AXIS2_EXTERN axis2_disp_t *AXIS2_CALL + axis2_soap_body_disp_create( + const axutil_env_t * env); + + /** + * Creates a SOAP action based dispatcher. + * @param env pointer to environment struct + * @return pointer to the newly created dispatcher with find_svc and find_op + * methods implemented based on SOAP action processing + */ + AXIS2_EXTERN axis2_disp_t *AXIS2_CALL + axis2_soap_action_disp_create( + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_DISP_H */ diff --git a/include/axis2_endpoint_ref.h b/include/axis2_endpoint_ref.h new file mode 100644 index 0000000..cb9dfe0 --- /dev/null +++ b/include/axis2_endpoint_ref.h @@ -0,0 +1,319 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_ENDPOINT_REF_H +#define AXIS2_ENDPOINT_REF_H + +/** + * @defgroup axis2_endpoint_ref endpoint reference + * @ingroup axis2_addr + * endpoint reference represent an endpoint address in WS-Addressing. + * In addition to the endpoint address, it also encapsulates meta data, + * reference attributes and the service hosted at the given endpoint. + * In addition to the addressing related implementation, the endpoint reference + * struct is used across core code-base to represent endpoints. + * @{ + */ + +/** + * @file axis2_endpoint_ref.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_endpoint_ref */ + typedef struct axis2_endpoint_ref axis2_endpoint_ref_t; + + /** + * Creates endpoint reference struct. + * @param env pointer to environment struct + * @param address endpoint address string + * @return pointer to newly created endpoint reference + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_endpoint_ref_create( + const axutil_env_t * env, + const axis2_char_t * address); + + /** + * Frees the endpoint_ref given as a void pointer. This method would cast the + * void parameter to an endpoint_ref pointer and then call free method. + * @param endpoint_ref pointer to endpoint_ref as a void pointer + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + void AXIS2_CALL + axis2_endpoint_ref_free_void_arg( + void *endpoint_ref, + const axutil_env_t * env); + + /** + * Gets endpoint address. Address URI identifies the endpoint. + * This may be a network address or a logical address. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return endpoint address string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_endpoint_ref_get_address( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Sets endpoint address. Address URI identifies the endpoint. + * This may be a network address or a logical address. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param address address string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_set_address( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + const axis2_char_t * address); + + /** + * Gets interface QName. QName represents the primary portType of + * the endpoint being conveyed. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return pointer to interface QName, returns a reference, not a cloned + * copy + */ + AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL + axis2_endpoint_ref_get_interface_qname( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Sets interface QName. QName represents the primary portType of + * the endpoint being conveyed. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param interface_qname pointer to interface QName, this method creates + * a clone of the QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_set_interface_qname( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + const axutil_qname_t * interface_qname); + + /** + * Gets reference parameter list. A reference may contain a number + * of individual parameters which are associated with the endpoint + * to facilitate a particular interaction. Reference parameters + * are element information items that are named by QName and are + * required to properly interact with the endpoint. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return pointer to array list containing all reference parameters, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_endpoint_ref_get_ref_param_list( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Gets the list of metadata. An endpoint can have different associated + * metadata such as WSDL, XML Schema, and WS-Policy policies. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return pointer to array list containing metadata, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_endpoint_ref_get_metadata_list( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Gets the list of reference attributes. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return pointer to array list containing reference attributes, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_endpoint_ref_get_ref_attribute_list( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Gets the list of metadata attributes. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return pointer to array list containing metadata attributes, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_endpoint_ref_get_metadata_attribute_list( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Gets the list of extensions. Extensions are a mechanism to allow + * additional elements to be specified in association with the endpoint. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return pointer to array list containing extensions, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_endpoint_ref_get_extension_list( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Adds a reference parameter in the form of an AXIOM node. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param ref_param_node pointer to AXIOM node representing reference + * parameter, endpoint reference does not assume the ownership of + * the node + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_add_ref_param( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + axiom_node_t * ref_param_node); + + /** + * Adds metadata in the form of an AXIOM node. An endpoint can have + * different associated metadata such as WSDL, XML Schema and + * WS-Policy policies. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param metadata_node AXIOM node representing metadata, + * endpoint reference does not assume the ownership of the node + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_add_metadata( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + axiom_node_t * metadata_node); + + /** + * Adds a reference attribute in the form of an AXIOM attribute. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param attr AXIOM attribute representing reference attribute, + * endpoint reference does not assume the ownership of the attribute + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_add_ref_attribute( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + axiom_attribute_t * attr); + + /** + * Adds a meta attribute in the form of an AXIOM attribute. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param attr AXIOM attribute representing meta attribute, + * endpoint reference does not assume the ownership of the attribute + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_add_metadata_attribute( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + axiom_attribute_t * attr); + + /** + * Adds an extension in the form of an AXIOM node. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param extension_node pointer to AXIOM node representing extension, + * endpoint reference does not assume the ownership of the node + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_add_extension( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + axiom_node_t * extension_node); + + /** + * Gets service name. An endpoint in WS-Addressing has a QName + * identifying the WSDL service element that contains the definition + * of the endpoint being conveyed. The service name provides a link + * to a full description of the service endpoint. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return pointer to service name struct, returns a reference, not + * a cloned copy + */ + AXIS2_EXTERN axis2_svc_name_t *AXIS2_CALL + axis2_endpoint_ref_get_svc_name( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** + * Sets service name. An endpoint in WS-Addressing has a QName + * identifying the WSDL service element that contains the definition + * of the endpoint being conveyed. The service name provides a link + * to a full description of the service endpoint. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @param svc_name pointer to service name struct, endpoint assumes + * ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_endpoint_ref_set_svc_name( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + axis2_svc_name_t * svc_name); + + /** + * Frees endpoint reference struct. + * @param endpoint_ref pointer to endpoint reference struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_endpoint_ref_free( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_ENDPOINT_REF_H */ diff --git a/include/axis2_engine.h b/include/axis2_engine.h new file mode 100644 index 0000000..9433d48 --- /dev/null +++ b/include/axis2_engine.h @@ -0,0 +1,264 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_ENGINE_H +#define AXIS2_ENGINE_H + +/** + * @defgroup axis2_engine engine + * @ingroup axis2_engine + * engine has the send and receive functions that is the heart when providing + * and consuming services. In Axis2 SOAP engine architecture, all the others + * parts are build around the concept of the engine. There is only one engine + * for both the server side and the client side, and the engine is not aware of + * if it is invoked as an client or a service. engine supports both synchronous + * and asynchronous messaging modes based on send and receive functions. + * @{ + */ + +/** + * @file axis2_engine.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_engine */ + typedef struct axis2_engine axis2_engine_t; + + struct axiom_soap_fault; + + /** + * This methods represents the out flow of the Axis engine both at the + * server side as well as the client side. In this function, the + * execution chain is created using the phases of the out flow. + * All handlers at each out flow phase, which are ordered in the + * deployment time are invoked in sequence here. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing current state + * that is used when sending message + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_send( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * This methods represents the in flow of the Axis engine, both at the + * server side as well as the client side. In this function, the + * execution chain is created using the phases of the in flow. + * All handlers at each in flow phase, which are ordered in the + * deployment time are invoked in sequence here. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing current state + * that is used in receiving message + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_receive( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Sends a SOAP fault. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context that contains details of + * fault state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_send_fault( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * This is invoked when a SOAP fault is received. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing that contains + * the details of receive state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_receive_fault( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Creates a message context that represents the fault state based on + * current processing state. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param processing_context pointer to message context representing + * current processing context + * @param code_value pointer to a string containing fault code + * @param reason_text pointer to a string containing reason of the fault + * @return pointer to message context representing the fault state + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + + axis2_engine_create_fault_msg_ctx( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * processing_context, + const axis2_char_t * code_value, + const axis2_char_t * reason_text); + + /** + * Invokes the phases in the given array list of phases. The list of + * phases could be representing one of the flows. The two possible + * flows are in flow and out flow. Both of those flows can also have + * fault related representations, in fault flow and out fault flow. + * Invoking a phase triggers the invocation of handlers the phase + * contain. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param phases pointer to phases + * @param msg_ctx pointer to message context containing current state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_invoke_phases( + axis2_engine_t * engine, + const axutil_env_t * env, + axutil_array_list_t * phases, + axis2_msg_ctx_t * msg_ctx); + + /** + * Resumes phase invocation. While invoking the phases, one of the + * handlers in any phase could determine to pause the invocation. + * Often pausing happens to wait till some state is reached or some + * task is complete. Once paused, the invocation has to be resumed + * using this function, which will resume the invocation from the paused + * handler in the paused phase and will continue till it is paused + * again or it completes invoking all the remaining handlers in the + * remaining phases. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param phases pointer to phases + * @param msg_ctx pointer to message context containing current paused + * state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_engine_resume_invocation_phases( + axis2_engine_t * engine, + const axutil_env_t * env, + axutil_array_list_t * phases, + axis2_msg_ctx_t * msg_ctx); + + /** + * Gets sender's SOAP fault code. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param soap_namespace pointer to SOAP namespace + * @return pointer to SOAP fault code string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_engine_get_sender_fault_code( + const axis2_engine_t * engine, + const axutil_env_t * env, + const axis2_char_t * soap_namespace); + + /** + * Gets receiver's SOAP fault code. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param soap_namespace pointer to soap namespace + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_engine_get_receiver_fault_code( + const axis2_engine_t * engine, + const axutil_env_t * env, + const axis2_char_t * soap_namespace); + + /** + * Frees engine struct. + * @param engine pointer to engine + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_engine_free( + axis2_engine_t * engine, + const axutil_env_t * env); + + /** + * Resumes receive operation. It could be the case that receive was + * paused by one of the in flow handlers. In such a situation, this + * method could be used to resume the receive operation. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_resume_receive( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Resumes send operation. It could be the case that send was + * paused by one of the out flow handlers. In such a situation, this + * method could be used to resume the send operation. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_resume_send( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Creates en engine struct instance. + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context struct + * @return pointer to newly created engine struct + */ + AXIS2_EXTERN axis2_engine_t *AXIS2_CALL + axis2_engine_create( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_ENGINE_H */ diff --git a/include/axis2_flow.h b/include/axis2_flow.h new file mode 100644 index 0000000..3bb2bde --- /dev/null +++ b/include/axis2_flow.h @@ -0,0 +1,125 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_FLOW_H +#define AXIS2_FLOW_H + +/** + * @defgroup axis2_flow flow + * @ingroup axis2_desc + * flow is a collection of handlers. This struct encapsulates the concept + * of an execution flow in the engine. + * @{ + */ + +/** + * @file axis2_flow.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_flow */ + typedef struct axis2_flow axis2_flow_t; + + /** + * Creates flow struct. + * @param env pointer to environment struct + * @return pointer to newly created flow + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_flow_create( + const axutil_env_t * env); + + /** + * Frees flow struct. + * @param flow pointer to flow + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_flow_free( + axis2_flow_t * flow, + const axutil_env_t * env); + + /** + * Adds a handler description to flow. + * @param flow pointer to flow + * @param env pointer to environment struct + * @param handler pointer to handler description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_flow_add_handler( + axis2_flow_t * flow, + const axutil_env_t * env, + axis2_handler_desc_t * handler); + + /** + * Gets handler description at given index. + * @param flow pointer to flow + * @param env pointer to environment struct + * @param index index of the handler + * @return pointer to handler description + */ + AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL + axis2_flow_get_handler( + const axis2_flow_t * flow, + const axutil_env_t * env, + const int index); + + /** + * Gets handler count. + * @param flow pointer to flow + * @param env pointer to environment struct + * @return handler count + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_flow_get_handler_count( + const axis2_flow_t * flow, + const axutil_env_t * env); + + /** + * Frees flow passed as void pointer. This method would cast the void + * pointer to appropriate type and then call free method. + * @param flow pointer to flow + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_flow_free_void_arg( + void *flow, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_FLOW_H */ diff --git a/include/axis2_flow_container.h b/include/axis2_flow_container.h new file mode 100644 index 0000000..ecc5fb6 --- /dev/null +++ b/include/axis2_flow_container.h @@ -0,0 +1,176 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_FLOW_CONTAINER_H +#define AXIS2_FLOW_CONTAINER_H + +/** + * @defgroup axis2_flow_container flow container + * @ingroup axis2_desc + * Flow container is the encapsulating struct for all the four flows. The four flows + * possible are in flow, out flow, in fault flow and out fault flow. + * @{ + */ + +/** + * @file axis2_flow_container.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_flow_container */ + typedef struct axis2_flow_container axis2_flow_container_t; + + /** + * Frees flow container. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_flow_container_free( + axis2_flow_container_t * flow_container, + const axutil_env_t * env); + + /** + * Gets in flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @return pointer to in flow, returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_flow_container_get_in_flow( + const axis2_flow_container_t * flow_container, + const axutil_env_t * env); + + /** + * Sets in flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @param in_flow pointer to in flow struct, flow container assumes + * ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_flow_container_set_in_flow( + axis2_flow_container_t * flow_container, + const axutil_env_t * env, + axis2_flow_t * in_flow); + + /** + * Gets out flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @return out flow, returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_flow_container_get_out_flow( + const axis2_flow_container_t * flow_container, + const axutil_env_t * env); + + /** + * Sets out flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @param out_flow pointer to out flow, flow container assumes + * ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_flow_container_set_out_flow( + axis2_flow_container_t * flow_container, + const axutil_env_t * env, + axis2_flow_t * out_flow); + + /** + * Gets fault in flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @return fault in flow, returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_flow_container_get_fault_in_flow( + const axis2_flow_container_t * flow_container, + const axutil_env_t * env); + + /** + * Sets fault in flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @param falut_in_flow pointer to falut in flow, flow container assumes + * ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_flow_container_set_fault_in_flow( + axis2_flow_container_t * flow_container, + const axutil_env_t * env, + axis2_flow_t * falut_in_flow); + + /** + * Gets fault out flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @return fault out flow, returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_flow_container_get_fault_out_flow( + const axis2_flow_container_t * flow_container, + const axutil_env_t * env); + + /** + * Sets fault out flow. + * @param flow_container pointer to flow container + * @param env pointer to environment struct + * @param fault_out_flow pointer to fault out flow, flow container assumes + * ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_flow_container_set_fault_out_flow( + axis2_flow_container_t * flow_container, + const axutil_env_t * env, + axis2_flow_t * fault_out_flow); + + /** + * Creates flow container struct. + * @param env pointer to environment struct + * @return pointer to newly created flow container + */ + AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL + axis2_flow_container_create( + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_FLOW_CONTAINER_H */ diff --git a/include/axis2_handler.h b/include/axis2_handler.h new file mode 100644 index 0000000..49cf9d0 --- /dev/null +++ b/include/axis2_handler.h @@ -0,0 +1,184 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HANDLER_H +#define AXIS2_HANDLER_H + +/** + * @defgroup axis2_handler handler + * @ingroup axis2_handler + * handler is the smallest unit of execution in the Axis2 engine's execution flow. + * The engine could have two flows, the in-flow and out-flow. A flow is a + * collection of phases and a phase in turn is a collection of handlers. + * handlers are configured in relation to modules. A module is a point of + * extension in the Axis2 engine and a module would have one or more handlers + * defined in its configuration. The module configuration defines the phases + * each handler is attached to. A handler is invoked when the phase within which + * it lives is invoked. handler is stateless and it is using the message context + * that the state information is captures across invocations. + * @{ + */ + +/** + * @file axis2_handler.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_handler */ + typedef struct axis2_handler axis2_handler_t; + + struct axis2_handler_desc; + struct axis2_msg_ctx; + + typedef axis2_status_t( + AXIS2_CALL + * AXIS2_HANDLER_INVOKE) ( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); + + /** + * Free handler struct. + * @param handler pointer to handler + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_handler_free( + axis2_handler_t * handler, + const axutil_env_t * env); + + /** + * Initializes the handler with the information form handler description. + * @param handler pointer to handler + * @param env pointer to environment struct + * @param handler_desc pointer to handler description related to the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_init( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_handler_desc *handler_desc); + + /** + * Invoke is called to do the actual work assigned to the handler. + * The phase that owns the handler is responsible for calling invoke + * on top of the handler. Those structs that implement the interface + * of the handler should implement the logic for invoke and assign the + * respective function pointer to invoke operation of the ops struct. + * @param handler pointer to handler + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + + /** + * Gets QName. + * @param handler pointer to handler + * @param env pointer to environment struct + * @return pointer to QName of the handler + */ + AXIS2_EXTERN const axutil_string_t *AXIS2_CALL + axis2_handler_get_name( + const axis2_handler_t * handler, + const axutil_env_t * env); + + /** + * Gets the named parameter. + * @param handler pointer to handler + * @param env pointer to environment struct + * @param name name of the parameter to be accessed + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_handler_get_param( + const axis2_handler_t * handler, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Gets the handler description related to the handler. + * @param handler pointer to handler + * @param env pointer to environment struct + * @return pointer to handler description struct related to handler + */ + AXIS2_EXTERN struct axis2_handler_desc *AXIS2_CALL + + axis2_handler_get_handler_desc( + const axis2_handler_t * handler, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_set_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + AXIS2_HANDLER_INVOKE func); + + /** + * Function pointer defining the creates syntax for a handler struct instance. + * @param env pointer to environment struct + * @param pointer to qname + * @return pointer to newly created handler struct + */ + typedef axis2_handler_t *( + AXIS2_CALL + * AXIS2_HANDLER_CREATE_FUNC)( + const axutil_env_t * env, + const axutil_string_t * name); + + /** + * Creates handler struct instance. + * @param env pointer to environment struct + * @return pointer to newly created handler struct + */ + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axis2_handler_create( + const axutil_env_t * env); + + /** + * Creates a handler with invoke method implemented to fill in the service + * and operation context information. + * @param env pointer to environment struct + * @param qname pointer to qname, this is cloned within create method + * @return pointer to newly created handler struct + */ + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axis2_ctx_handler_create( + const axutil_env_t * env, + const axutil_string_t * qname); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HANDLER_H */ diff --git a/include/axis2_handler_desc.h b/include/axis2_handler_desc.h new file mode 100644 index 0000000..b807508 --- /dev/null +++ b/include/axis2_handler_desc.h @@ -0,0 +1,274 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HANDLER_DESC_H +#define AXIS2_HANDLER_DESC_H + +/** + * @defgroup axis2_handler_desc handler description + * @ingroup axis2_desc + * handler description captures information on a handler. Each handler in the + * system has an associated handler description. Deployment engine would create + * handler descriptions based on configuration information. When handlers are + * loaded from shared libraries, the information captured in handler description + * would be used. + * @{ + */ + +/** + * @file axis2_handler_desc.h + */ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_handler_desc */ + typedef struct axis2_handler_desc axis2_handler_desc_t; + + /** + * Gets QName. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return pointer to QName, returns a reference, not a cloned copy + */ + AXIS2_EXTERN const axutil_string_t *AXIS2_CALL + axis2_handler_desc_get_name( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Sets QName. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param name pointer to string representing handler name + * of QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_desc_set_name( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axutil_string_t * name); + + /** + * Gets phase rules. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return pointer to phase rule struct containing phase rules + */ + AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL + axis2_handler_desc_get_rules( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Sets phase rules. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param phase_rule pointer to phase rule struct, handler description + * assumes ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_desc_set_rules( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axis2_phase_rule_t * phase_rule); + + /** + * Gets named parameter. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param name parameter name string + * @return pointer to parameter if found, else NULL. Return a reference + * not a cloned copy + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_handler_desc_get_param( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Adds given parameter to the parameter list. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param param pointer to param + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_desc_add_param( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets all parameters stored within handler description. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return pointer to array list containing parameters, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_handler_desc_get_all_params( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Checks if the named parameter is locked at any level + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param param_name parameter name string + * @return AXIS2_TRUE if the parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_handler_desc_is_param_locked( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Gets the handler associated with the handler description. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return pointer to handler, returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axis2_handler_desc_get_handler( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Sets the handler associated with the handler description. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param handler pointer to handler, handler description assumes + * the ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_desc_set_handler( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Gets the class name. Class name is the name of the shared library + * file that contains the implementation of the handler. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return class name string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_handler_desc_get_class_name( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Sets the class name. Class name is the name of the shared library + * file that contains the implementation of the handler. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param class_name class name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_desc_set_class_name( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + const axis2_char_t * class_name); + + /** + * Gets the parent. Parent of handler description is of type parameter + * container. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return pointer to parent parameter container, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + axis2_handler_desc_get_parent( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Gets the parent. Parent of handler description is of type parameter + * container. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @param parent pointer to parent parameter container struct, handler + * description assumes ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_handler_desc_set_parent( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env, + axutil_param_container_t * parent); + + /** + * Frees handler description. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_handler_desc_free( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Gets the param container. + * @param handler_desc pointer to handler description + * @param env pointer to environment struct + * @return pointer to parameter container, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + axis2_handler_desc_get_param_container( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env); + + /** + * Creates handler description struct instance. + * @param env pointer to env pointer to environment struct + * @param name pointer to string representing handler name, can be NULL, create function + * clones this + * @return pointer to newly created handler description struct + */ + AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL + axis2_handler_desc_create( + const axutil_env_t * env, + axutil_string_t * name); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HANDLER_DESC_H */ diff --git a/include/axis2_http_accept_record.h b/include/axis2_http_accept_record.h new file mode 100644 index 0000000..3ddb068 --- /dev/null +++ b/include/axis2_http_accept_record.h @@ -0,0 +1,117 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_ACCEPT_RECORD_H +#define AXIS2_HTTP_ACCEPT_RECORD_H + +/** + * @defgroup axis2_http_accept_record HTTP Accept record + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_accept_record.h + * @brief Axis2 HTTP Accept record + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_accept_record */ + typedef struct axis2_http_accept_record axis2_http_accept_record_t; + + /** + * Gets quality factor of accept record + * @param accept_record pointer to accept record + * @param env pointer to environment struct + * @return quality factor between 0 and 1 (1 meaning maximum + * and 0 meaning minimum) + */ + AXIS2_EXTERN float AXIS2_CALL + axis2_http_accept_record_get_quality_factor( + const axis2_http_accept_record_t * accept_record, + const axutil_env_t * env); + + /** + * Gets name of accept record + * @param accept_record pointer to accept record + * @param env pointer to environment struct + * @return name of accept record + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_accept_record_get_name( + const axis2_http_accept_record_t * accept_record, + const axutil_env_t * env); + + /** + * Gets level of accept record + * @param accept_record pointer to accept record + * @param env pointer to environment struct + * @return level of accept record (1 meaning highest). + * A return value of -1 indicates that no level is + * associated. + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_http_accept_record_get_level( + const axis2_http_accept_record_t * accept_record, + const axutil_env_t * env); + + /** + * Gets string representation of accept record + * @param accept_record pointer to accept record + * @param env pointer to environment struct + * @return created accept record string + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_accept_record_to_string( + axis2_http_accept_record_t * accept_record, + const axutil_env_t * env); + + /** + * Frees accept record + * @param accept_record pointer to accept record + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_accept_record_free( + axis2_http_accept_record_t * accept_record, + const axutil_env_t * env); + + /** + * Creates accept record + * @param env pointer to environment struct + * @param str pointer to str + * @return created accept record + */ + AXIS2_EXTERN axis2_http_accept_record_t *AXIS2_CALL + axis2_http_accept_record_create( + const axutil_env_t * env, + const axis2_char_t * str); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_HTTP_ACCEPT_RECORD_H */ diff --git a/include/axis2_http_client.h b/include/axis2_http_client.h new file mode 100644 index 0000000..fbad8d4 --- /dev/null +++ b/include/axis2_http_client.h @@ -0,0 +1,270 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_HTTP_CLIENT_H +#define AXIS2_HTTP_CLIENT_H + +/** + * @defgroup axis2_http_client http client + * @ingroup axis2_core_trans_http + * Description + * @{ + */ + +/** + * @file axis2_http_client.h + * @brief axis2 HTTP Header name:value pair implementation + */ + +#include +#include +#include +#include +#include +#include + + + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_client */ + typedef struct axis2_http_client axis2_http_client_t; + + /** + * @param client pointer to client + * @param env pointer to environment struct + * @param request pointer to request + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_send( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_http_simple_request_t * request, + axis2_char_t * ssl_pp); + + /** + * @param client pointer to client + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_http_client_recieve_header( + axis2_http_client_t * client, + const axutil_env_t * env); + + /** + * @param client pointer to client + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_http_simple_response_t *AXIS2_CALL + + axis2_http_client_get_response( + const axis2_http_client_t * client, + const axutil_env_t * env); + + /** + * @param client pointer to client + * @param env pointer to environment struct + * @param url pointer to url + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_url( + axis2_http_client_t * client, + const axutil_env_t * env, + axutil_url_t * url); + + /** + * @param client pointer to client + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_url_t *AXIS2_CALL + axis2_http_client_get_url( + const axis2_http_client_t * client, + const axutil_env_t * env); + + /** + * @param client pointer to client + * @param env pointer to environment struct + * @param timeout_ms + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_timeout( + axis2_http_client_t * client, + const axutil_env_t * env, + int timeout_ms); + + /** + * @param client pointer to client + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_http_client_get_timeout( + const axis2_http_client_t * client, + const axutil_env_t * env); + + /** + * @param client pointer to client + * @param env pointer to environment struct + * @param proxy_host pointer to proxy host + * @param proxy_port + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_proxy( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_char_t * proxy_host, + int proxy_port); + + /** + * @param client pointer to client + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_client_get_proxy( + const axis2_http_client_t * client, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_client_connect_ssl_host( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_char_t * host, + int port); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_client_set_dump_input_msg( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_bool_t dump_input_msg); + + /** + * @param client pointer to client + * @param env pointer to environment struct + * @param server_cert server certificate + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_server_cert( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_char_t * server_cert); + + /** + * @param client pointer to client + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_client_get_server_cert( + const axis2_http_client_t * client, + const axutil_env_t * env); + + /** + * @param client pointer to client + * @param env pointer to environment struct + * @param key_file chain file containing + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_key_file( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_char_t * key_file); + + /** + * @param client pointer to client + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_client_get_key_file( + const axis2_http_client_t * client, + const axutil_env_t * env); + + /** + * @param client pointer to client + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_client_free( + axis2_http_client_t * client, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param url pointer to url + */ + AXIS2_EXTERN axis2_http_client_t *AXIS2_CALL + axis2_http_client_create( + const axutil_env_t * env, + axutil_url_t * url); + + /** + * Free http_client passed as void pointer. This will be + * cast into appropriate type and then pass the cast object + * into the http_client structure's free method + * @param client + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_client_free_void_arg( + void *client, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_mime_parts( + axis2_http_client_t * client, + const axutil_env_t * env, + axutil_array_list_t *mime_parts); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_http_client_get_mime_parts( + const axis2_http_client_t * client, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_doing_mtom( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_bool_t doing_mtom); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_http_client_get_doing_mtom( + const axis2_http_client_t * client, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_client_set_mtom_sending_callback_name( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_char_t *callback_name); + + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_CLIENT_H */ diff --git a/include/axis2_http_header.h b/include/axis2_http_header.h new file mode 100644 index 0000000..c79ab50 --- /dev/null +++ b/include/axis2_http_header.h @@ -0,0 +1,110 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_HTTP_HEADER_H +#define AXIS2_HTTP_HEADER_H + +/** + * @defgroup axis2_http_header http header + * @ingroup axis2_core_trans_http + * Description + * @{ + */ + +/** + * @file axis2_http_header.h + * @brief axis2 HTTP Header name:value pair implementation + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_header */ + typedef struct axis2_http_header axis2_http_header_t; + + /** + * @param header pointer to header + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_header_to_external_form( + axis2_http_header_t * header, + const axutil_env_t * env); + + /** + * @param header pointer to header + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_header_get_name( + const axis2_http_header_t * header, + const axutil_env_t * env); + + /** + * @param header pointer to header + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_header_get_value( + const axis2_http_header_t * header, + const axutil_env_t * env); + + /** + * @param header pointer to header + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_header_free( + axis2_http_header_t * header, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param name pointer to name + * @param value pointer to value + */ + AXIS2_EXTERN axis2_http_header_t *AXIS2_CALL + axis2_http_header_create( + const axutil_env_t * env, + const axis2_char_t * name, + const axis2_char_t * value); + + /** + * Creates http header object from a string having format "header_name: header_value" + * (e.g. "SOAPAction: urn:hello") + * @param env pointer to environment struct + * @param str pointer to str + */ + AXIS2_EXTERN axis2_http_header_t *AXIS2_CALL + axis2_http_header_create_by_str( + const axutil_env_t * env, + const axis2_char_t * str); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_HEADER_H */ diff --git a/include/axis2_http_out_transport_info.h b/include/axis2_http_out_transport_info.h new file mode 100644 index 0000000..7ba4b94 --- /dev/null +++ b/include/axis2_http_out_transport_info.h @@ -0,0 +1,250 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_HTTP_OUT_TRANSPORT_INFO_H +#define AXIS2_HTTP_OUT_TRANSPORT_INFO_H + +/** + * @defgroup axis2_http_out_transport_info http out transport info + * @ingroup axis2_core_trans_http + * Description + * @{ + */ + +/** + * @file axis2_http_out_transport_info.h + * @brief axis2 HTTP Out Transport Info + */ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_out_transport_info */ + typedef struct axis2_http_out_transport_info + axis2_http_out_transport_info_t; + + struct axis2_http_out_transport_info + { + axis2_out_transport_info_t out_transport; + axis2_http_simple_response_t *response; + axis2_transport_receiver_t *server; + axis2_char_t *encoding; + + axis2_status_t( + AXIS2_CALL + * set_content_type)( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * content_type); + + axis2_status_t( + AXIS2_CALL + * set_char_encoding)( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding); + + axis2_status_t( + AXIS2_CALL + * set_cookie_header)( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * cookie_header); + + axis2_status_t( + AXIS2_CALL + * set_session)( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value); + + void( + AXIS2_CALL + * free_function)( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env); + }; + + /** + * @param info pointer to info + * @param env pointer to environment struct + * @param content_type pointer to content type + */ + AXIS2_EXTERN int AXIS2_CALL + + axis2_http_out_transport_info_set_content_type( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * content_type); + + /** + * @param info pointer to info + * @param env pointer to environment struct + * @param encoding pointer to encoding + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding); + + /** + * @param info pointer to info + * @param env pointer to environment struct + * @param cookie_header pointer to cookie_header + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_out_transport_info_set_cookie_header( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * cookie_header); + + /** @param info pointer to info + * @param env pointer to environment struct + * @param session_str pointer to session string + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_out_transport_info_set_session( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value); + + + /** + * @param out_transport_info pointer to out transport info + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_out_transport_info_free( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param response pointer to response + */ + AXIS2_EXTERN axis2_http_out_transport_info_t *AXIS2_CALL + + axis2_http_out_transport_info_create( + const axutil_env_t * env, + axis2_http_simple_response_t * response); + + /** + * Free http_out_transport_info passed as void pointer. This will be + * cast into appropriate type and then pass the cast object + * into the http_out_transport_info structure's free method + * @param transport_info pointer to transport info + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + + axis2_http_out_transport_info_set_char_encoding_func( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + axis2_status_t(AXIS2_CALL + * set_encoding) + (axis2_http_out_transport_info_t *, + const axutil_env_t *, + const axis2_char_t *)); + + AXIS2_EXTERN void AXIS2_CALL + + axis2_http_out_transport_info_set_content_type_func( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + axis2_status_t(AXIS2_CALL + * + set_content_type)(axis2_http_out_transport_info_t *, + const axutil_env_t *, + const axis2_char_t *)); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_out_transport_info_set_cookie_header_func( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + axis2_status_t(AXIS2_CALL + * + set_cookie_header)(axis2_http_out_transport_info_t *, + const axutil_env_t *, + const axis2_char_t *)); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_out_transport_info_set_session_func( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + axis2_status_t(AXIS2_CALL + * + set_session)(axis2_http_out_transport_info_t *, + const axutil_env_t *, + const axis2_char_t *, + const axis2_char_t *)); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_out_transport_info_set_free_func( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + void(AXIS2_CALL + * free_function)(axis2_http_out_transport_info_t *, + const axutil_env_t *)); + + /** Set content type. */ +#define AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_transport_info, \ + env, content_type) axis2_http_out_transport_info_set_content_type (out_transport_info, env, content_type) + + /** Set char encoding. */ +#define AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(out_transport_info,\ + env, encoding) axis2_http_out_transport_info_set_char_encoding(out_transport_info, env, encoding) + + /** Set cookie_header. */ +#define AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_transport_info, \ + env, cookie_header) axis2_http_out_transport_info_set_cookie_header (out_transport_info, env, cookie_header) + + /** Set session. */ +#define AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_SESSION(out_transport_info, \ + env, session_id, session_value) axis2_http_out_transport_info_set_session (out_transport_info, env, session_id, session_value) + + /** Free. */ +#define AXIS2_HTTP_OUT_TRANSPORT_INFO_FREE(out_transport_info, env)\ + axis2_http_out_transport_info_free(out_transport_info, env) + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_HTTP_OUT_TRANSPORT_INFO_H */ diff --git a/include/axis2_http_request_line.h b/include/axis2_http_request_line.h new file mode 100644 index 0000000..4d1ef00 --- /dev/null +++ b/include/axis2_http_request_line.h @@ -0,0 +1,122 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_HTTP_REQUEST_LINE_H +#define AXIS2_HTTP_REQUEST_LINE_H + +/** + * @defgroup axis2_http_request_line http request line + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_request_line.h + * @brief axis2 HTTP Request Line + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_request_line */ + typedef struct axis2_http_request_line axis2_http_request_line_t; + + /** + * @param request_line pointer to request line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_request_line_get_method( + const axis2_http_request_line_t * request_line, + const axutil_env_t * env); + + /** + * @param request_line pointer to request line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_request_line_get_http_version( + const axis2_http_request_line_t * request_line, + const axutil_env_t * env); + + /** + * @param request_line pointer to request line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_request_line_get_uri( + const axis2_http_request_line_t * request_line, + const axutil_env_t * env); + + /** + * @param request_line pointer to request line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_request_line_to_string( + axis2_http_request_line_t * request_line, + const axutil_env_t * env); + + /** + * @param request_line pointer to request line + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_request_line_free( + axis2_http_request_line_t * request_line, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param method pointer to method + * @param uri pointer to uri + * @param http_version pointer to http version + */ + AXIS2_EXTERN axis2_http_request_line_t *AXIS2_CALL + + axis2_http_request_line_create( + const axutil_env_t * env, + const axis2_char_t * method, + const axis2_char_t * uri, + const axis2_char_t * http_version); + + /** + * Parses a line " CRLF" and creates http_request_line + * object. E.g "POST /axis2/services/echo HTTP/1.1\r\n" + * @param env pointer to environment struct + * @param str pointer to the line to be parsed + * @return created object if success. NULL otherwise + */ + AXIS2_EXTERN axis2_http_request_line_t *AXIS2_CALL + axis2_http_request_line_parse_line( + const axutil_env_t * env, + const axis2_char_t * str); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_HTTP_REQUEST_LINE_H */ diff --git a/include/axis2_http_response_writer.h b/include/axis2_http_response_writer.h new file mode 100644 index 0000000..08c5c6c --- /dev/null +++ b/include/axis2_http_response_writer.h @@ -0,0 +1,193 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_HTTP_RESPONSE_WRITER_H +#define AXIS2_HTTP_RESPONSE_WRITER_H + +/** + * @defgroup axis2_http_response_writer http response writer + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_response_writer.h + * @brief axis2 Response Writer + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_response_writer */ + typedef struct axis2_http_response_writer axis2_http_response_writer_t; + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_response_writer_get_encoding( + const axis2_http_response_writer_t * response_writer, + const axutil_env_t * env); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_response_writer_close( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_response_writer_flush( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @param c + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_response_writer_write_char( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env, + char c); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @param buf pointer to buf + * @param offset + * @param len + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_response_writer_write_buf( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env, + char *buf, + int offset, + axis2_ssize_t len); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @param str pointer to str + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_response_writer_print_str( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env, + const char *str); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @param i + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_response_writer_print_int( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env, + int i); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @param str pointer to str + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_response_writer_println_str( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env, + const char *str); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_response_writer_println( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env); + + /** + * @param response_writer pointer to response writer + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_response_writer_free( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param stream pointer to stream + */ + AXIS2_EXTERN axis2_http_response_writer_t *AXIS2_CALL + + axis2_http_response_writer_create( + const axutil_env_t * env, + axutil_stream_t * stream); + + /** + * @param env pointer to environment struct + * @param stream pointer to stream + * @param encoding pointer to encoding + */ + AXIS2_EXTERN axis2_http_response_writer_t *AXIS2_CALL + + axis2_http_response_writer_create_with_encoding( + const axutil_env_t * env, + axutil_stream_t * stream, + const axis2_char_t * encoding); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_RESPONSE_WRITER_H */ diff --git a/include/axis2_http_sender.h b/include/axis2_http_sender.h new file mode 100644 index 0000000..d2ee5e7 --- /dev/null +++ b/include/axis2_http_sender.h @@ -0,0 +1,226 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_SENDER_H +#define AXIS2_HTTP_SENDER_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_http_sender.h + * @brief axis2 SOAP over HTTP sender + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef AXIS2_LIBCURL_ENABLED +#include +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_sender_ */ + typedef struct axis2_http_sender axis2_http_sender_t; + + /** + * @param sender sender + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @param out out + * @param str_url str url + * @param soap_action pointer to soap action + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_sender_send( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axiom_soap_envelope_t * out, + const axis2_char_t * str_url, + const axis2_char_t * soap_action); + + void AXIS2_CALL + axis2_http_sender_util_add_header( + const axutil_env_t * env, + axis2_http_simple_request_t * request, + axis2_char_t * header_name, + const axis2_char_t * header_value); + +#ifdef AXIS2_LIBCURL_ENABLED + typedef struct axis2_libcurl axis2_libcurl_t; + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_libcurl_http_send( + axis2_libcurl_t * curl, + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axiom_soap_envelope_t * out, + const axis2_char_t * str_url, + const axis2_char_t * soap_action); +#endif + + /** + * @param sender sender + * @param env pointer to environment struct + * @param chunked chunked + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_sender_set_chunked( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_bool_t chunked); + + /** + * @param sender sender + * @param env pointer to environment struct + * @param om_output om output + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_sender_set_om_output( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axiom_output_t * om_output); + + /** + * @param sender sender + * @param env pointer to environment struct + * @param version pointer to version + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_sender_set_http_version( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_char_t * version); + + /** + * @param sender sender + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_sender_free( + axis2_http_sender_t * sender, + const axutil_env_t * env); + + /** + * @param sender soap over http sender + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @param response pointer to response + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_sender_get_header_info( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_response_t * response); + + /** + * @param sender soap over http sender + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @param response pointer to response + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_sender_process_response( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_response_t * response); + + /** + * @param sender soap over http sender + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_sender_get_timeout_values( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_sender_get_param_string( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_sender_set_keep_alive( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_bool_t keep_alive); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_http_sender_get_keep_alive( + axis2_http_sender_t * sender, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_http_sender_t *AXIS2_CALL + axis2_http_sender_create( + const axutil_env_t * env); + + /** Send. */ +#define AXIS2_HTTP_SENDER_SEND(sender, env, msg_ctx, output, url,soap_action)\ + axis2_http_sender_send(sender, env, msg_ctx,output, url, soap_action) + + /** Set chunked. */ +#define AXIS2_HTTP_SENDER_SET_CHUNKED(sender, env, chunked) \ + axis2_http_sender_set_chunked(sender, env, chunked) + + /** Set om output. */ +#define AXIS2_HTTP_SENDER_SET_OM_OUTPUT(sender, env, om_output) \ + axis2_http_sender_set_om_output (sender, env, om_output) + + /** Set http version. */ +#define AXIS2_HTTP_SENDER_SET_HTTP_VERSION(sender, env, version)\ + axis2_http_sender_set_http_version (sender, env, version) + + /** Frees the soap over http sender. */ +#define AXIS2_HTTP_SENDER_FREE(sender, env) \ + axis2_http_sender_free(sender, env) + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_HTTP_SENDER_H */ diff --git a/include/axis2_http_server.h b/include/axis2_http_server.h new file mode 100644 index 0000000..4e31344 --- /dev/null +++ b/include/axis2_http_server.h @@ -0,0 +1,66 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_SERVER_H +#define AXIS2_HTTP_SERVER_H + +/** + * @defgroup axis2_http_server http server + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_server.h + * @brief axis2 HTTP Server implementation + */ + +#include +#include +#include +#include +#include + + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN axis2_transport_receiver_t *AXIS2_CALL + axis2_http_server_create( + const axutil_env_t * env, + const axis2_char_t * repo, + const int port); + + AXIS2_EXTERN axis2_transport_receiver_t *AXIS2_CALL + axis2_http_server_create_with_file( + const axutil_env_t * env, + const axis2_char_t * file, + const int port); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_server_stop( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_SERVER_H */ diff --git a/include/axis2_http_simple_request.h b/include/axis2_http_simple_request.h new file mode 100644 index 0000000..cb2b8b5 --- /dev/null +++ b/include/axis2_http_simple_request.h @@ -0,0 +1,229 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_HTTP_SIMPLE_REQUEST_H +#define AXIS2_HTTP_SIMPLE_REQUEST_H + +/** + * @defgroup axis2_http_simple_request http simple request + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_simple_request.h + * @brief axis2 HTTP Simple Request + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_simple_request */ + typedef struct axis2_http_simple_request axis2_http_simple_request_t; + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_http_request_line_t *AXIS2_CALL + + axis2_http_simple_request_get_request_line( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @param request_line pointer to request line + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_request_set_request_line( + axis2_http_simple_request_t * simple_request, + const axutil_env_t * env, + axis2_http_request_line_t * request_line); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @param name pointer to name + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_http_simple_request_contains_header( + axis2_http_simple_request_t * simple_request, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_http_simple_request_get_headers( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @param str pointer to str + */ + AXIS2_EXTERN axis2_http_header_t *AXIS2_CALL + + axis2_http_simple_request_get_first_header( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env, + const axis2_char_t * str); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @param str pointer to str + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_request_remove_headers( + axis2_http_simple_request_t * simple_request, + const axutil_env_t * env, + const axis2_char_t * str); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @param header pointer to header + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_request_add_header( + axis2_http_simple_request_t * simple_request, + const axutil_env_t * env, + axis2_http_header_t * header); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_http_simple_request_get_content_type( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_http_simple_request_get_charset( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_ssize_t AXIS2_CALL + + axis2_http_simple_request_get_content_length( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + + axis2_http_simple_request_get_body( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @param buf double pointer to buf + */ + AXIS2_EXTERN axis2_ssize_t AXIS2_CALL + + axis2_http_simple_request_get_body_bytes( + const axis2_http_simple_request_t * simple_request, + const axutil_env_t * env, + char **buf); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @param str pointer to str + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_request_set_body_string( + axis2_http_simple_request_t * simple_request, + const axutil_env_t * env, + void *str, + unsigned int str_len); + + /** + * @param simple_request pointer to simple request + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_simple_request_free( + axis2_http_simple_request_t * simple_request, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param request_line pointer to request line + * @param http_headers double pointer to http headers + * @param http_hdr_count + * @param content pointer to content + */ + AXIS2_EXTERN axis2_http_simple_request_t *AXIS2_CALL + + axis2_http_simple_request_create( + const axutil_env_t * env, + axis2_http_request_line_t * request_line, + axis2_http_header_t ** http_headers, + axis2_ssize_t http_hdr_count, + axutil_stream_t * content); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_SIMPLE_REQUEST_H */ diff --git a/include/axis2_http_simple_response.h b/include/axis2_http_simple_response.h new file mode 100644 index 0000000..052e9cd --- /dev/null +++ b/include/axis2_http_simple_response.h @@ -0,0 +1,337 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_SIMPLE_RESPONSE_H +#define AXIS2_HTTP_SIMPLE_RESPONSE_H + +/** + * @defgroup axis2_http_simple_response http simple response + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_simple_http_response.h + * @brief axis2 HTTP Simple Response + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_simple_response */ + typedef struct axis2_http_simple_response axis2_http_simple_response_t; + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param http_ver pointer to http_ver + * @param status_code pointer to status code + * @param phrase pointer to phrase + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_response_set_status_line( + struct axis2_http_simple_response *simple_response, + const axutil_env_t * env, + const axis2_char_t * http_ver, + const int status_code, + const axis2_char_t * phrase); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_simple_response_get_phrase( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_http_simple_response_get_status_code( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_simple_response_get_http_version( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_simple_response_get_status_line( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param name pointer to name + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_http_simple_response_contains_header( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_http_simple_response_get_headers( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_http_simple_response_extract_headers( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param str pointer to str + */ + AXIS2_EXTERN axis2_http_header_t *AXIS2_CALL + + axis2_http_simple_response_get_first_header( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + const axis2_char_t * str); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param str pointer to str + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_response_remove_headers( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + const axis2_char_t * str); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param header pointer to header + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_response_set_header( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axis2_http_header_t * header); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param headers double pointer to headers + * @param array_size + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_response_set_headers( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axis2_http_header_t ** headers, + axis2_ssize_t array_size); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_http_simple_response_get_charset( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_ssize_t AXIS2_CALL + + axis2_http_simple_response_get_content_length( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_http_simple_response_get_content_type( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param str pointer to str + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_response_set_body_string( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axis2_char_t * str); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param stream pointer to stream + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_http_simple_response_set_body_stream( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axutil_stream_t * stream); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + + axis2_http_simple_response_get_body( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @param buf double pointer to buf + */ + AXIS2_EXTERN axis2_ssize_t AXIS2_CALL + + axis2_http_simple_response_get_body_bytes( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axis2_char_t ** buf); + + /** + * @param simple_response pointer to simple response struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_simple_response_free( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param status_line pointer to status line + * @param http_headers double pointer to http_headers + * @param http_hdr_count + * @param content pointer to content + */ + AXIS2_EXTERN axis2_http_simple_response_t *AXIS2_CALL + + axis2_http_simple_response_create( + const axutil_env_t * env, + axis2_http_status_line_t * status_line, + const axis2_http_header_t ** http_headers, + const axis2_ssize_t http_hdr_count, + axutil_stream_t * content); + + /** + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_http_simple_response_t *AXIS2_CALL + + axis2_http_simple_response_create_default( + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_http_simple_response_get_mime_parts( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_simple_response_set_mime_parts( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axutil_array_list_t *mime_parts); + + axis2_status_t AXIS2_CALL + axis2_http_simple_response_set_http_version( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axis2_char_t *http_version); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_simple_response_get_mtom_sending_callback_name( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env); + + void AXIS2_EXTERN AXIS2_CALL + axis2_http_simple_response_set_mtom_sending_callback_name( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env, + axis2_char_t *mtom_sending_callback_name); + + + + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_SIMPLE_RESPONSE_H */ diff --git a/include/axis2_http_status_line.h b/include/axis2_http_status_line.h new file mode 100644 index 0000000..4480bdf --- /dev/null +++ b/include/axis2_http_status_line.h @@ -0,0 +1,131 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_STATUS_LINE_H +#define AXIS2_HTTP_STATUS_LINE_H + +/** + * @defgroup axis2_http_status_line http status line + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_status_line.h + * @brief axis2 HTTP Status Line + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_status_line */ + typedef struct axis2_http_status_line axis2_http_status_line_t; + + /** + * @param status_line pointer to status line + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_http_status_line_get_status_code( + const axis2_http_status_line_t * status_line, + const axutil_env_t * env); + + /** + * @param status_line pointer to status line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_status_line_get_http_version( + const axis2_http_status_line_t * status_line, + const axutil_env_t * env); + + /** + * @param status_line pointer to status line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_status_line_get_reason_phrase( + const axis2_http_status_line_t * status_line, + const axutil_env_t * env); + + /** + * @param status_line pointer to status line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_http_status_line_starts_with_http( + axis2_http_status_line_t * status_line, + const axutil_env_t * env); + + /** + * @param status_line pointer to status line + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_status_line_to_string( + axis2_http_status_line_t * status_line, + const axutil_env_t * env); + + /** + * @param status_line pointer to status line + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_status_line_free( + axis2_http_status_line_t * status_line, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param str pointer to str + */ + AXIS2_EXTERN axis2_http_status_line_t *AXIS2_CALL + axis2_http_status_line_create( + const axutil_env_t * env, + const axis2_char_t * str); + + AXIS2_EXTERN axis2_http_status_line_t *AXIS2_CALL + axis2_http_status_line_create_with_values( + const axutil_env_t * env, + const axis2_char_t * http_ver, + const int status_code, + const axis2_char_t * phrase); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_status_line_set_http_version( + axis2_http_status_line_t * status_line, + const axutil_env_t * env, + axis2_char_t *http_version); + + + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_HTTP_STATUS_LINE_H */ diff --git a/include/axis2_http_svr_thread.h b/include/axis2_http_svr_thread.h new file mode 100644 index 0000000..12fe115 --- /dev/null +++ b/include/axis2_http_svr_thread.h @@ -0,0 +1,121 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_SVR_THREAD_H +#define AXIS2_HTTP_SVR_THREAD_H + +/** + * @defgroup axis2_http_svr_thread http server thread + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_svr_thread.h + * @brief axis2 HTTP server listening thread implementation + */ + +#include +#include +#include +#include + + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axist_http_svr_thread */ + typedef struct axis2_http_svr_thread axis2_http_svr_thread_t; + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_svr_thread_run( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env); + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_svr_thread_destroy( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env); + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_http_svr_thread_get_local_port( + const axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env); + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_http_svr_thread_is_running( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env); + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + * @param worker pointer to worker + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_svr_thread_set_worker( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env, + axis2_http_worker_t * worker); + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_svr_thread_free( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param port + */ + AXIS2_EXTERN axis2_http_svr_thread_t *AXIS2_CALL + axis2_http_svr_thread_create( + const axutil_env_t * env, + int port); + + AXIS2_EXTERN int AXIS2_CALL + axis2_http_svr_thread_get_listen_socket( + axis2_http_svr_thread_t *svr_thread, + const axutil_env_t *env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_SVR_THREAD_H */ diff --git a/include/axis2_http_transport.h b/include/axis2_http_transport.h new file mode 100644 index 0000000..25f6e97 --- /dev/null +++ b/include/axis2_http_transport.h @@ -0,0 +1,1164 @@ + +/* +* Copyright 2004,2005 The Apache Software Foundation. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain count copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_HTTP_TRANSPORT_H +#define AXIS2_HTTP_TRANSPORT_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @defgroup axis2_core_trans_http http transport + * @ingroup axis2_transport + * Description. + * @{ + */ + + /** + * @defgroup axis2_core_transport_http core http transport + * @ingroup axis2_core_trans_http + * @{ + */ + + /** + * @brief HTTP protocol and message context constants. + * + */ + #define AXIS2_HTTP_OUT_TRANSPORT_INFO "HTTPOutTransportInfo" + + /** + * CARRIAGE RETURN AND LINE FEED + */ + #define AXIS2_HTTP_CRLF AXIS2_CRLF + + /** + * PROTOCOL_VERSION + */ + #define AXIS2_HTTP_PROTOCOL_VERSION "PROTOCOL" + + /** + * REQUEST_URI + */ + #define AXIS2_HTTP_REQUEST_URI "REQUEST_URI" + + /** + * RESPONSE_CODE + */ + #define AXIS2_HTTP_RESPONSE_CODE "RESPONSE_CODE" + + /** + * RESPONSE_WORD + */ + #define AXIS2_HTTP_RESPONSE_WORD "RESPONSE_WORD" + + /* + * RESPONSE_CONTINUE_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL 100 + + /* + * RESPONSE_OK_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_OK_CODE_VAL 200 + + /* + * RESPONSE_CREATED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_CREATED_CODE_VAL 201 + + /** + * RESPONSE_ACK_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_ACK_CODE_VAL 202 + + /** + * RESPONSE_NON_AUTHORITATIVE_INFO_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_NON_AUTHORITATIVE_INFO_CODE_VAL 203 + + /** + * RESPONSE_NO_CONTENT_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL 204 + + /** + * RESPONSE_RESET_CONTENT_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL 205 + + /** + * RESPONSE_MULTIPLE_CHOICES_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL 300 + + /** + * RESPONSE_MOVED_PERMANENTLY_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL 301 + + /** + * RESPONSE_SEE_OTHER_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL 303 + + /** + * RESPONSE_NOT_MODIFIED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL 304 + + /** + * RESPONSE_TEMPORARY_REDIRECT_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL 307 + + /** + * RESPONSE_BAD_REQUEST_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL 400 + + /** + * RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL 401 + + /** + * RESPONSE_HTTP_FORBIDDEN_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_FORBIDDEN_CODE_VAL 403 + + + /** + * RESPONSE_NOT_FOUND_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL 404 + + /** + * RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL 405 + + /** + * RESPONSE_NOT_ACCEPTABLE_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL 406 + + /** + * RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL 407 + + /** + * RESPONSE_REQUEST_TIMEOUT_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL 408 + + /** + * RESPONSE_CONFLICT_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL 409 + + /** + * RESPONSE_GONE_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_GONE_CODE_VAL 410 + + /** + * RESPONSE_LENGTH_REQUIRED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_LENGTH_REQUIRED_CODE_VAL 411 + + /** + * RESPONSE_PRECONDITION_FAILED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL 412 + + /** + * RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL 413 + + /** + * RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL 500 + + /** + * RESPONSE_NOT_IMPLEMENTED_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_VAL 501 + + /** + * RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL + */ + #define AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL 503 + + /** + * RESPONSE_CONTINUE_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_CONTINUE_CODE_NAME "Continue" + + /** + * RESPONSE_OK_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_OK_CODE_NAME "OK" + + /* + * RESPONSE_CREATED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_CREATED_CODE_NAME "Created" + + /** + * RESPONSE_ACK_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_ACK_CODE_NAME "Accepted" + + /** + * RESPONSE_NO_CONTENT_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_NAME "No Content" + + /** + * RESPONSE_NON_AUTHORITATIVE_INFO_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_NON_AUTHORITATIVE_INFO_CODE_NAME "Non-Authoritative Information" + + /** + * RESPONSE_RESET_CONTENT_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_NAME "Reset Content" + + /** + * RESPONSE_MULTIPLE_CHOICES_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_NAME "Multiple Choices" + + /** + * RESPONSE_MOVED_PERMANENTLY_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_NAME "Moved Permanently" + + /** + * RESPONSE_SEE_OTHER_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_NAME "See Other" + + /** + * RESPONSE_NOT_MODIFIED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME "Not Modified" + + /** + * RESPONSE_TEMPORARY_REDIRECT_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_NAME "Temporary Redirect" + + /** + * RESPONSE_BAD_REQUEST_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME "Bad Request" + + /** + * RESPONSE_HTTP_UNAUTHORIZED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_NAME "Unauthorized" + + + /** + * RESPONSE_HTTP_FORBIDDEN_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_HTTP_FORBIDDEN_CODE_NAME "Forbidden" + + /** + * RESPONSE_NOT_FOUND_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME "Not Found" + + /** + * RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME "Method Not Allowed" + + /** + * RESPONSE_NOT_ACCEPTABLE_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME "Not Acceptable" + + /** + * RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_NAME "Proxy Authentication Required" + + /** + * RESPONSE_REQUEST_TIMEOUT_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME "Request Timeout" + + /** + * RESPONSE_CONFLICT_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME "Conflict" + + /** + * RESPONSE_GONE_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_GONE_CODE_NAME "Gone" + + /** + * RESPONSE_LENGTH_REQUIRED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_LENGTH_REQUIRED_CODE_NAME "Length Required" + + /** + * RESPONSE_PRECONDITION_FAILED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME "Precondition Failed" + + /** + * RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME "Request Entity Too Large" + + /** + * RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME "Internal Server Error" + + /** + * RESPONSE_NOT_IMPLEMENTED_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME "Not Implemented" + + /** + * RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME + */ + #define AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME "Service Unavailable" + + /** + * SOCKET + */ + #define AXIS2_SOCKET "SOCKET" + + /** + * HEADER_PROTOCOL_10 + */ + #define AXIS2_HTTP_HEADER_PROTOCOL_10 "HTTP/1.0" + + /** + * HEADER_PROTOCOL_11 + */ + #define AXIS2_HTTP_HEADER_PROTOCOL_11 "HTTP/1.1" + + /** + * CHAR_SET_ENCODING + */ + #define AXIS2_HTTP_CHAR_SET_ENCODING "charset" + + /** + * HEADER_POST + */ + #define AXIS2_HTTP_POST "POST" + + /** + * HEADER_GET + */ + #define AXIS2_HTTP_GET "GET" + + /** + * HEADER_HEAD + */ + #define AXIS2_HTTP_HEAD "HEAD" + + /** + * HEADER_PUT + */ + #define AXIS2_HTTP_PUT "PUT" + + /** + * HEADER_DELETE + */ + #define AXIS2_HTTP_DELETE "DELETE" + + /** + * HEADER_HOST + */ + #define AXIS2_HTTP_HEADER_HOST "Host" + + /** + * HEADER_CONTENT_DESCRIPTION + */ + #define AXIS2_HTP_HEADER_CONTENT_DESCRIPTION "Content-Description" + + /** + * HEADER_CONTENT_TYPE + */ + #define AXIS2_HTTP_HEADER_CONTENT_TYPE "Content-Type" + #define AXIS2_HTTP_HEADER_CONTENT_TYPE_ "Content-Type: " + + /** + *USER DEFINED HEADER CONTENT TYPE + */ + + #define AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE "User_Content_Type" + + /** + * HEADER_CONTENT_TYPE + */ + #define AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY "boundary" + + /** + * HEADER_CONTENT_TRANSFER_ENCODING + */ + #define AXIS2_HTTP_HEADER_CONTENT_TRANSFER_ENCODING \ + "Content-Transfer-Encoding" + + /** + * HEADER_CONTENT_LENGTH + */ + #define AXIS2_HTTP_HEADER_CONTENT_LENGTH "Content-Length" + + /** + * HEADER_CONTENT_LANGUAGE + */ + #define AXIS2_HTTP_HEADER_CONTENT_LANGUAGE "Content-Language" + + #define AXIS2_HTTP_HEADER_CONTENT_LENGTH_ "Content-Length: " + + /** + * HEADER_CONTENT_LOCATION + */ + #define AXIS2_HTTP_HEADER_CONTENT_LOCATION "Content-Location" + + /** + * HEADER_CONTENT_ID + */ + #define AXIS2_HTTP_HEADER_CONTENT_ID "Content-Id" + + /** + * HEADER_SOAP_ACTION + */ + #define AXIS2_HTTP_HEADER_SOAP_ACTION "SOAPAction" + #define AXIS2_HTTP_HEADER_SOAP_ACTION_ "SOAPAction: " + + /** + * HEADER_AUTHORIZATION + */ + #define AXIS2_HTTP_HEADER_AUTHORIZATION "Authorization" + + /** + * HEADER_WWW_AUTHENTICATE + */ + #define AXIS2_HTTP_HEADER_WWW_AUTHENTICATE "WWW-Authenticate" + + /** + * HEADER_PROXY_AUTHENTICATE + */ + #define AXIS2_HTTP_HEADER_PROXY_AUTHENTICATE "Proxy-Authenticate" + + /** + * HEADER_PROXY_AUTHORIZATION + */ + #define AXIS2_HTTP_HEADER_PROXY_AUTHORIZATION "Proxy-Authorization" + + /** + * AUTHORIZATION_REQUEST_PARAM_REALM + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM "realm" + + /** + * AUTHORIZATION_REQUEST_PARAM_DOMAIN + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_DOMAIN "domain" + + /** + * AUTHORIZATION_REQUEST_PARAM_NONCE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE "nonce" + + /** + * AUTHORIZATION_REQUEST_PARAM_OPAQUE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE "opaque" + + /** + * AUTHORIZATION_REQUEST_PARAM_STALE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_STALE "stale" + + /** + * AUTHORIZATION_REQUEST_PARAM_ALGORITHM + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_ALGORITHM "algorithm" + + /** + * AUTHORIZATION_REQUEST_PARAM_QOP + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP "qop" + + /** + * AUTHORIZATION_REQUEST_PARAM_USERNAME + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_USERNAME "username" + + /** + * AUTHORIZATION_REQUEST_PARAM_URI + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_URI "uri" + + /** + * AUTHORIZATION_REQUEST_PARAM_RESPONSE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_RESPONSE "response" + + /** + * AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT "nc" + + /** + * AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE "cnonce" + + /** + * AUTHORIZATION_REQUEST_DEFAULT_CLIENT_NONCE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_DEFAULT_CLIENT_NONCE "00000001" + + /** + * AUTHORIZATION_REQUEST_QOP_OPTION_AUTH + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_QOP_OPTION_AUTH "auth" + + /** + * AUTHORIZATION_REQUEST_QOP_OPTION_AUTH_INT + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_QOP_OPTION_AUTH_INT "auth-int" + + /** + * AUTHORIZATION_REQUEST_STALE_STATE_TRUE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_STALE_STATE_TRUE "true" + + /** + * AUTHORIZATION_REQUEST_STALE_STATE_FALSE + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_STALE_STATE_FALSE "false" + + /** + * AUTHORIZATION_REQUEST_ALGORITHM_MD5 + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_ALGORITHM_MD5 "MD5" + + /** + * AUTHORIZATION_REQUEST_ALGORITHM_MD5_SESS + */ + #define AXIS2_HTTP_AUTHORIZATION_REQUEST_ALGORITHM_MD5_SESS "MD5-sess" + + /** + * HEADER_EXPECT + */ + #define AXIS2_HTTP_HEADER_EXPECT "Expect" + + /** + * HEADER_EXPECT_100_Continue + */ + #define AXIS2_HTTP_HEADER_EXPECT_100_CONTINUE "100-continue" + + /** + * HEADER_USER_AGENT + */ + #define AXIS2_HTTP_HEADER_USER_AGENT "User-Agent" + + /** + * HEADER_USER_AGENT_AXIS2C + */ + #define AXIS2_HTTP_HEADER_USER_AGENT_AXIS2C "User-Agent: Axis2C/" AXIS2_VERSION_STRING + + /** + * HEADER_SERVER + */ + #define AXIS2_HTTP_HEADER_SERVER "Server" + + /** + * HEADER_DATE + */ + #define AXIS2_HTTP_HEADER_DATE "Date" + + /** + * HEADER_SERVER_AXIS2C + */ + #define AXIS2_HTTP_HEADER_SERVER_AXIS2C "Axis2C/" AXIS2_VERSION_STRING + + #define AXIS2_HTTP_HEADER_ACCEPT_ "Accept: " + + #define AXIS2_HTTP_HEADER_EXPECT_ "Expect: " + + /** + * HEADER_CACHE_CONTROL + */ + #define AXIS2_HTTP_HEADER_CACHE_CONTROL "Cache-Control" + + /** + * HEADER_CACHE_CONTROL_NOCACHE + */ + #define AXIS2_HTTP_HEADER_CACHE_CONTROL_NOCACHE "no-cache" + + /** + * HEADER_PRAGMA + */ + #define AXIS2_HTTP_HEADER_PRAGMA "Pragma" + + /** + * HEADER_LOCATION + */ + #define AXIS2_HTTP_HEADER_LOCATION "Location" + + /** + * REQUEST_HEADERS + */ + #define AXIS2_HTTP_REQUEST_HEADERS "HTTP-Request-Headers" + + /** + * RESPONSE_HEADERS + */ + #define AXIS2_HTTP_RESPONSE_HEADERS "HTTP-Response-Headers" + + /* http 1.1 */ + + /** + * HEADER_TRANSFER_ENCODING + */ + #define AXIS2_HTTP_HEADER_TRANSFER_ENCODING "Transfer-Encoding" + + /** + * HEADER_TRANSFER_ENCODING_CHUNKED + */ + #define AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED "chunked" + + /** + * HEADER_CONNECTION + */ + #define AXIS2_HTTP_HEADER_CONNECTION "Connection" + +#define AXIS2_HTTP_CONNECTION_MAP "connection_map" + + /** + * HEADER_CONNECTION_CLOSE + */ + #define AXIS2_HTTP_HEADER_CONNECTION_CLOSE "close" + + /** + * HEADER_CONNECTION_KEEPALIVE + */ + #define AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE "Keep-Alive" + + #define AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE "is_app_client_side" + /** + * HEADER_ACCEPT + */ + #define AXIS2_HTTP_HEADER_ACCEPT "Accept" + + /** + * HEADER_ACCEPT_CHARSET + */ + #define AXIS2_HTTP_HEADER_ACCEPT_CHARSET "Accept-Charset" + + /** + * AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE + */ + #define AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE "Accept-Language" + + /** + * HEADER_ALLOW + */ + #define AXIS2_HTTP_HEADER_ALLOW "Allow" + + /** + * HEADER_ACCEPT_ALL + */ + #define AXIS2_HTTP_HEADER_ACCEPT_ALL "*/*" + + /** + * HEADER_ACCEPT_TEXT_ALL + */ + #define AXIS2_HTTP_HEADER_ACCEPT_TEXT_ALL "text/*" + + /** + * HEADER_ACCEPT_TEXT_PLAIN + */ + #define AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN "text/plain" + + /** + * HEADER_ACCEPT_TEXT_HTML + */ + #define AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML "text/html" + + /** + * HEADER APPLICATION_XML + */ + #define AXIS2_HTTP_HEADER_ACCEPT_APPLICATION_XML "application/xml" + + /** + * HEADER_ACCEPT_TEXT_XML + */ + #define AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML "text/xml" + + /** + * HEADER_ACCEPT_APPL_SOAP + */ + #define AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP "application/soap+xml" + + /** + * HEADER_ACCEPT_X_WWW_FORM_URLENCODED + */ + #define AXIS2_HTTP_HEADER_ACCEPT_X_WWW_FORM_URLENCODED "application/x-www-form-urlencoded" + + /** + * HEADER XOP XML + */ + #define AXIS2_HTTP_HEADER_ACCEPT_XOP_XML AXIOM_MIME_TYPE_XOP_XML + + /** + * HEADER_ACCEPT_MULTIPART_RELATED + */ + #define AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED AXIOM_MIME_TYPE_MULTIPART_RELATED + + /** + * HEADER_ACCEPT_APPLICATION_DIME + */ + #define AXIS2_HTTP_HEADER_ACCEPT_APPLICATION_DIME "application/dime" + + /** + * Cookie headers + */ + #define AXIS2_HTTP_HEADER_COOKIE "Cookie" + + /** + * HEADER_COOKIE2 + */ + #define AXIS2_HTTP_HEADER_COOKIE2 "Cookie2" + + /** + * HEADER_SET_COOKIE + */ + #define AXIS2_HTTP_HEADER_SET_COOKIE "Set-Cookie" + + /** + * HEADER_SET_COOKIE2 + */ + #define AXIS2_HTTP_HEADER_SET_COOKIE2 "Set-Cookie2" + + /** + * HTTP header field values + */ + #define AXIS2_HTTP_HEADER_DEFAULT_CHAR_ENCODING "iso-8859-1" + + /** + * REPONSE_HTTP_OK + */ + #define AXIS2_HTTP_RESPONSE_OK "200 OK" + + /** + * RESPONSE_HTTP_NOCONTENT + */ + #define AXIS2_HTTP_RESPONSE_NOCONTENT "202 OK"; + + /** + * RESPONSE_HTTP_UNAUTHORIZED + */ + #define AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED "401 Unauthorized" + + + /** + * RESPONSE_HTTP_FORBIDDEN + */ + #define AXIS2_HTTP_RESPONSE_HTTP_FORBIDDEN "403 Forbidden" + + /** + * RESPONSE_PROXY_AUTHENTICATION_REQUIRED + */ + #define AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED "407 Proxy Authentication Required" + + /** + * RESPONSE_BAD_REQUEST + */ + #define AXIS2_HTTP_RESPONSE_BAD_REQUEST "400 Bad Request" + + /** + * RESPONSE_HTTP_INTERNAL_SERVER_ERROR + */ + #define AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR "500 Internal Server Error" + + /** + * HTTP_REQ_TYPE + */ + #define AXIS2_HTTP_REQ_TYPE "HTTP_REQ_TYPE" + + /** + * SO_TIMEOUT + */ + #define AXIS2_HTTP_SO_TIMEOUT "SO_TIMEOUT" + + /** + * CONNECTION_TIMEOUT + */ + #define AXIS2_HTTP_CONNECTION_TIMEOUT "CONNECTION_TIMEOUT" + + /** + * DEFAULT_SO_TIMEOUT + */ + #define AXIS2_HTTP_DEFAULT_SO_TIMEOUT 60000 + + /** + * DEFAULT_CONNECTION_TIMEOUT + */ + #define AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT 60000 + + #define AXIS2_HTTP_PROXY "PROXY" + + /** + * ISO-8859-1 encoding + */ + #define AXIS2_HTTP_ISO_8859_1 "ISO-8859-1" + + /** + * Default charset in content + */ + #define AXIS2_HTTP_DEFAULT_CONTENT_CHARSET "ISO-8859-1" + + /** + * Field TRANSPORT_HTTP + */ + #define AXIS2_TRANSPORT_HTTP "http" + + /** + * Msg context response written key + */ + #define AXIS2_RESPONSE_WRITTEN "CONTENT_WRITTEN" + + /** + * Content type for MTOM + */ + #define MTOM_RECIVED_CONTENT_TYPE "MTOM_RECEIVED" + + /** + * Constant for HTTP authentication + */ + #define AXIS2_HTTP_AUTHENTICATION "HTTP-Authentication" + + /** + * Constant for HTTP authentication username + */ + #define AXIS2_HTTP_AUTHENTICATION_USERNAME "username" + + /** + * Constant for HTTP authentication password + */ + #define AXIS2_HTTP_AUTHENTICATION_PASSWORD "password" + + /** + * Constant for HTTP proxy + */ + #define AXIS2_HTTP_PROXY "PROXY" + + /** + * Constant for HTTP proxy host + */ + #define AXIS2_HTTP_PROXY_HOST "proxy_host" + + /** + * Constant for HTTP proxy port + */ + #define AXIS2_HTTP_PROXY_PORT "proxy_port" + + /** + * Constant for HTTP proxy username + */ + #define AXIS2_HTTP_PROXY_USERNAME "proxy_username" + + /** + * Constant for HTTP proxy password + */ + #define AXIS2_HTTP_PROXY_PASSWORD "proxy_password" + + + #define AXIS2_HTTP_PROXY_API "PROXY_API" + + /** + * Constant for HTTP method + */ + #define AXIS2_HTTP_METHOD "HTTP_METHOD" + + /** + * Constant for SSL Server Certificate + */ + #define AXIS2_SSL_SERVER_CERT "SERVER_CERT" + + /** + * Constant for SSL Key File + */ + #define AXIS2_SSL_KEY_FILE "KEY_FILE" + + /** + * Constant for SSL Passphrase + */ + #define AXIS2_SSL_PASSPHRASE "SSL_PASSPHRASE" + + /** + * Constant for SSL verify server host property name + * + * 2 - certificate name must match intended host name + * 1 - certificate must have any Common Name + * 0 - do not check certificate name + * + * Only used with libcurl. + */ + #define AXIS2_SSL_VERIFY_HOST "SSL_VERIFY_HOST" + + /** + * Constant for SSL verify server certificate property name + * + * AXIS2_TRUE - verify certificate is authentic + * AXIS2_FALSE - do not check certificate + * + * Only used with libcurl. + */ + #define AXIS2_SSL_VERIFY_PEER "SSL_VERIFY_PEER" + + + /** + * HTTP authentication username property name + */ + #define AXIS2_HTTP_AUTH_UNAME "HTTP_AUTH_USERNAME" + + /** + * HTTP authentication password property name + */ + #define AXIS2_HTTP_AUTH_PASSWD "HTTP_AUTH_PASSWD" + + /** + * Proxy authentication username property name + */ + #define AXIS2_PROXY_AUTH_UNAME "PROXY_AUTH_USERNAME" + + /** + * Proxy authentication password property name + */ + #define AXIS2_PROXY_AUTH_PASSWD "PROXY_AUTH_PASSWD" + + + /* #define AXIS2_HTTP_AUTH_TYPE "HTTP_AUTH_TYPE"*/ + + /** + * HTTP "Basic" authentication + */ + #define AXIS2_HTTP_AUTH_TYPE_BASIC "Basic" + + /** + * HTTP "Digest" authentication + */ + #define AXIS2_HTTP_AUTH_TYPE_DIGEST "Digest" + + /** + * Proxy "Basic" authentication + */ + #define AXIS2_PROXY_AUTH_TYPE_BASIC "Basic" + + /** + * Proxy "Digest" authentication + */ + #define AXIS2_PROXY_AUTH_TYPE_DIGEST "Digest" + + + /** + *HTTP Transport Level Error + */ + #define AXIS2_HTTP_TRANSPORT_ERROR "http_transport_error" + + /** + *415 Unsupported media Type + */ + #define AXIS2_HTTP_UNSUPPORTED_MEDIA_TYPE "415 Unsupported Media Type\r\n" + + /** + *Constant for HTTP headers that user specify, Those headers will + *provided as property to the message context. + */ + #define AXIS2_TRANSPORT_HEADER_PROPERTY "HTTP_HEADER_PROPERTY" + + /** + * Default session duration + */ +#define AXIS2_TRANSPORT_SESSION_EXPIRE_DURATION 60 /* seconds */ + /** + * When a service need session it need to set a hash table into message context. + */ +#define AXIS2_TRANSPORT_SESSION_TABLE "session-table" + +#define AXIS2_TRANSPORT_SESSION_ID "session_id" +#define AXIS2_TRANSPORT_SESSION_MAP "session_map" + +#define AXIS2_TRANSPORT_URL_HTTPS "HTTPS" + + #define AXIS2_Q_MARK_STR "?" + + #define AXIS2_Q_MARK '?' + + #define AXIS2_H_MARK '#' + + #define AXIS2_ALL "ALL" + + #define AXIS2_USER_AGENT "Axis2C/" AXIS2_VERSION_STRING + + #define AXIS2_AND_SIGN "&" + + #define AXIS2_ESC_DOUBLE_QUOTE '\"' + + #define AXIS2_ESC_DOUBLE_QUOTE_STR "\"" + + #define AXIS2_ESC_SINGLE_QUOTE '\'' + + #define AXIS2_DOUBLE_QUOTE '"' + + #define AXIS2_ESC_NULL '\0' + + #define AXIS2_SEMI_COLON_STR ";" + + #define AXIS2_SEMI_COLON ';' + + #define AXIS2_COLON ':' + + #define AXIS2_COLON_STR ":" + + #define AXIS2_CONTENT_TYPE_ACTION ";action=\"" + + #define AXIS2_CONTENT_TYPE_CHARSET ";charset=" + + #define AXIS2_CHARSET "charset" + + #define AXIS2_PORT_STRING "port" + + #define AXIS2_DEFAULT_HOST_ADDRESS "127.0.0.1" + + #define AXIS2_DEFAULT_SVC_PATH "/axis2/services/" + + #define AXIS2_HTTP_PROTOCOL "http" + + #define AXIS2_HTTP "HTTP" + + #define AXIS2_SPACE_COMMA " ," + + #define AXIS2_COMMA ',' + + #define AXIS2_Q 'q' + + #define AXIS2_EQ_N_SEMICOLON " =;" + + #define AXIS2_LEVEL "level" + + #define AXIS2_SPACE_SEMICOLON " ;" + + #define AXIS2_SPACE ' ' + + #define AXIS2_RETURN '\r' + + #define AXIS2_NEW_LINE '\n' + + #define AXIS2_F_SLASH '/' + + #define AXIS2_B_SLASH '\\' + + #define AXIS2_EQ '=' + + #define AXIS2_AND '&' + + #define AXIS2_PERCENT '%' + + #define AXIS2_HTTP_SERVER " (Simple Axis2 HTTP Server)" + + #define AXIS2_COMMA_SPACE_STR ", " + + #define AXIS2_SPACE_TAB_EQ " \t=" + + #define AXIS2_ACTION "action" + + /* Error Messages */ + + #define AXIS2_HTTP_NOT_FOUND "404 Not Found\ +

Not Found

The requested URL was not found on this server.\ +

" + + + #define AXIS2_HTTP_NOT_IMPLEMENTED "501 Not Implemented\ +

Not Implemented

The requested Method is not\ +implemented on this server.

" + + + #define AXIS2_HTTP_INTERNAL_SERVER_ERROR "500 Internal Server\ + Error

Internal Server Error

The server \ +encountered an unexpected condition which prevented it from fulfilling the \ +request.

" + + + #define AXIS2_HTTP_METHOD_NOT_ALLOWED "405 Method Not Allowed\ +

Method Not Allowed

The requested method is not\ +allowed for this URL.

" + + #define AXIS2_HTTP_NOT_ACCEPTABLE "406 Not Acceptable\ +

Not Acceptable

An appropriate representation of \ +the requested resource could not be found on this server.

" + + #define AXIS2_HTTP_BAD_REQUEST "400 Bad Request\ +

Bad Request

Your client sent a request that this server\ + could not understand.

" + + #define AXIS2_HTTP_REQUEST_TIMEOUT "408 Request Timeout\ +

Request Timeout

Cannot wait any longer for \ +the HTTP request from the client.

" + + #define AXIS2_HTTP_CONFLICT "409 Conflict\ +

Conflict

The client attempted to put the server\'s resources\ + into an invalid state.

" + + #define AXIS2_HTTP_GONE "410 Gone\ +

Gone

The requested resource is no longer available on this server.\ +

" + + #define AXIS2_HTTP_PRECONDITION_FAILED "412 Precondition \ +Failed

Precondition Failed

A precondition for\ + the requested URL failed.

" + + #define AXIS2_HTTP_TOO_LARGE "413 Request Entity Too Large\ +

Request Entity Too Large

The data provided in\ + the request is too large or the requested resource does not allow request \ +data.

" + + #define AXIS2_HTTP_SERVICE_UNAVILABLE "503 Service \ +Unavailable

Service Unavailable

The service\ + is temporarily unable to serve your request.

" + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_HTTP_TRANSPORT_H */ diff --git a/include/axis2_http_transport_sender.h b/include/axis2_http_transport_sender.h new file mode 100644 index 0000000..4c8dab8 --- /dev/null +++ b/include/axis2_http_transport_sender.h @@ -0,0 +1,59 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_TRANSPORT_SENDER_H +#define AXIS2_HTTP_TRANSPORT_SENDER_H + +/** + * @defgroup axis2_http_transport_sender http transport sender + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_transport_sender.h + * @brief axis2 HTTP Transport Sender (Handler) implementation + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_transport_sender_t *AXIS2_CALL + + axis2_http_transport_sender_create( + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_TRANSPORT_SENDER_H */ diff --git a/include/axis2_http_transport_utils.h b/include/axis2_http_transport_utils.h new file mode 100644 index 0000000..9cf7563 --- /dev/null +++ b/include/axis2_http_transport_utils.h @@ -0,0 +1,487 @@ +/* + * Licensedo to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_TRANSPORT_UTILS_H +#define AXIS2_HTTP_TRANSPORT_UTILS_H + +#define AXIS2_MTOM_OUTPUT_BUFFER_SIZE 1024 + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_http_transport_utils.h + * @brief axis2 HTTP Transport Utility functions + * This file includes functions that handles soap and rest request + * that comes to the engine via HTTP protocol. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef enum axis2_http_method_types + { + AXIS2_HTTP_METHOD_GET = 0, + AXIS2_HTTP_METHOD_POST, + AXIS2_HTTP_METHOD_HEAD, + AXIS2_HTTP_METHOD_PUT, + AXIS2_HTTP_METHOD_DELETE + }axis2_http_method_types_t; + + + typedef struct axis2_http_transport_in + { + /** HTTP Content type */ + axis2_char_t *content_type; + /** HTTP Content length */ + int content_length; + /** Input message context */ + axis2_msg_ctx_t *msg_ctx; + + /** soap action */ + axis2_char_t *soap_action; + + /** complete request uri */ + axis2_char_t *request_uri; + + /** Input stream */ + axutil_stream_t *in_stream; + + /** remote request ip corresponds to CGI header REMOTE_ADDR */ + axis2_char_t *remote_ip; + + /** server port */ + axis2_char_t *svr_port; + + /** HTTP transfer encoding header value */ + axis2_char_t *transfer_encoding; + + /** HTTP Accept header */ + axis2_char_t *accept_header; + + /** HTTP Accept language header */ + axis2_char_t *accept_language_header; + + /** HTTP accept charset header */ + axis2_char_t *accept_charset_header; + /** H&TTP METHOD Should be one of AXIS2_HTTP_METHOD_GET | AXIS2_HTTP_METHOD_POST |" + AXIS2_HTTP_METHOD_HEAD | AXIS2_HTTP_METHOD_PUT | AXIS2_HTTP_METHOD_DELETE" */ + int request_method; + /** out transport */ + axis2_http_out_transport_info_t *out_transport_info; + /** this is for serving services html */ + axis2_char_t *request_url_prefix; + + }axis2_http_transport_in_t; + + typedef struct axis2_http_transport_out + { + /** HTTP Status code string */ + axis2_char_t *http_status_code_name; + /** HTTP Status code value */ + int http_status_code; + /** Out message context */ + axis2_msg_ctx_t *msg_ctx; + /** Response data */ + void *response_data; + /** HTTP content type */ + axis2_char_t *content_type; + /** Response data length */ + int response_data_length; + /** content language */ + axis2_char_t *content_language; + /** output headers list */ + axutil_array_list_t *output_headers; + + }axis2_http_transport_out_t; + + /** + * size of the key stored in the session file + */ + #define AXIS2_TRANSPORT_SESSION_KEY_SIZE 64 + /** + * size of the value stored in the session file + */ + #define AXIS2_TRANSPORT_SESSION_VALUE_SIZE 256 + typedef struct axis2_session_file_record + { + axis2_char_t key[AXIS2_TRANSPORT_SESSION_KEY_SIZE]; + axis2_char_t value[AXIS2_TRANSPORT_SESSION_VALUE_SIZE]; + } axis2_session_file_record_t; + + /** + * This will retrieve the session table, set by a service or a module and store it in a session + * file named with the unique session id, generated here in. Then it return the Set-Cookie http + * header with value containing session id and session expire time. + * @param env, environments + * @param msg_ctx + * @return cookie_header + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_session( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx); + + /** + * When the transport receive a Cookie header it calls this function. This will retrieve the + * stored session info from the file related to the id value of the cookie. It also check + * whether the session has timeout by comparing the session expire time contained in the cookie + * value with the expire time contained in the file. If session expired then it return nothing. + * If session is still valid it put the values in a hash table and set it into message context. + * @param env, environments + * @param id + * @param msg_ctx + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_transport_utils_set_session( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_char_t *session_str); + + /** + * After receiving Set-Cookie header in client side store it + * @param env, environments + * @param msg_ctx + * @param cookie + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_transport_utils_store_cookie( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_char_t *cookie); + + /** + * Read from cookie store before sending from client side + * @param env, environments + * @param msg_ctx + * @return cookie string + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_read_from_cookie_store( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx); + + /** + * Initialize the axis2_http_tranport_in_t. Before using this structure users should + * initialize it using this method. + * @param in a pointer to a axis2_http_tranport_in_t + * @param env, environments + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_transport_in_init(axis2_http_transport_in_t *in, + const axutil_env_t *env); + + /** + * Uninitialize the axis2_http_tranport_in_t. Before using this structure users should + * initialize it using this method. + * @param in a pointer to a axis2_http_tranport_in_t + * @param env, environments + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_transport_in_uninit(axis2_http_transport_in_t *request, + const axutil_env_t *env); + + /** + * Initialize the axis2_http_tranport_out_t. Before using this structure users should + * initialize it using this method. + * @param out a pointer to a axis2_http_tranport_out_t + * @param env, environments + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_transport_out_init(axis2_http_transport_out_t *out, + const axutil_env_t *env); + + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_transport_out_uninit(axis2_http_transport_out_t *response, + const axutil_env_t *env); + /** + * This methods provides the HTTP request handling functionality using axis2 for server side + * HTTP modules. + * @param env, environments + * @param conf_ctx, Instance of axis2_conf_ctx_t + * @param request, populated instance of axis2_http_transport_in_t struct + * @param response, an instance of axis2_http_transport_out_t struct + * @returns AXIS2_SUCCESS on success, AXIS2_FAILURE Otherwise + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_process_request( + const axutil_env_t *env, + axis2_conf_ctx_t *conf_ctx, + axis2_http_transport_in_t *request, + axis2_http_transport_out_t *response); + + + + /** + * This function handles the HTTP POST request that comes to the axis2 engine. + * The request can be either a SOAP request OR a REST request. + * @param env, axutil_env_t instance + * @param msg_ctx, Input message context. (an instance of axis2_msg_ctx_t struct.) + * @param in_stream, This is the input message content represented as an axutil_stream instance. + * A callback function will be used to read as required from the stream with in the engine. + * @param out_stream, This is the output stream. The outgoing message contents is represented as + * an instance of axutil_stream + * @param content_type, HTTP content type. This value should not be null. + * @param content_length, HTTP Content length value. + * @param soap_action_header, SOAPAction header value. This is only required in case of SOAP 1.1. + * For SOAP 1.2 , the action header will be within the ContentType header and + * this method is able to obtain the extract the action header value from content type. + * @param request_uri, This is the HTTP request uri. Should not be null. + * @returns AXIS2_SUCCESS on success, AXIS2_FAILURE Otherwise + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_process_http_post_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + const int content_length, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri); + + + /** + * This method handles the HTTP put request. Parameters are similar to that of post_request + * method. + * @param env, environment + * @param msg_ctx, in message context. + * @param in_stream, input stream + * @param out_stream, output stream. + * @param content_type, HTTP ContentType header value + * @param content_length, HTTP Content length value + * @param soap_action_header, SOAP Action header value + * @param request_uri, request uri + * @returns AXIS2_SUCCESS on success, AXIS2_FAILURE Otherwise + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_process_http_put_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + const int content_length, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_http_transport_utils_process_http_get_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_http_transport_utils_process_http_head_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_http_transport_utils_process_http_delete_request( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axutil_stream_t * out_stream, + const axis2_char_t * content_type, + axutil_string_t * soap_action_header, + const axis2_char_t * request_uri, + axis2_conf_ctx_t * conf_ctx, + axutil_hash_t * request_params); + + AXIS2_EXTERN axiom_stax_builder_t *AXIS2_CALL + + axis2_http_transport_utils_select_builder_for_mime( + const axutil_env_t * env, + axis2_char_t * request_uri, + axis2_msg_ctx_t * msg_ctx, + axutil_stream_t * in_stream, + axis2_char_t * content_type); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_http_transport_utils_do_write_mtom( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + + axis2_http_transport_utils_get_request_params( + const axutil_env_t * env, + axis2_char_t * request_uri); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_not_found( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_not_implemented( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_method_not_allowed( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_not_acceptable( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_bad_request( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_request_timeout( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_conflict( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_gone( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_precondition_failed( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_request_entity_too_large( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_service_unavailable( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_internal_server_error( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_transport_utils_get_services_html( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_http_transport_utils_get_services_static_wsdl( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_char_t * request_url); + + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + + axis2_http_transport_utils_get_request_params( + const axutil_env_t * env, + axis2_char_t * request_uri); + + AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL + + axis2_http_transport_utils_create_soap_msg( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + const axis2_char_t * soap_ns_uri); + + AXIS2_EXTERN axutil_array_list_t* AXIS2_CALL + axis2_http_transport_utils_process_accept_headers( + const axutil_env_t *env, + axis2_char_t *accept_value); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_transport_utils_send_mtom_message( + axutil_http_chunked_stream_t * chunked_stream, + const axutil_env_t * env, + axutil_array_list_t *mime_parts, + axis2_char_t *sending_callback_name); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_transport_utils_destroy_mime_parts( + axutil_array_list_t *mime_parts, + const axutil_env_t *env); + + AXIS2_EXTERN void *AXIS2_CALL + axis2_http_transport_utils_initiate_callback( + const axutil_env_t *env, + axis2_char_t *callback_name, + void *user_param, + axiom_mtom_sending_callback_t **callback); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL axis2_http_transport_utils_is_callback_required( + const axutil_env_t *env, + axutil_array_list_t *mime_parts); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_http_transport_utils_get_session_id_from_cookie( + const axutil_env_t *env, + axis2_char_t *cookie); + + + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_TRANSPORT_UTILS_H */ diff --git a/include/axis2_http_worker.h b/include/axis2_http_worker.h new file mode 100644 index 0000000..84bcc4b --- /dev/null +++ b/include/axis2_http_worker.h @@ -0,0 +1,115 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_HTTP_WORKER_H +#define AXIS2_HTTP_WORKER_H + +/** + * @defgroup axis2_http_worker http worker + * @ingroup axis2_core_trans_http + * @{ + */ + +/** + * @file axis2_http_worker.h + * @brief axis2 HTTP Worker + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_http_worker */ + typedef struct axis2_http_worker axis2_http_worker_t; + + /** + * @param http_worker pointer to http worker + * @param env pointer to environment struct + * @param svr_conn pointer to svr conn + * @param simple_request pointer to simple request + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_http_worker_process_request( + axis2_http_worker_t * http_worker, + const axutil_env_t * env, + axis2_simple_http_svr_conn_t * svr_conn, + axis2_http_simple_request_t * simple_request); + + /** + * @param http_worker pointer to http worker + * @param env pointer to environment struct + * @param port + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_http_worker_set_svr_port( + axis2_http_worker_t * http_worker, + const axutil_env_t * env, + int port); + + AXIS2_EXTERN void AXIS2_CALL + axis2_http_worker_set_is_application_client_side( + axis2_http_worker_t *http_worker, + const axutil_env_t *env, + axis2_bool_t application_client_side); + + /** + * @param http_worker pointer to http worker + * @param env pointer to environment strut + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_http_worker_free( + axis2_http_worker_t * http_worker, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context + */ + AXIS2_EXTERN axis2_http_worker_t *AXIS2_CALL + axis2_http_worker_create( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + + /*#define AXIS2_HTTP_WORKER_PROCESS_REQUEST(http_worker, env, svr_conn,\ + simple_request) axis2_http_worker_process_request(\ + http_worker, env, svr_conn, simple_request) + + #define AXIS2_HTTP_WORKER_SET_SVR_PORT(http_worker, env, port) \ + axis2_http_worker_set_svr_port(http_worker, env, port) + + #define AXIS2_HTTP_WORKER_FREE(http_worker, env) \ + axis2_http_worker_free(http_worker, env) + */ + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_HTTP_WORKER_H */ diff --git a/include/axis2_listener_manager.h b/include/axis2_listener_manager.h new file mode 100644 index 0000000..c16f5be --- /dev/null +++ b/include/axis2_listener_manager.h @@ -0,0 +1,136 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_LISTENER_MANAGER_H +#define AXIS2_LISTENER_MANAGER_H + +/** + * @defgroup axis2_listener_manager listener manager + * @ingroup axis2_core_context + * listener manager manages the listeners in case of dual channel invocations. + * In case of a dual channel invocation, request is sent along one channel + * and the response is received on another channel. When the response is + * expected to be received along another transport channel, it has to be + * made sure that the listener socket is up in anticipation of the response + * and also that listener must be closed once the response is received. + * listener manager is responsible for dealing with these tasks. + * @{ + */ + +/** + * @file axis2_listener_manager.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_listener_manager */ + typedef struct axis2_listener_manager axis2_listener_manager_t; + + /** + * Ensures that the named transport's listener is started. Starts a listener + * if it is not already started. Only one listener would be started for a given + * transport. + * @param listener_manager pointer to listener manager struct + * @param env pointer to environment struct + * @param transport name of the transport + * @param conf_ctx configuration context to pick transport info for the + * named transport + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_listener_manager_make_sure_started( + axis2_listener_manager_t * listener_manager, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS transport, + axis2_conf_ctx_t * conf_ctx); + + /** + * Stops the named listener transport. + * @param listener_manager pointer to listener manager struct + * @param env pointer to environment struct + * @param transport name of the transport whose listener is to be stopped + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_listener_manager_stop( + axis2_listener_manager_t * listener_manager, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS transport); + + /** + * Gets reply to end point reference. The engine will direct the + * response for the message to this reply to address. + * @param listener_manager pointer to listener manager struct + * @param env pointer to environment struct + * @param svc_name name of the service for which the epr is to be returned + * @param transport name of the transport corresponding to the endpoint + * @return a pointer to endpoint reference struct representing the reply + * endpoint + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_listener_manager_get_reply_to_epr( + const axis2_listener_manager_t * listener_manager, + const axutil_env_t * env, + const axis2_char_t * svc_name, + const AXIS2_TRANSPORT_ENUMS transport); + + /** + * Gets the configuration context that holds information on the transports + * managed by the listener manager. + * @param listener_manager pointer to listener manager struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL + axis2_listener_manager_get_conf_ctx( + const axis2_listener_manager_t * listener_manager, + const axutil_env_t * env); + + /** + * Frees listener manager struct. + * @param listener_manager pointer to listener manager struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_listener_manager_free( + axis2_listener_manager_t * listener_manager, + const axutil_env_t * env); + + /** + * Creates a listener manager struct instance. + * @param env pointer to environment struct + * @return a pointer to newly created listener manager struct, + * or NULL on error with error code set in environment's error + */ + AXIS2_EXTERN axis2_listener_manager_t *AXIS2_CALL + axis2_listener_manager_create( + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_LISTENER_MANAGER_H */ diff --git a/include/axis2_module.h b/include/axis2_module.h new file mode 100644 index 0000000..625c9ea --- /dev/null +++ b/include/axis2_module.h @@ -0,0 +1,161 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef AXIS2_MODULE_H +#define AXIS2_MODULE_H + +/** + * @defgroup axis2_module module + * @ingroup axis2_desc + * Every module provides an implementation of struct interface. Modules are in + * one of two states: "available" or "initialized". All modules that the run-time + * detects (from the repository modules directory) are said to be in the + * "available" state. If some service indicates a dependency on this + * module then the module is initialized (once for the life time of the system) + * and the state changes to "initialized". + * Any module which is in the "initialized" state can be engaged as needed + * by the engine to respond to a message. Module engagement is done by + * deployment engine using module.xml. + * @{ + */ + +/** + * @file axis2_module.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for axis2_module_ops */ + typedef struct axis2_module_ops axis2_module_ops_t; + + /** Type name for axis2_module_ops */ + typedef struct axis2_module axis2_module_t; + + struct axis2_conf; + + /** + * Struct containing operations available on a module. + * \n + * 1. init + * \n + * 2. shutdown + * \n + * 3. fill_handler_create_func_map + * \n + * are the three operations presently available. + */ + struct axis2_module_ops + { + + /** + * Initializes module. + * @param module pointer to module struct + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context + * @param module_desc module description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + axis2_status_t( + AXIS2_CALL + * init)( + axis2_module_t * module, + const axutil_env_t * env, + struct axis2_conf_ctx * conf_ctx, + axis2_module_desc_t * module_desc); + + /** + * Shutdowns module. + * @param module pointer to module struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + axis2_status_t( + AXIS2_CALL + * shutdown)( + axis2_module_t * module, + const axutil_env_t * env); + + /** + * Fills the hash map of handler create functions for the module. + * @param module pointer to module struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + axis2_status_t( + AXIS2_CALL + * fill_handler_create_func_map)( + axis2_module_t * module, + const axutil_env_t * env); + + }; + + /** + * Struct representing a module. + */ + struct axis2_module + { + + /** operations of module */ + const axis2_module_ops_t *ops; + + /** hash map of handler create functions */ + axutil_hash_t *handler_create_func_map; + }; + + /** + * Creates module struct. + * @param env pointer to environment struct + * @return pointer to newly created module + */ + AXIS2_EXTERN axis2_module_t *AXIS2_CALL + axis2_module_create( + const axutil_env_t * env); + + /** Initializes module. + @sa axis2_module_ops#init */ +#define axis2_module_init(module, env, conf_ctx, module_desc) \ + ((module)->ops->init (module, env, conf_ctx, module_desc)) + + /** Shutdowns module. + @sa axis2_module_ops#shutdown */ +#define axis2_module_shutdown(module, env) \ + ((module)->ops->shutdown (module, env)) + + /** Fills handler create function map. + @sa axis2_module_ops#fill_handler_create_func_map */ +#define axis2_module_fill_handler_create_func_map(module, env) \ + ((module)->ops->fill_handler_create_func_map (module, env)) + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_MODULE_H */ diff --git a/include/axis2_module_desc.h b/include/axis2_module_desc.h new file mode 100644 index 0000000..611fd92 --- /dev/null +++ b/include/axis2_module_desc.h @@ -0,0 +1,386 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_MODULE_DESC_H +#define AXIS2_MODULE_DESC_H + +/** + * @defgroup axis2_module_desc module description + * @ingroup axis2_desc + * module holds information about a module. This information includes module + * parameters and handler information. + * Modules are available to all services if axis2.xml has a module reference + * entry. Alternatively, a module could be made available to selected services + * by including a module reference entry in services.xml. + * @{ + */ + +/** + * @file axis2_module_desc.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_module_desc */ + typedef struct axis2_module_desc axis2_module_desc_t; + + struct axis2_op; + struct axis2_conf; + + /** + * Frees module description. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_module_desc_free( + axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Gets flow representing in flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to flow that represents in flow, returns a reference + * not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_module_desc_get_in_flow( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Sets flow representing in flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param in_flow pointer to flow representing in flow, module assumes + * ownership of flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_set_in_flow( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axis2_flow_t * in_flow); + + /** + * Gets flow representing out flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to flow that represents out flow, returns a reference + * not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_module_desc_get_out_flow( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Sets flow representing out flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param out_flow pointer to flow representing out flow, module assumes + * ownership of flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_set_out_flow( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axis2_flow_t * out_flow); + + /** + * Gets flow representing fault in flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to flow that represents fault in flow, returns a reference + * not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_module_desc_get_fault_in_flow( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Sets flow representing fault in flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param falut_in_flow pointer to flow representing fault in flow, + * module assumes ownership of flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_set_fault_in_flow( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axis2_flow_t * falut_in_flow); + + /** + * Gets flow representing fault out flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to flow that represents fault out flow, returns a + * reference not a cloned copy + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_module_desc_get_fault_out_flow( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Sets flow representing fault out flow. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param fault_out_flow pointer to flow representing fault out flow, + * module assumes ownership of flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_set_fault_out_flow( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axis2_flow_t * fault_out_flow); + + /** + * Gets module QName. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to QName + */ + AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL + axis2_module_desc_get_qname( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Sets module QName. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param qname pointer to qname + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_set_qname( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Adds given operation to module. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param op pointer to operation, module assumes ownership of operation + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_add_op( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + struct axis2_op *op); + + /** + * Gets all operations associated with module. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to hash map containing the operations + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_module_desc_get_all_ops( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Gets parent which is of type configuration. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to configuration, returns a reference not a + * cloned copy + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_module_desc_get_parent( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Sets parent which is of type configuration. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param parent pointer to parent configuration, module does not assume + * the ownership of configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_set_parent( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + struct axis2_conf *parent); + + /** + * Adds parameter to module description. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param param pointer to parameter struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_add_param( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets parameter with given name. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param name parameter name string + * @return pointer to parameter corresponding to given name + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_module_desc_get_param( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Gets all parameters associated with module. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to array list containing all parameters + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_module_desc_get_all_params( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Checks if a given parameter is locked. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param param_name parameter name string + * @return AXIS2_TRUE if named parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_module_desc_is_param_locked( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Gets module associated with module description. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to module + */ + AXIS2_EXTERN struct axis2_module *AXIS2_CALL + axis2_module_desc_get_module( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @param module pointer to module, module description assumes ownership + * of module + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_module_desc_set_module( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + struct axis2_module *module); + + /** + * Gets the container having all params. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to param container + * @sa axutil_param_container + */ + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + axis2_module_desc_get_param_container( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Gets the container having all flows. + * @param module_desc pointer to module description + * @param env pointer to environment struct + * @return pointer to param container + * @sa axis2_flow_container + */ + AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL + axis2_module_desc_get_flow_container( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env); + + /** + * Creates module description struct instance. + * @param env pointer to environment struct + * @return pointer to newly created module description + */ + AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL + axis2_module_desc_create( + const axutil_env_t * env); + + /** + * Creates module description struct instance with given QName. + * @param env pointer to environment struct + * @param qname pointer to QName + * @return pointer to newly created module description + */ + AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL + axis2_module_desc_create_with_qname( + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Frees module description passed as void pointer. This method will cast + * the void pointer parameter into appropriate type and then call module + * description free method on top of that pointer. + * @param module_desc pointer to module description as a void pointer + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_module_desc_free_void_arg( + void *module_desc, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_MODULE_DESC_H */ diff --git a/include/axis2_msg.h b/include/axis2_msg.h new file mode 100644 index 0000000..aace1ed --- /dev/null +++ b/include/axis2_msg.h @@ -0,0 +1,298 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_MSG_H +#define AXIS2_MSG_H + +/** + * @defgroup axis2_msg message + * @ingroup axis2_desc + * message represents a message in a WSDL. It captures SOAP headers related to + * a given message, the direction as well as the phases to be invoked along + * the flow. Based on the message direction, there could be only one flow + * associated with a message. + * @{ + */ + +/** + * @file axis2_msg.h + */ + +#include +#include +#include +#include +#include + + /** Message of IN flow */ +#define AXIS2_MSG_IN "in" + + /** Message of OUT flow */ +#define AXIS2_MSG_OUT "out" + + /** Message of IN FAULT flow */ +#define AXIS2_MSG_IN_FAULT "InFaultMessage" + + /** Message of OUT FAULT flow */ +#define AXIS2_MSG_OUT_FAULT "OutFaultMessage" + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_msg */ + typedef struct axis2_msg axis2_msg_t; + + /** + * Creates message struct instance. + * @param env pointer to environment struct + * @return pointer to newly created message + */ + AXIS2_EXTERN axis2_msg_t *AXIS2_CALL + axis2_msg_create( + const axutil_env_t * env); + + /** + * Frees message. + * @param msg pointer to message + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_msg_free( + axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Adds a parameter. + * @param msg pointer to message + * @param env pointer to environment struct + * @param param pointer to parameter, message assumes ownership of + * parameter + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_add_param( + axis2_msg_t * msg, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets the named parameter. + * @param msg pointer to message + * @param env pointer to environment struct + * @param name parameter name string + * @return pointer to parameter corresponding to the same name, returns + * a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_msg_get_param( + const axis2_msg_t * msg, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Gets all parameters stored in message. + * @param msg pointer to message + * @param env pointer to environment struct + * @return pointer to list of parameters, returns a reference, not a + * cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_get_all_params( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Checks if the named parameter is locked. + * @param msg pointer to message + * @param env pointer to environment struct + * @param param_name parameter name string + * @return AXIS2_TRUE if the parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_is_param_locked( + axis2_msg_t * msg, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Sets parent. Parent of a message is of type operation. + * @param msg pointer to message + * @param env pointer to environment struct + * @param op pointer to parent operation, message does not assume + * ownership of parent + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_set_parent( + axis2_msg_t * msg, + const axutil_env_t * env, + axis2_op_t * op); + + /** + * Gets parent. Parent of a message is of type operation. + * @param msg pointer to message + * @param env pointer to environment struct + * @return pointer to parent operation, returns a reference, not a + * cloned copy + */ + AXIS2_EXTERN axis2_op_t *AXIS2_CALL + axis2_msg_get_parent( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Gets flow of execution associated with the message. + * @param msg pointer to message + * @param env pointer to environment struct + * @return pointer to array list containing the list of phases + * representing the flow + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_get_flow( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Sets flow of execution associated with the message. + * @param msg pointer to message + * @param env pointer to environment struct + * @param flow pointer to array list of phases representing the flow, + * message assumes ownership of flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_set_flow( + axis2_msg_t * msg, + const axutil_env_t * env, + axutil_array_list_t * flow); + + /** + * Gets direction of message. + * @param msg pointer to message + * @param env pointer to environment struct + * @return direction string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_get_direction( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Sets direction of message. + * @param msg pointer to message + * @param env pointer to environment struct + * @param direction pointer to direction + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_set_direction( + axis2_msg_t * msg, + const axutil_env_t * env, + const axis2_char_t * direction); + + /** + * Gets QName representing message. + * @param msg pointer to message + * @param env pointer to environment struct + * @return pointer to QName, returns a reference, not a cloned copy + */ + AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL + axis2_msg_get_element_qname( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Sets QName representing message. + * @param msg pointer to message + * @param env pointer to environment struct + * @param element_qname pointer to QName representing message, this + * function creates a clone of QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_set_element_qname( + axis2_msg_t * msg, + const axutil_env_t * env, + const axutil_qname_t * element_qname); + + /** + * Gets message name. + * @param msg pointer to message + * @param env pointer to environment struct + * @return message name string. + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_get_name( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Sets message name. + * @param msg pointer to message + * @param env pointer to environment struct + * @param name message name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_set_name( + axis2_msg_t * msg, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Gets base description. + * @param msg pointer to message + * @param env pointer to environment struct + * @return pointer to base description struct + */ + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_msg_get_base( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Gets container of parameters belonging to message. + * @param msg pointer to message + * @param env pointer to environment struct + * @return returns container of parameters + * @sa axutil_param_container + */ + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + axis2_msg_get_param_container( + const axis2_msg_t * msg, + const axutil_env_t * env); + + /** + * Increments the reference count to this oject + * @param msg pointer to message + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_increment_ref( + axis2_msg_t * msg, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_MSG_H */ diff --git a/include/axis2_msg_ctx.h b/include/axis2_msg_ctx.h new file mode 100644 index 0000000..b1d4d0f --- /dev/null +++ b/include/axis2_msg_ctx.h @@ -0,0 +1,2098 @@ +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_MSG_CTX_H +#define AXIS2_MSG_CTX_H + +/** + * @defgroup axis2_msg_ctx message context + * @ingroup axis2_context + * message context captures all state information related to a message + * invocation. It holds information on the service and operation to be invoked + * as well as context hierarchy information related to the service and operation. + * It also has information on transports, that are to be used in invocation. The + * phase information is kept, along with the phase at which message invocation was + * paused as well as the handler in the phase from which the invocation is to be + * resumed. message context would hold the request SOAP message along the out + * path and would capture response along the in path. + * message context also has information on various engine specific information, + * such as if it should be doing MTOM, REST. + * As message context is inherited form context, it has the capability of + * storing user defined properties. + * @{ + */ + +/** + * @file axis2_msg_ctx.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** transport headers */ +#define AXIS2_TRANSPORT_HEADERS "AXIS2_TRANSPORT_HEADERS" + + /** transport in */ +#define AXIS2_TRANSPORT_OUT "AXIS2_TRANSPORT_OUT" + + /** transport out */ +#define AXIS2_TRANSPORT_IN "AXIS2_TRANSPORT_IN" + + /** character set encoding */ +#define AXIS2_CHARACTER_SET_ENCODING "AXIS2_CHARACTER_SET_ENCODING" + + /** UTF_8; This is the 'utf-8' value for AXIS2_CHARACTER_SET_ENCODING property */ +#define AXIS2_UTF_8 "UTF-8" + + /** UTF_16; This is the 'utf-16' value for AXIS2_CHARACTER_SET_ENCODING property */ +#define AXIS2_UTF_16 "utf-16" + + /** default char set encoding; This is the default value for AXIS2_CHARACTER_SET_ENCODING property */ +#define AXIS2_DEFAULT_CHAR_SET_ENCODING "UTF-8" + + /** transport succeeded */ +#define AXIS2_TRANSPORT_SUCCEED "AXIS2_TRANSPORT_SUCCEED" + + /** HTTP Client */ +#define AXIS2_HTTP_CLIENT "AXIS2_HTTP_CLIENT" + + /** Transport URL */ +#define AXIS2_TRANSPORT_URL "TransportURL" + + /** PEER IP Address of Server */ +#define AXIS2_SVR_PEER_IP_ADDR "peer_ip_addr" + + /* Message flows */ + + /* In flow */ + + /*#define AXIS2_IN_FLOW 1*/ + + /* In fault flow */ + + /*#define AXIS2_IN_FAULT_FLOW 2*/ + + /* Out flow */ + + /*#define AXIS2_OUT_FLOW 3*/ + + /* Out fault flow */ + + /*#define AXIS2_OUT_FAULT_FLOW 4*/ + + /** Type name for struct axis2_msg_ctx */ + typedef struct axis2_msg_ctx axis2_msg_ctx_t; + + struct axis2_svc; + struct axis2_op; + + struct axis2_conf_ctx; + struct axis2_svc_grp_ctx; + struct axis2_svc_ctx; + struct axis2_op_ctx; + struct axis2_conf; + struct axiom_soap_envelope; + struct axis2_options; + struct axis2_transport_in_desc; + struct axis2_transport_out_desc; + struct axis2_out_transport_info; + + /** Type name for pointer to a function to find a service */ + typedef struct axis2_svc *( + AXIS2_CALL + * AXIS2_MSG_CTX_FIND_SVC) ( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** Type name for pointer to a function to find an operation in a service */ + typedef struct axis2_op *( + AXIS2_CALL + * AXIS2_MSG_CTX_FIND_OP) ( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc * svc); + + /** + * Creates a message context struct instance. + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context struct, message context + * does not assume the ownership of the struct + * @param transport_in_desc pointer to transport in description struct, + * message context does not assume the ownership of the struct + * @param transport_out_desc pointer to transport out description struct, + * message context does not assume the ownership of the struct + * @return pointer to newly created message context instance + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_msg_ctx_create( + const axutil_env_t * env, + struct axis2_conf_ctx *conf_ctx, + struct axis2_transport_in_desc *transport_in_desc, + struct axis2_transport_out_desc *transport_out_desc); + + /** + * Gets the base, which is of type context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to base context struct + */ + AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL + axis2_msg_ctx_get_base( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets parent. Parent of a message context is of type operation + * context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to operation context which is the parent + */ + AXIS2_EXTERN struct axis2_op_ctx *AXIS2_CALL + axis2_msg_ctx_get_parent( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets parent. Parent of a message context is of type operation + * context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param parent pointer to parent operation context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_parent( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_op_ctx *parent); + + /** + * Frees message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_msg_ctx_free( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Initializes the message context. Based on the transport, service and + * operation qnames set on top of message context, correct instances of + * those struct instances would be extracted from configuration and + * set within message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param conf pointer to configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_init( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Gets WS-Addressing fault to address. Fault to address tells where to + * send the fault in case there is an error. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing the fault + * to address, returns a reference not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_ctx_get_fault_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets WS-Addressing from endpoint. From address tells where the + * request came from. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing the from + * address, returns a reference not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_ctx_get_from( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Checks if there is a SOAP fault on in flow. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if there is an in flow fault, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_in_fault_flow( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the SOAP envelope. This SOAP envelope could be either request + * SOAP envelope or the response SOAP envelope, based on the state + * the message context is in. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to SOAP envelope stored within message context + */ + AXIS2_EXTERN struct axiom_soap_envelope *AXIS2_CALL + axis2_msg_ctx_get_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the SOAP envelope of the response. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to response SOAP envelope stored within message context + */ + AXIS2_EXTERN struct axiom_soap_envelope *AXIS2_CALL + axis2_msg_ctx_get_response_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets fault SOAP envelope. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to fault SOAP envelope stored within message context + */ + AXIS2_EXTERN struct axiom_soap_envelope *AXIS2_CALL + axis2_msg_ctx_get_fault_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets message ID. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param msg_id + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_msg_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * msg_id); + + /** + * Gets message ID. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return message ID string corresponding to the message the message + * context is related to + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_msg_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets process fault status. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if process fault is on, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_process_fault( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets relates to information for the message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to relates to struct + */ + AXIS2_EXTERN axis2_relates_to_t *AXIS2_CALL + axis2_msg_ctx_get_relates_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets WS-Addressing reply to endpoint. Reply to address tells where + * the the response should be sent to. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing the reply + * to address, returns a reference not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_ctx_get_reply_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Checks if it is on the server side that the message is being dealt + * with, or on the client side. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if it is server side, AXIS2_FALSE if it is client + * side + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_server_side( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets WS-Addressing to endpoint. To address tells where message should + * be sent to. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing the + * to address, returns a reference not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_ctx_get_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets WS-Addressing fault to endpoint. Fault to address tells where + * the fault message should be sent when there is an error. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param reference pointer to endpoint reference representing fault to + * address. message context assumes the ownership of endpoint struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_fault_to( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference); + + /** + * Sets WS-Addressing from endpoint. From address tells where + * the message came from. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param reference pointer to endpoint reference representing from + * address. message context assumes the ownership of endpoint struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_from( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference); + + /** + * Sets in fault flow status. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param in_fault_flow AXIS2_TRUE if there is a fault on in path, + * else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_in_fault_flow( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t in_fault_flow); + + /** + * Sets SOAP envelope. The fact that if it is the request SOAP envelope + * or that of response depends on the current status represented by + * message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param soap_envelope pointer to SOAP envelope, message context + * assumes ownership of SOAP envelope + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_soap_envelope( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axiom_soap_envelope *soap_envelope); + + /** + * Sets response SOAP envelope. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param soap_envelope pointer to SOAP envelope, message context + * assumes ownership of SOAP envelope + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_response_soap_envelope( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axiom_soap_envelope *soap_envelope); + + /** + * Sets fault SOAP envelope. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param soap_envelope pointer to SOAP envelope, message context + * assumes ownership of SOAP envelope + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_fault_soap_envelope( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axiom_soap_envelope *soap_envelope); + + /** + * Sets message ID. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param message_id message ID string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_message_id( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id); + + /** + * Sets process fault bool value. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param process_fault AXIS2_TRUE if SOAP faults are to be processed, + * else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_process_fault( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t process_fault); + + /** + * Sets relates to struct. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param reference pointer to relates to struct, message context + * assumes ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_relates_to( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_relates_to_t * reference); + + /** + * Sets WS-Addressing reply to address indicating the location to which + * the reply would be sent. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param reference pointer to endpoint reference representing reply to + * address + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_reply_to( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference); + + /** + * Sets the bool value indicating if it is the server side or the + * client side. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param server_side AXIS2_TRUE if it is server side, AXIS2_FALSE if it + * is client side + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_server_side( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t server_side); + + /** + * Sets WS-Addressing to address. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param reference pointer to endpoint reference struct representing + * the address where the request should be sent to. message context + * assumes ownership of endpoint struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_to( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference); + + /** + * Gets the bool value indicating if it is required to have a new thread + * for the invocation, or if the same thread of execution could be used. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if new thread is required, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_new_thread_required( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating if it is required to have a new thread + * for the invocation, or if the same thread of execution could be used. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param new_thread_required AXIS2_TRUE if a new thread is required, + * else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_new_thread_required( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t new_thread_required); + + /** + * Sets WS-Addressing action. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param action_uri WSA action URI string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_wsa_action( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * action_uri); + + /** + * Gets WS-Addressing action. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to WSA action URI string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_wsa_action( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets WS-Addressing message ID. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param message_id pointer to message ID string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_wsa_message_id( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id); + + /** + * Gets WS-Addressing message ID. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return WSA message ID string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_wsa_message_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets WS-Addressing message information headers. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to message information headers struct with + * WS-Addressing information. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_msg_info_headers_t *AXIS2_CALL + axis2_msg_ctx_get_msg_info_headers( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the bool value indicating the paused status. It is possible + * to pause the engine invocation by any handler. By calling this method + * one can find out if some handler has paused the invocation. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if message context is paused, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_paused( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating the paused status of invocation. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param paused paused + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_paused( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t paused); + + /** + * Gets the bool value indicating the keep alive status. It is possible + * to keep alive the message context by any handler. By calling this method + * one can see whether it is possible to clean the message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if message context is keep alive, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_is_keep_alive( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating the keep alive status of invocation. + * By setting this one can indicate the engine not to clean the message + * context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param keep_alive keep alive + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_keep_alive( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t keep_alive); + + /** + * Gets transport in description. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to transport in description struct, returns a + * reference not a cloned copy + */ + AXIS2_EXTERN struct axis2_transport_in_desc *AXIS2_CALL + axis2_msg_ctx_get_transport_in_desc( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets transport out description. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to transport out description struct, returns a + * reference not a cloned copy + */ + AXIS2_EXTERN struct axis2_transport_out_desc *AXIS2_CALL + axis2_msg_ctx_get_transport_out_desc( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets transport in description. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param transport_in_desc pointer to transport in description struct, + * message context does not assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_transport_in_desc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_transport_in_desc *transport_in_desc); + + /** + * Sets transport out description. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param transport_out_desc pointer to transport out description, + * message context does not assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_transport_out_desc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_transport_out_desc *transport_out_desc); + + /** + * Gets operation context related to the operation that this message + * context is related to. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to operation context struct + */ + AXIS2_EXTERN struct axis2_op_ctx *AXIS2_CALL + axis2_msg_ctx_get_op_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets operation context related to the operation that this message + * context is related to. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param op_ctx pointer to operation context, message context does not + * assume the ownership of operation context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_op_ctx( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_op_ctx *op_ctx); + + /** + * Gets the bool value indicating the output written status. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if output is written, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_output_written( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating the output written status. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param output_written AXIS2_TRUE if output is written, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_output_written( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t output_written); + + /** + * Gets the HTTP Method that relates to the service that is + * related to the message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return HTTP Method string, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_rest_http_method( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the HTTP Method that relates to the service that is + * related to the message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param rest_http_method HTTP Method string, msg_ctx does not assume + * ownership of rest_http_method. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_rest_http_method( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * rest_http_method); + + /** + * Gets the ID of service context that relates to the service that is + * related to the message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return service context ID string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_svc_ctx_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the ID of service context that relates to the service that is + * related to the message context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc_ctx_id The service context ID string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_svc_ctx_id( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_ctx_id); + + /** + * Gets configuration context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to configuration context + */ + AXIS2_EXTERN struct axis2_conf_ctx *AXIS2_CALL + axis2_msg_ctx_get_conf_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets service context that relates to the service that the message + * context is related to. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to message context struct + */ + AXIS2_EXTERN struct axis2_svc_ctx *AXIS2_CALL + axis2_msg_ctx_get_svc_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets configuration context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context struct, message + * context does not assume the ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_conf_ctx( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_conf_ctx *conf_ctx); + + /** + * Sets service context. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc_ctx pointer to service context struct, message + * context does not assume the ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_svc_ctx( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc_ctx *svc_ctx); + + /** + * Sets message information headers. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param msg_info_headers pointer to message information headers, + * message context assumes the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_msg_info_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_msg_info_headers_t * msg_info_headers); + + /** + * Gets configuration descriptor parameter with given key. This method + * recursively search the related description hierarchy for the parameter + * with given key until it is found or the parent of the description + * hierarchy is reached. The order of search is as follows: + * \n + * 1. search in operation description, if its there return + * \n + * 2. if the parameter is not found in operation or operation is NULL, + * search in service + * \n + * 3. if the parameter is not found in service or service is NULL search + * in configuration + * @param msg_ctx message context + * @param env pointer to environment struct + * @param key parameter key + * @return pointer to parameter struct corresponding to the given key + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_msg_ctx_get_parameter( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key); + + /** + * Gets parameters related to a named module and a given handler + * description. The order of searching for parameter is as follows: + * \n + * 1. search in module configuration stored inside corresponding operation + * description if its there + * \n + * 2. search in corresponding operation if its there + * \n + * 3. search in module configurations stored inside corresponding + * service description if its there + * \n + * 4. search in corresponding service description if its there + * \n + * 5. search in module configurations stored inside configuration + * \n + * 6. search in configuration for parameters + * \n + * 7. get the corresponding module and search for the parameters + * \n + * 8. search in handler description for the parameter + * @param msg_ctx pointer to message context + * @param env pointer to environment struct + * @param key parameter key + * @param module_name name of the module + * @param handler_desc pointer to handler description + * @return pointer to parameter + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_msg_ctx_get_module_parameter( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key, + const axis2_char_t * module_name, + axis2_handler_desc_t * handler_desc); + + /** + * Gets property corresponding to the given key. + * @param msg_ctx pointer to message context + * @param env pointer to environment struct + * @param key key string with which the property is stored + * @return pointer to property struct + */ + AXIS2_EXTERN axutil_property_t *AXIS2_CALL + axis2_msg_ctx_get_property( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key); + + /** + * Gets property value corresponding to the property given key. + * @param msg_ctx pointer to message context + * @param env pointer to environment struct + * @param property_str key string with which the property is stored + * @return pointer to property struct + */ + AXIS2_EXTERN void *AXIS2_CALL + axis2_msg_ctx_get_property_value( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * property_str); + + /** + * Sets property with given key. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param key key string + * @param value property to be stored + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_property( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key, + axutil_property_t * value); + + /** + * Gets the QName of the handler at which invocation was paused. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to QName of the paused handler + */ + AXIS2_EXTERN const axutil_string_t *AXIS2_CALL + axis2_msg_ctx_get_paused_handler_name( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the name of the phase at which the invocation was paused. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return name string of the paused phase. + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_paused_phase_name( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the name of the phase at which the invocation was paused. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param paused_phase_name paused phase name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_paused_phase_name( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * paused_phase_name); + + /** + * Gets SOAP action. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return SOAP action string + */ + AXIS2_EXTERN axutil_string_t *AXIS2_CALL + axis2_msg_ctx_get_soap_action( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets SOAP action. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param soap_action SOAP action string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_soap_action( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_string_t * soap_action); + + /** + * Gets the boolean value indicating if MTOM is enabled or not. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if MTOM is enabled, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_doing_mtom( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the boolean value indicating if MTOM is enabled or not. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param doing_mtom AXIS2_TRUE if MTOM is enabled, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_doing_mtom( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t doing_mtom); + + /** + * Gets the boolean value indicating if REST is enabled or not. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if REST is enabled, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_doing_rest( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the boolean value indicating if REST is enabled or not. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param doing_rest AXIS2_TRUE if REST is enabled, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_doing_rest( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t doing_rest); + + /** + * Sets the boolean value indicating if REST should be done through + * HTTP POST or not. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param do_rest_through_post AXIS2_TRUE if REST is to be done with + * HTTP POST, else AXIS2_FALSE if REST is not to be done with HTTP POST + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_do_rest_through_post( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t do_rest_through_post); + + /** + * Sets the boolean value indicating if REST should be done through + * HTTP POST or not. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if REST is to be done with HTTP POST, else + * AXIS2_FALSE if REST is not to be done with HTTP POST + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_do_rest_through_post( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets manage session bool value. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if session is managed, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_manage_session( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets manage session bool value. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param manage_session manage session bool value + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_manage_session( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t manage_session); + + /** + * Gets the bool value indicating the SOAP version being used either + * SOAP 1.1 or SOAP 1.2 + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if SOAP 1.1 is being used, else AXIS2_FALSE if + * SOAP 1.2 is being used + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_is_soap_11( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating the SOAP version being used either + * SOAP 1.1 or SOAP 1.2 + * @param msg_ctx message context + * @param env pointer to environment struct + * @param is_soap11 AXIS2_TRUE if SOAP 1.1 is being used, else + * AXIS2_FALSE if SOAP 1.2 is being used + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_is_soap_11( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t is_soap11); + + /** + * Gets service group context. The returned service group context + * relates to the service group to which the service, related to the + * message context, belongs. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to service group struct + */ + AXIS2_EXTERN struct axis2_svc_grp_ctx *AXIS2_CALL + axis2_msg_ctx_get_svc_grp_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets service group context. The returned service group context + * relates to the service group to which the service, related to the + * message context, belongs. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc_grp_ctx pointer to service group context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_svc_grp_ctx( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc_grp_ctx *svc_grp_ctx); + + /** + * Gets the operation that is to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to operation, returns a reference not a cloned copy + */ + AXIS2_EXTERN struct axis2_op *AXIS2_CALL + axis2_msg_ctx_get_op( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the operation that is to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param op pointer to operation, message context does not assume the + * ownership of operation + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_op *op); + + /** + * Gets the service to which the operation to be invoked belongs. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to service struct, returns a reference not a cloned copy + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_msg_ctx_get_svc( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the service to which the operation to be invoked belongs. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc pointer to service struct, message context does not assume + * the ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc *svc); + + /** + * Gets the service group to which the service to be invoked belongs. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to service group struct, returns a reference not + * a cloned copy + */ + AXIS2_EXTERN struct axis2_svc_grp *AXIS2_CALL + axis2_msg_ctx_get_svc_grp( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the service group to which the service to be invoked belongs. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc_grp pointer to service group struct, message context does + * not assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_svc_grp( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc_grp *svc_grp); + + /** + * Gets the service group context ID. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return service group context ID string + */ + AXIS2_EXTERN const axutil_string_t *AXIS2_CALL + axis2_msg_ctx_get_svc_grp_ctx_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the service group context ID. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc_grp_ctx_id service group context ID string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_svc_grp_ctx_id( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_string_t * svc_grp_ctx_id); + + /** + * Sets function to be used to find a service. This function is used by dispatchers + * to locate the service to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param func function to be used to find an operation + * @return pointer to service to be invoked + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + AXIS2_MSG_CTX_FIND_SVC func); + + /** + * Sets function to be used to find an operation in the given service. + * This function is used by dispatchers to locate the operation to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param func function to be used to find an operation + * @return pointer to the operation to be invoked + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + AXIS2_MSG_CTX_FIND_OP func); + + /** + * Finds the service to be invoked. This function is used by dispatchers + * to locate the service to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer to service to be invoked + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_msg_ctx_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Finds the operation to be invoked in the given service. This function + * is used by dispatchers to locate the operation to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param svc pointer to service to whom the operation belongs + * @return pointer to the operation to be invoked + */ + AXIS2_EXTERN struct axis2_op *AXIS2_CALL + axis2_msg_ctx_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc *svc); + + /** + * Gets the options to be used in invocation. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return options pointer to options struct, message context does not + * assume the ownership of the struct + */ + AXIS2_EXTERN struct axis2_options *AXIS2_CALL + axis2_msg_ctx_get_options( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the bool value indicating the paused status. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if invocation is paused, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_is_paused( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the options to be used in invocation. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param options pointer to options struct, message context does not + * assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_options( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_options *options); + + /** + * Sets the flow to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param flow int value indicating the flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_flow( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + int flow); + + /** + * Gets the flow to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return int value indicating the flow + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_msg_ctx_get_flow( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the list of supported REST HTTP Methods + * @param msg_ctx message context + * @param env pointer to environment struct + * @param supported_rest_http_methods pointer array list containing + * the list of HTTP Methods supported. Message context does + * assumes the ownership of the array list. Anything added to this + * array list will be freed by the msg_ctx + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_supported_rest_http_methods( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * supported_rest_http_methods); + + /** + * Gets the list of supported REST HTTP Methods + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer array list containing + * the list of HTTP Methods supported. Message context does + * assumes the ownership of the array list + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_get_supported_rest_http_methods( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the execution chain to be invoked. The execution chain is a + * list of phases containing the handlers to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param execution_chain pointer array list containing the list of + * handlers that constitute the execution chain. Message context does + * not assume the ownership of the array list + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_execution_chain( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * execution_chain); + + /** + * Gets the execution chain to be invoked. The execution chain is a + * list of phases containing the handlers to be invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return pointer array list containing the list of handlers that + * constitute the execution chain. Message context does not assume + * the ownership of the array list + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_get_execution_chain( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets current handler index, indicating which handler is currently + * being invoked in the execution chain + * @param msg_ctx message context + * @param env pointer to environment struct + * @param index index of currently executed handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_current_handler_index( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const int index); + + /** + * Gets current handler index, indicating which handler is currently + * being invoked in the execution chain + * @param msg_ctx message context + * @param env pointer to environment struct + * @return index of currently executed handler + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_msg_ctx_get_current_handler_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets paused handler index, indicating at which handler the execution + * chain was paused. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return index of handler at which invocation was paused + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_msg_ctx_get_paused_handler_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets index of the current phase being invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param index index of current phase + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_current_phase_index( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const int index); + + /** + * Gets index of the current phase being invoked. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return index of current phase + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_msg_ctx_get_current_phase_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the phase at which the invocation was paused. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return index of paused phase + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_msg_ctx_get_paused_phase_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets character set encoding to be used. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axutil_string_t *AXIS2_CALL + axis2_msg_ctx_get_charset_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets character set encoding to be used. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param str pointer to string struct representing encoding + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_charset_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_string_t * str); + + /** + * Gets the integer value indicating http status_code. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return status value + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_msg_ctx_get_status_code( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the int value indicating http status code + * @param msg_ctx message context + * @param env pointer to environment struct + * @param status_code of the http response + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_status_code( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const int status_code); + + /** + * Gets the Transport Out Stream + * @param msg_ctx message context + * @param env pointer to environment struct + * @return reference to Transport Out Stream + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + axis2_msg_ctx_get_transport_out_stream( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the Transport Out Stream + * @param msg_ctx message context + * @param env pointer to environment struct + * @param stream reference to Transport Out Stream + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_transport_out_stream( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_stream_t * stream); + + /** + * Resets Transport Out Stream + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_reset_transport_out_stream( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the HTTP Out Transport Info associated + * @param msg_ctx message context + * @param env pointer to environment struct + * @return reference to HTTP Out Transport Info associated + */ + AXIS2_EXTERN struct axis2_out_transport_info *AXIS2_CALL + axis2_msg_ctx_get_out_transport_info( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the HTTP Out Transport Info associated + * @param msg_ctx message context + * @param env pointer to environment struct + * @param out_transport_info reference to HTTP Out + * Transport Info associated + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_out_transport_info( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_out_transport_info *out_transport_info); + + /** + * Resets the HTTP Out Transport Info associated + * @param msg_ctx message context + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_reset_out_transport_info( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Retrieves Transport Headers. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Transport Headers associated. + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_msg_ctx_get_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Retrieves Transport Headers, and removes them + * from the message context + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Transport Headers associated. + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_msg_ctx_extract_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the Transport Headers + * @param msg_ctx message context + * @param env pointer to environment struct + * @param transport_headers a Hash containing the + * Transport Headers + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_hash_t * transport_headers); + + /** + * Retrieves HTTP Accept-Charset records. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return HTTP Accept-Charset records associated. + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_get_http_accept_charset_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Retrieves HTTP Accept-Charset records, and removes them + * from the message context + * @param msg_ctx message context + * @param env pointer to environment struct + * @return HTTP Accept-Charset records associated. + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_extract_http_accept_charset_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the HTTP Accept-Charset records + * @param msg_ctx message context + * @param env pointer to environment struct + * @param accept_charset_record_list an Array List containing the + * HTTP Accept-Charset records + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_http_accept_charset_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * accept_charset_record_list); + + /** + * Retrieves HTTP Accept-Language records. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return HTTP Accept-Language records associated. + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_get_http_accept_language_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Retrieves HTTP Accept-Language records, and removes them + * from the message context + * @param msg_ctx message context + * @param env pointer to environment struct + * @return HTTP Accept-Language records associated. + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_extract_http_accept_language_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the HTTP Accept-Language records + * @param msg_ctx message context + * @param env pointer to environment struct + * @param accept_language_record_list an Array List containing the + * HTTP Accept-Language records + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_http_accept_language_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * accept_language_record_list); + + /** + * Gets the Content Language used + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Content Language string + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_content_language( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the Content Language used + * @param msg_ctx message context + * @param env pointer to environment struct + * @param str Content Language string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_content_language( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * str); + + /** + * Retrieves HTTP Accept records. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return HTTP Accept records associated. + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_get_http_accept_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Retrieves HTTP Accept records, and removes them + * from the message context + * @param msg_ctx message context + * @param env pointer to environment struct + * @return HTTP Accept records associated. + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_extract_http_accept_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the HTTP Accept records + * @param msg_ctx message context + * @param env pointer to environment struct + * @param accept_record_list an Array List containing the + * HTTP Accept records + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_http_accept_record_list( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * accept_record_list); + + /** + * Gets the transfer encoding used + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Transfer encoding string + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_transfer_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the transfer encoding used + * @param msg_ctx message context + * @param env pointer to environment struct + * @param str Transfer encoding string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_transfer_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * str); + + /** + * Gets the Transport URL + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Transport URL string + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_transport_url( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the Transport URL + * @param msg_ctx message context + * @param env pointer to environment struct + * @param str Transport URL string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_transport_url( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_char_t * str); + + /** + * Gets whether there was no content in the response. + * This will cater for a situation where the invoke + * method in a service returns NULL when no fault has + * occured. + * @param msg_ctx message context + * @param env pointer to environment struct + * @return returns AXIS2_TRUE if there was no content + * occured or AXIS2_FALSE otherwise + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_no_content( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets that there was no content in the response. + * @param msg_ctx message context + * @param env pointer to environment struct + * @param no_content expects AXIS2_TRUE if there was no + * content in the response or AXIS2_FALSE otherwise + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_no_content( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t no_content); + + /** + * Gets whether an authentication failure occured + * @param msg_ctx message context + * @param env pointer to environment struct + * @return returns AXIS2_TRUE if an authentication failure + * occured or AXIS2_FALSE if not + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_auth_failed( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets whether an authentication failure occured + * @param msg_ctx message context + * @param env pointer to environment struct + * @param status expects AXIS2_TRUE if an authentication failure + * occured or AXIS2_FALSE if not + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_auth_failed( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t status); + + /** + * Gets whether HTTP Authentication is required or + * whether Proxy Authentication is required + * @param msg_ctx message context + * @param env pointer to environment struct + * @return returns AXIS2_TRUE for HTTP Authentication + * and AXIS2_FALSE for Proxy Authentication + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_ctx_get_required_auth_is_http( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets whether HTTP Authentication is required or + * whether Proxy Authentication is required + * @param msg_ctx message context + * @param env pointer to environment struct + * @param is_http use AXIS2_TRUE for HTTP Authentication + * and AXIS2_FALSE for Proxy Authentication + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_required_auth_is_http( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t is_http); + + /** + * Sets the authentication type + * @param msg_ctx message context + * @param env pointer to environment struct + * @param auth_type Authentication type string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_auth_type( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * auth_type); + + /** + * Gets the authentication type + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Authentication type string + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_msg_ctx_get_auth_type( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Gets the Output Header list + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Output Header list + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_get_http_output_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Retrieves the Output Headers, and removes them + * from the message context + * @param msg_ctx message context + * @param env pointer to environment struct + * @return Output Header list + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_extract_http_output_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + /** + * Sets the Output Header list + * @param msg_ctx message context + * @param env pointer to environment struct + * @param output_headers Output Header list + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_set_http_output_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t * output_headers); + + + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_ctx_get_mime_parts( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + + AXIS2_EXTERN void AXIS2_CALL + axis2_msg_ctx_set_mime_parts( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axutil_array_list_t *mime_parts); + + /** + * Incrementing the msg_ctx ref count. This is necessary when + * prevent freeing msg_ctx through op_client when it is in use + * as in sandesha2. + * @param msg_ctx pointer to message context + * @param env pointer to environment struct + * @return AXIS2_TRUE if still in use, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_ctx_increment_ref( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + + + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_MSG_CTX_H */ diff --git a/include/axis2_msg_info_headers.h b/include/axis2_msg_info_headers.h new file mode 100644 index 0000000..bd70bbe --- /dev/null +++ b/include/axis2_msg_info_headers.h @@ -0,0 +1,466 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_MSG_INFO_HEADERS_H +#define AXIS2_MSG_INFO_HEADERS_H + +/** + * @defgroup axis2_msg_info_headers message information headers + * @ingroup axis2_addr + * message information headers encapsulates properties that enable the + * identification and location of the endpoints involved in an interaction. + * The basic interaction pattern from which all others are composed is + * "one way". In this pattern a source sends a message to a destination + * without any further definition of the interaction. "Request Reply" is a + * common interaction pattern that consists of an initial message sent by + * a source endpoint (the request) and a subsequent message sent from the + * destination of the request back to the source (the reply). + * A reply can be either an application message, a fault, or any other message. + * message information headers capture addressing information related to these + * interaction patterns such as from, to, reply to and fault to addresses. + * @{ + */ + +/** + * @file axis2_msg_info_headers.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_msg_info_headers */ + typedef struct axis2_msg_info_headers axis2_msg_info_headers_t; + + /** + * Creates message information headers struct. + * @param env pointer to environment struct + * @param to pointer to endpoint reference representing to endpoint + * @param action WS-Addressing action string + * @return pointer to newly created message information headers struct + */ + AXIS2_EXTERN axis2_msg_info_headers_t *AXIS2_CALL + axis2_msg_info_headers_create( + const axutil_env_t * env, + axis2_endpoint_ref_t * to, + const axis2_char_t * action); + + /** + * Gets to endpoint. to endpoint represents the address of the + * intended receiver of this message. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return pointer to endpoint reference representing to address, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_info_headers_get_to( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets to endpoint. to endpoint represents the address of the + * intended receiver of this message. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param to pointer to endpoint reference representing to address, + * message information headers assumes ownership of the endpoint + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_to( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + axis2_endpoint_ref_t * to); + + /** + * Gets from endpoint. from endpoint represents the address of the + * endpoint where the message originated from. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return pointer to endpoint reference representing from address, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_info_headers_get_from( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets from endpoint. from endpoint represents the address of the + * endpoint where the message originated from. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param from pointer to endpoint reference representing from address, + * message information headers assumes ownership of the endpoint + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_from( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + axis2_endpoint_ref_t * from); + + /** + * Gets reply to endpoint. reply to endpoint identifies the intended + * receiver to which a message is replied. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return pointer to endpoint reference representing reply to address, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_info_headers_get_reply_to( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets reply to endpoint. reply to endpoint identifies the intended + * receiver to which a message is replied. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param reply_to pointer to endpoint reference representing reply to + * address, message information headers assumes ownership of the endpoint + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_reply_to( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + axis2_endpoint_ref_t * reply_to); + + /** + * Sets the bool value indicating whether the reply to endpoint should + * be none. reply to endpoint identifies the intended receiver for + * replies to a message. The URI "http://www.w3.org/2005/08/addressing/none" + * in the reply to address indicates that no reply should be sent. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param none AXIS2_TRUE if http://www.w3.org/2005/08/addressing/none + * is to be used as reply to URI, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_reply_to_none( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + const axis2_bool_t none); + + /** + * Gets the bool value indicating whether the reply to endpoint should + * be none. reply to endpoint identifies the intended receiver for + * replies related to a message. The URI + * "http://www.w3.org/2005/08/addressing/none" + * in the reply to address indicates that no reply should be sent. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if http://www.w3.org/2005/08/addressing/none + * is to be used as reply to URI, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_info_headers_get_reply_to_none( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets the bool value indicating whether the reply to endpoint should + * be anonymous. reply to endpoint identifies the intended receiver for + * replies related to a message. The URI + * "http://www.w3.org/2005/08/addressing/anonymous" + * in the reply to address indicates that reply should be sent to + * from address. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param anonymous AXIS2_TRUE if + * http://www.w3.org/2005/08/addressing/anonymous + * is to be used as reply to URI, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_reply_to_anonymous( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + const axis2_bool_t anonymous); + + /** + * Gets the bool value indicating whether the reply to endpoint should + * be anonymous. reply to endpoint identifies the intended receiver for + * replies related to a message. The URI + * "http://www.w3.org/2005/08/addressing/anonymous" + * in the reply to address indicates that reply should be sent to + * from address. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if http://www.w3.org/2005/08/addressing/anonymous + * is to be used as reply to URI, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_info_headers_get_reply_to_anonymous( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Gets fault to endpoint. fault to endpoint identifies the intended + * receiver for faults related to a message. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return pointer to endpoint reference representing fault to address, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_msg_info_headers_get_fault_to( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets fault to endpoint. fault to endpoint identifies the intended + * receiver for faults related to a message. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param fault_to pointer to endpoint reference representing fault to + * address, message information headers assumes ownership of the endpoint + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_fault_to( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + axis2_endpoint_ref_t * fault_to); + + /** + * Sets the bool value indicating whether the fault to endpoint should + * be none. fault to endpoint identifies the intended receiver for + * faults related to a message. The URI + * "http://www.w3.org/2005/08/addressing/none" + * in the fault to address indicates that no fault should be sent back. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param none AXIS2_TRUE if http://www.w3.org/2005/08/addressing/none + * is to be used as fault to URI, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_fault_to_none( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + const axis2_bool_t none); + + /** + * Gets the bool value indicating whether the fault to endpoint should + * be none. fault to endpoint identifies the intended receiver for + * faults related to a message. The URI + * "http://www.w3.org/2005/08/addressing/none" + * in the fault to address indicates that no fault should be sent back. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if http://www.w3.org/2005/08/addressing/none + * is to be used as fault to URI, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_info_headers_get_fault_to_none( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets the bool value indicating whether the fault to endpoint should + * be anonymous. fault to endpoint identifies the intended receiver for + * faults related to a message. The URI + * "http://www.w3.org/2005/08/addressing/anonymous" + * in the fault to address indicates that fault should be sent to + * from address. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param anonymous AXIS2_TRUE if + * http://www.w3.org/2005/08/addressing/anonymous + * is to be used as fault to URI, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_fault_to_anonymous( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + const axis2_bool_t anonymous); + + /** + * Gets the bool value indicating whether the fault to endpoint should + * be anonymous. fault to endpoint identifies the intended receiver for + * faults related to a message. The URI + * "http://www.w3.org/2005/08/addressing/anonymous" + * in the fault to address indicates that fault should be sent to + * from address. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if http://www.w3.org/2005/08/addressing/anonymous + * is to be used as fault to URI, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_msg_info_headers_get_fault_to_anonymous( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Gets WS-Addressing action. action is an absolute IRI + * (Internationalized Resource Identifier) that uniquely identifies + * the semantics implied by this message. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return WS-Addressing action string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_info_headers_get_action( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets WS-Addressing action. action is an absolute IRI + * (Internationalized Resource Identifier) that uniquely identifies + * the semantics implied by this message. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param action WS-Addressing action string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_action( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + const axis2_char_t * action); + + /** + * Gets message ID. message ID is an absolute IRI that uniquely + * identifies the message. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return message ID string. + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_msg_info_headers_get_message_id( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets message ID. message ID is an absolute URI that uniquely + * identifies the message. Message ID will be prefixed with "urn:uuid:" + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param message_id message ID string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_message_id( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + const axis2_char_t * message_id); + + /** + * Sets message ID. message ID is an absolute URI that uniquely + * identifies the message. Message ID Given will be used. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param message_id message ID string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_in_message_id( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + const axis2_char_t * message_id); + + /** + * Gets relates to information. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return pointer to relates to struct, returns a reference, not a + * cloned copy + * @sa axis2_relates_to + */ + AXIS2_EXTERN axis2_relates_to_t *AXIS2_CALL + axis2_msg_info_headers_get_relates_to( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Sets relates to information. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param relates_to pointer to relates to struct, message information + * headers assumes ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_set_relates_to( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + axis2_relates_to_t * relates_to); + + /** + * Gets all reference parameters associated with message information + * headers. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return pointer to array list containing all reference parameters + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_msg_info_headers_get_all_ref_params( + const axis2_msg_info_headers_t * msg_info_headers, + const axutil_env_t * env); + + /** + * Adds a reference parameter in the form of an AXIOM node. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @param ref_param pointer to AXIOM node representing reference + * parameter, message information header does not assume ownership of + * node + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_info_headers_add_ref_param( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env, + axiom_node_t * ref_param); + + /** + * Frees message information header struct. + * @param msg_info_headers pointer to message information headers struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_msg_info_headers_free( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_MSG_INFO_HEADERS_H */ diff --git a/include/axis2_msg_recv.h b/include/axis2_msg_recv.h new file mode 100644 index 0000000..ecd9bce --- /dev/null +++ b/include/axis2_msg_recv.h @@ -0,0 +1,268 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_MSG_RECV_H +#define AXIS2_MSG_RECV_H + +/** + * @defgroup axis2_receivers receivers + * @ingroup axis2 + * @{ + * @} + */ + +/** @defgroup axis2_msg_recv message receiver + * @ingroup axis2_receivers + * Description. + * @{ + */ + +/** + * @file axis2_msg_recv.h + * @brief Axis Message Receiver interface. Message Receiver struct. + * This interface is extended by custom message receivers + */ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include +#include +#include +#include +#include +#include +#include + + struct axis2_msg_ctx; + + /** Type name for struct axis2_msg_recv*/ + typedef struct axis2_msg_recv axis2_msg_recv_t; + + typedef axis2_status_t( + AXIS2_CALL + * AXIS2_MSG_RECV_INVOKE_BUSINESS_LOGIC) ( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + struct axis2_msg_ctx * in_msg_ctx, + struct axis2_msg_ctx * out_msg_ctx); + + typedef axis2_status_t( + AXIS2_CALL + * AXIS2_MSG_RECV_RECEIVE) ( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + struct axis2_msg_ctx * in_msg_ctx, + void *callback_recv_param); + + typedef axis2_status_t( + AXIS2_CALL * AXIS2_MSG_RECV_LOAD_AND_INIT_SVC)( + axis2_msg_recv_t *msg_recv, + const axutil_env_t *env, + struct axis2_svc *svc); + + /** + * Deallocate memory + * @param msg_recv pinter to message receiver + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_msg_recv_free( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env); + + /** + * This method is called from axis2_engine_receive method. This method's + * actual implementation is decided from the create method of the + * extended message receiver object. There depending on the synchronous or + * asynchronous type, receive method is assigned with the synchronous or + * asynchronous implementation of receive. + * @see raw_xml_in_out_msg_recv_create method where receive is assigned + * to receive_sync + * @param msg_recv pointer to message receiver + * @param env pointer to environment struct + * @param in_msg_ctx pointer to in message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_recv_receive( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + struct axis2_msg_ctx *in_msg_ctx, + void *callback_recv_param); + + /** + * This contain in out synchronous business invoke logic + * @param msg_recv pointer to message receiver + * @param env pointer to environment struct + * @param in_msg_ctx pointer to in message context + * @param out_msg_ctx pointer to out message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_msg_recv_invoke_business_logic( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + struct axis2_msg_ctx *in_msg_ctx, + struct axis2_msg_ctx *out_msg_ctx); + + /** + * this will create a new service skeleton object + * @param msg_recv pointer to message receiver + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return service skeleton object + */ + AXIS2_EXTERN axis2_svc_skeleton_t *AXIS2_CALL + + axis2_msg_recv_make_new_svc_obj( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + + /** + * This will return the service skeleton object + * @param msg_recv pointer to message receiver + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return service skeleton object + */ + /*AXIS2_EXTERN axis2_svc_skeleton_t *AXIS2_CALL + + axis2_msg_recv_get_impl_obj( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx);*/ + + /** + * Set the application scope + * @param msg_recv pointer to message receiver + * @param env pointer to environment struct + * @param scope pointer to scope + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_recv_set_scope( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + const axis2_char_t * scope); + + /** + * Get the application scope + * @param msg_recv pointer to message receiver + * @env pointer to environment struct + * @return scope + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_msg_recv_get_scope( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env); + + /** + * Delete the service skeleton object created by make_new_svc_obj + * @param msg_recv pointer to message receiver + * @env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_msg_recv_delete_svc_obj( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + AXIS2_EXPORT axis2_status_t AXIS2_CALL + + axis2_msg_recv_set_invoke_business_logic( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + AXIS2_MSG_RECV_INVOKE_BUSINESS_LOGIC func); + + AXIS2_EXPORT axis2_status_t AXIS2_CALL + axis2_msg_recv_set_derived( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + void *derived); + + AXIS2_EXPORT void *AXIS2_CALL + axis2_msg_recv_get_derived( + const axis2_msg_recv_t * msg_recv, + const axutil_env_t * env); + + AXIS2_EXPORT axis2_status_t AXIS2_CALL + axis2_msg_recv_set_receive( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + AXIS2_MSG_RECV_RECEIVE func); + + AXIS2_EXPORT axis2_status_t AXIS2_CALL + axis2_msg_recv_set_load_and_init_svc( + axis2_msg_recv_t *msg_recv, + const axutil_env_t *env, + AXIS2_MSG_RECV_LOAD_AND_INIT_SVC func); + + AXIS2_EXPORT axis2_status_t AXIS2_CALL + axis2_msg_recv_load_and_init_svc( + axis2_msg_recv_t *msg_recv, + const axutil_env_t *env, + struct axis2_svc *svc); + + /** + * Create new message receiver object. usually this will be called from the + * extended message receiver object. + * @see create method of raw_xml_in_out_msg_recv + * @param env pointer to environment struct + * @return newly created message receiver object + **/ + AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL + axis2_msg_recv_create( + const axutil_env_t * env); + + /** + * Configuration context is attached to the message receiver so that conf_ctx can be assccessed in load_and_init + * method at service load time. + * @param msg_recv axis2_msg_recv instance + * @param env axutil environment + * @param axis2_conf_ctx Configuration context instance + */ + AXIS2_EXPORT void AXIS2_CALL + axis2_msg_recv_set_conf_ctx( + axis2_msg_recv_t *msg_recv, + const axutil_env_t *env, + struct axis2_conf_ctx *conf_ctx); + + /** + * Returns the Configuration context which is attached to the message receiver + * @param msg_recv axis2_msg_recv instance + * @param env axutil environment + * @returns configuration context + */ + AXIS2_EXPORT struct axis2_conf_ctx* AXIS2_CALL + axis2_msg_recv_get_conf_ctx( + axis2_msg_recv_t *msg_recv, + const axutil_env_t *env); + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_MSG_RECV_H */ diff --git a/include/axis2_op.h b/include/axis2_op.h new file mode 100644 index 0000000..27d3520 --- /dev/null +++ b/include/axis2_op.h @@ -0,0 +1,724 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_OP_H +#define AXIS2_OP_H + +/** + * @defgroup axis2_op operation + * @ingroup axis2_desc + * operation represents the static structure of an operation in a service. + * In Axis2 description hierarchy, an operation lives inside the service to + * which it belongs. + * operations are configured in services.xml files located in the respective + * service group folders of the services folder in the repository. + * In services.xml file, operations are declared in association with a given + * service. The deployment engine would create operation instances to represent + * those configured operations and would associate them with the respective + * service in the configuration. + * operation encapsulates data on message exchange pattern (MEP), the + * execution flows, engaged module information, and the message receiver + * associated with the operation. + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_op */ + typedef struct axis2_op axis2_op_t; + + struct axis2_svc; + struct axis2_msg_recv; + struct axutil_param_container; + struct axis2_module_desc; + struct axis2_op; + struct axis2_relates_to; + struct axis2_op_ctx; + struct axis2_svc_ctx; + struct axis2_msg_ctx; + struct axis2_msg; + struct axis2_conf; + + /** SOAP action string constant */ +#define AXIS2_SOAP_ACTION "soapAction" + + /** + * Creates operation struct. + * @param env pointer to environment struct + * @return pointer to newly created operation + */ + AXIS2_EXTERN axis2_op_t *AXIS2_CALL + axis2_op_create( + const axutil_env_t * env); + + /** + * Frees operation. + * @param op pointer to operation + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_free( + axis2_op_t * op, + const axutil_env_t * env); + + /** + * Frees operation given as a void pointer. + * @param op pointer to operation as a void pointer + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_free_void_arg( + void *op, + const axutil_env_t * env); + + /** + * Adds a parameter to method. + * @param op pointer to operation + * @param env pointer to environment struct + * @param param pointer parameter to be added, operation assumes + * ownership of parameter + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_add_param( + axis2_op_t * op, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets named parameter. + * @param op pointer to operation + * @param env pointer to environment struct + * @param name name of parameter to be retrieved as a string + * @return pointer to named parameter if exists, else NULL. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_op_get_param( + const axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * name); + /** + * Removes a parameter assiciated with the operation + * @param op pointer to operation + * @param env pointer to environment struct + * @param param_name parameter name to be removed + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_remove_param + (axis2_op_t *op, + const axutil_env_t *env, + const axis2_char_t *param_name); + + /** + * Gets all parameters. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to array list containing all parameters, returns + * a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_op_get_all_params( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Checks if the named parameter is locked. + * @param op pointer to operation + * @param env pointer to environment struct + * @param param_name name of the parameter to be checked + * @return AXIS2_TRUE if named parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_is_param_locked( + axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Sets parent. Parent of an operation is of type service. + * @param op pointer to operation + * @param env pointer to environment struct + * @param svc pointer to parent service, operation does not assume + * ownership of service + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_parent( + axis2_op_t * op, + const axutil_env_t * env, + struct axis2_svc *svc); + + /** + * Gets parent. Parent of an operation is of type service. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to parent service, returns a reference, not a cloned + * copy + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_op_get_parent( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Sets HTTP Method for RESTful Services. + * @param op pointer to operation + * @param env pointer to environment struct + * @param rest_http_method HTTP Method string, operation does not assume + * ownership of rest_http_method. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_rest_http_method( + axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * rest_http_method); + + /** + * Gets HTTP Method for RESTful Services. + * @param op pointer to operation + * @param env pointer to environment struct + * @return HTTP Method string, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_op_get_rest_http_method( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Sets HTTP Location for RESTful Services. + * @param op pointer to operation + * @param env pointer to environment struct + * @param rest_http_location HTTP Location string, operation does not assume + * ownership of rest_http_location. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_rest_http_location( + axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * rest_http_location); + + /** + * Gets HTTP Location for RESTful Services. + * @param op pointer to operation + * @param env pointer to environment struct + * @return HTTP Location string, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_op_get_rest_http_location( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Sets operation QName. + * @param op pointer to operation as a void pointer. + * @param env pointer to environment struct + * @param qname pointer to QName, this method creates a clone of the + * QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_qname( + axis2_op_t * op, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Gets operation QName. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to QName, returns a reference, not a cloned copy + */ + AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL + axis2_op_get_qname( + void *op, + const axutil_env_t * env); + + /** + * Sets operation message exchange pattern (MEP). + * @param op pointer to operation + * @param env pointer to environment struct + * @param pattern message exchange pattern string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_msg_exchange_pattern( + axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * pattern); + + /** + * Gets operation message exchange pattern (MEP). + * @param op pointer to operation + * @param env pointer to environment struct + * @return MEP string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_op_get_msg_exchange_pattern( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Sets message receiver. message receiver is responsible for invoking + * the business logic associated with the operation. + * @param op pointer to operation + * @param env pointer to environment struct + * @param msg_recv pointer to message receiver, operation assumes + * ownership of message receiver + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_msg_recv( + axis2_op_t * op, + const axutil_env_t * env, + struct axis2_msg_recv *msg_recv); + + /** + * Gets message receiver. message receiver is responsible for invoking + * the business logic associated with the operation. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to message receiver, returns a reference, not a + * cloned copy + */ + AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL + axis2_op_get_msg_recv( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Gets style of operation. Style is that mentioned in WSDL, either + * RPC or document literal. + * @param op pointer to operation + * @param env pointer to environment struct + * @return string representing style + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_op_get_style( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Sets style of operation. Style is that mentioned in WSDL, either + * RPC or document literal. + * @param op pointer to operation + * @param env pointer to environment struct + * @param style string representing style + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_style( + axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * style); + + /** + * Engages given module to operation. + * @param op pointer to operation + * @param env pointer to environment struct + * @param module_desc pointer to module description, operation does not + * assume ownership of struct + * @param conf pointer to configuration, operation does not assume + * ownership of configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_engage_module( + axis2_op_t * op, + const axutil_env_t * env, + struct axis2_module_desc *module_desc, + struct axis2_conf *conf); + + /** + * Adds module description to engaged module list. + * @param op pointer to operation + * @param env pointer to environment struct + * @param module_dec pointer to module description, operation does not + * assume ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_op_add_to_engaged_module_list( + axis2_op_t * op, + const axutil_env_t * env, + struct axis2_module_desc *module_dec); + + /** + * Gets all modules associated to operation. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to array list containing module descriptions + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_op_get_all_modules( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Gets Axis specific MEP constant. This method simply maps the string + * URI of the MEP to an integer. + * @param op pointer to operation + * @param env pointer to environment struct + * @return integer representing MEP + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_op_get_axis_specific_mep_const( + axis2_op_t * op, + const axutil_env_t * env); + + /** + * Gets fault in flow. Fault in flow is the list of phases invoked + * when a fault happens along in path. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to array list containing phases, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_op_get_fault_in_flow( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Gets fault out flow. Fault out flow is the list of phases invoked + * when a fault happens along out path. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to array list containing phases, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_op_get_fault_out_flow( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Gets out flow. Out flow is the list of phases invoked + * along out path. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to array list containing phases, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_op_get_out_flow( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Gets in flow. In flow is the list of phases + * invoked along in path. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to array list containing phases, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_op_get_in_flow( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Sets fault in flow. Fault in flow is the list of phases invoked + * when a fault happens along in path. + * @param op pointer to operation + * @param env pointer to environment struct + * @param list pointer to array list containing phases, operation takes + * over the ownership of list + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_fault_in_flow( + axis2_op_t * op, + const axutil_env_t * env, + axutil_array_list_t * list); + + /** + * Sets fault out flow. Fault out flow is the list of phases invoked + * when a fault happens along out path. + * @param op pointer to operation + * @param env pointer to environment struct + * @param list pointer to array list containing phases, operation takes + * over the ownership of list + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_fault_out_flow( + axis2_op_t * op, + const axutil_env_t * env, + axutil_array_list_t * list); + + /** + * Sets out flow. Out flow is the list of phases invoked + * along out path. + * @param op pointer to operation + * @param env pointer to environment struct + * @param list pointer to array list containing phases, operation takes + * over the ownership of list + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_out_flow( + axis2_op_t * op, + const axutil_env_t * env, + axutil_array_list_t * list); + + /** + * Sets in flow. In flow is the list of phases + * invoked along in path. + * @param op pointer to operation + * @param env pointer to environment struct + * @param list pointer to array list containing phases, operation takes + * over the ownership of list + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_in_flow( + axis2_op_t * op, + const axutil_env_t * env, + axutil_array_list_t * list); + + /** + * Adds given QName to module QName list. + * @param op pointer to operation + * @param env pointer to environment struct + * @param module_name pointer to module QName, QName would be cloned by + * this method + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_add_module_qname( + axis2_op_t * op, + const axutil_env_t * env, + const axutil_qname_t * module_qname); + + /** + * Gets all module QNames as a list. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to array list containing module QNames, + * returns a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_op_get_all_module_qnames( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Finds operation context related to this operation using given message + * context and service context. This method would create a new operation + * context related to the operation, if one could not be found. + * @param op pointer to operation + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @param svc_ctx pointer to service context + * @return pointer to operation context, returns + * a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_op_ctx *AXIS2_CALL + axis2_op_find_op_ctx( + axis2_op_t * op, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx, + struct axis2_svc_ctx *svc_ctx); + + /** + * Finds operation context related to this operation using given message + * context. This method will not create a new operation context if + * an associated operation context could not be found. + * @param op pointer to operation + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return pointer to operation context if found, else NULL. Returns + * a reference, not a cloned copy + + */ + AXIS2_EXTERN struct axis2_op_ctx *AXIS2_CALL + + axis2_op_find_existing_op_ctx( + axis2_op_t * op, + const axutil_env_t * env, + const struct axis2_msg_ctx *msg_ctx); + + /** + * Registers given operation context against this operation. Registration + * happens within the given message context, as it is the message context + * that captures the state information of a given invocation. + * @param op pointer to operation + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @param op_ctx pointer to operation context, operation does not assume + * ownership of operation context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_register_op_ctx( + axis2_op_t * op, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx, + struct axis2_op_ctx *op_ctx); + + /** + * Gets message with given label. + * @param op pointer to operation + * @param env pointer to environment struct + * @return pointer to message corresponding to given label, returns + * a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_msg *AXIS2_CALL + axis2_op_get_msg( + const axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * label); + + /** + * Adds given message with the given label. + * @param op pointer to operation + * @param env pointer to environment struct + * @param label label string + * @param msg pointer to message + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_add_msg( + axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * label, + const struct axis2_msg *msg); + + /** + * Checks if the operation is from a module. + * @param op pointer to operation + * @param env pointer to environment struct + * AXIS2_TRUE if the operation is from a module, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_is_from_module( + const axis2_op_t * op, + const axutil_env_t * env); + + /** + * Set the wsamapping list. + * @param op pointer to operation + * @param env pointer to environment struct + * @param mapping_list list of action mappings + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_set_wsamapping_list( + axis2_op_t * op, + const axutil_env_t * env, + axutil_array_list_t * mapping_list); + + /** + * Get the wsamapping list. + * @param op pointer to operation + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_op_get_wsamapping_list( + axis2_op_t * op, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + + axis2_op_get_param_container( + const axis2_op_t * op, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_op_remove_from_engaged_module_list( + axis2_op_t * op, + const axutil_env_t * env, + struct axis2_module_desc *module_desc); + + /** + * Creates operation struct for an operation defined in a module. + * @param env pointer to environment struct + * @return pointer to newly created operation + */ + AXIS2_EXTERN axis2_op_t *AXIS2_CALL + axis2_op_create_from_module( + const axutil_env_t * env); + + /** + * Creates operation struct with given QName. + * @param env pointer to environment struct + * @param name pointer to QName + * @return pointer to newly created operation + */ + AXIS2_EXTERN axis2_op_t *AXIS2_CALL + axis2_op_create_with_qname( + const axutil_env_t * env, + const axutil_qname_t * name); + + /** + * Frees the operation given as a void pointer. This method would cast the + * void parameter to an operation pointer and then call free method. + * @param pointer to operation as a void pointer + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_free_void_arg( + void *op, + const axutil_env_t * env); + + /** + * Gets base description. + * @param op pointer to message + * @param env pointer to environment struct + * @return pointer to base description struct + */ + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_op_get_base( + const axis2_op_t * op, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_OP_H */ diff --git a/include/axis2_op_client.h b/include/axis2_op_client.h new file mode 100644 index 0000000..8ba764d --- /dev/null +++ b/include/axis2_op_client.h @@ -0,0 +1,445 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_OP_CLIENT_H +#define AXIS2_OP_CLIENT_H + +/** + * @defgroup axis2_client_api client API + * @ingroup axis2 + * @{ + * @} + */ + +/** + * @defgroup axis2_op_client operation client + * @ingroup axis2_client_api + * The operation client is meant to be used by advanced users to consume services. + * Operation client understands a specific Message Exchange Pattern (op) and + * hence the behavior is defined by the op. + * To consume services with an operation client, an operation (of type axis2_op_t) + * and a service context (of type axis2_svc_ctx_t) + * has to be provided along with options to be used. The execute() function + * can be used to send the request and get the response. + * The service client implementation uses the operation client and provides an + * easy to use API for consuming services. Hence the service client + * implementation is a very good example of how to use the operation client API. + * @sa axis2_svc_client + * @{ + */ + +/** + * @file axis2_op_client.h + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_op_client */ + typedef struct axis2_op_client axis2_op_client_t; + + struct axis2_callback_recv; + + /** + * Sets the options that is to be used by this operation client. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @param options pointer to options struct to be set + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_set_options( + axis2_op_client_t * op_client, + const axutil_env_t * env, + const axis2_options_t * options); + + /** + * Gets options used by operation client. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @return a pointer to the options struct if options set, else NULL. + * Returns a reference, not a cloned copy. + */ + AXIS2_EXTERN const axis2_options_t *AXIS2_CALL + axis2_op_client_get_options( + const axis2_op_client_t * op_client, + const axutil_env_t * env); + + /** + * Adds a message context to the client for processing. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @param msg_ctx message context to be added. operation client takes + * over the ownership of the message context struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_add_msg_ctx( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Adds out message context to the client for processing. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @param msg_ctx message context to be added. operation client takes + * over the ownership of the message context struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_add_out_msg_ctx( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_add_in_msg_ctx( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Gets a message corresponding to the given label. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @param message_label the message label of the desired message context + * @return the desired message context or NULL if its not available. + * Returns a reference, not a cloned copy. + */ + AXIS2_EXTERN const axis2_msg_ctx_t *AXIS2_CALL + axis2_op_client_get_msg_ctx( + const axis2_op_client_t * op_client, + const axutil_env_t * env, + const axis2_wsdl_msg_labels_t message_label); + + /** + * Sets the callback to be executed when a response message is received. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @param callback the callback to be used. operation client takes + * over the ownership of the message context struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_set_callback( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_callback_t * callback); + + /** + * Gets the callback. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @return callback + */ + AXIS2_EXTERN axis2_callback_t *AXIS2_CALL + axis2_op_client_get_callback( + axis2_op_client_t * op_client, + const axutil_env_t * env); + + /** + * Execute the op. What this does depends on the specific operation client. + * The basic idea is to have the operation client execute and do something + * with the messages that have been added to it so far. For example, if its + * an Out-In op, and if the Out message has been set, then executing the + * client asks it to send the out message and get the in message + * @param op_client pointer to operation client + * @param env pointer to environment struct + * @param block indicates whether execution should block or return ASAP + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_execute( + axis2_op_client_t * op_client, + const axutil_env_t * env, + const axis2_bool_t block); + + /** + * Resets the operation client to a clean status after the op has completed. + * This is how you can reuse an operation client. Note that this does not reset + * the options; only the internal state so the client can be used again. + * @param op_client pointer to operation client + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_reset( + axis2_op_client_t * op_client, + const axutil_env_t * env); + + /** + * Completes the execution by closing the transports if necessary. + * This method is useful when client uses two transports for sending and + * receiving. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @param msg_ctx message context which contains the transport information + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_complete( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Gets the operation context of the operation client. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @return operation context related to operation client + */ + AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL + axis2_op_client_get_operation_context( + const axis2_op_client_t * op_client, + const axutil_env_t * env); + + /** + * Sets callback receiver. + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @param callback_recv pointer to callback receiver struct. + * operation client assumes ownership of the callback struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_set_callback_recv( + axis2_op_client_t * op_client, + const axutil_env_t * env, + struct axis2_callback_recv *callback_recv); + + /** + * Frees the operation client + * @param op_client pointer to operation client struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_client_free( + axis2_op_client_t * op_client, + const axutil_env_t * env); + + /** + * Creates an operation client struct for the specified operation, service + * context and given options. + * @param env pointer to environment struct + * @param op pointer to operation struct corresponding to the operation to + * to be executed. Newly created client assumes ownership of the operation. + * @param svc_ctx pointer to service context struct representing the service + * to be consumed. Newly created client assumes ownership of the service + * context. + * @param options options to be used by operation client. Newly created + * client assumes ownership of the options + * context. + * @return a pointer to newly created operation client struct, + * or NULL on error with error code set in environment's error + */ + AXIS2_EXTERN axis2_op_client_t *AXIS2_CALL + axis2_op_client_create( + const axutil_env_t * env, + axis2_op_t * op, + axis2_svc_ctx_t * svc_ctx, + axis2_options_t * options); + + /** + * Gets SOAP action. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @return a pointer to SOAP action string + */ + AXIS2_EXTERN axutil_string_t *AXIS2_CALL + axis2_op_client_get_soap_action( + const axis2_op_client_t * op_client, + const axutil_env_t * env); + + /** + * Prepares the message context for invocation. Here the properties kept + * in the op_client are copied to the message context. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param op pointer operation to be invoked + * @param msg_ctx pointer to message context to be filled + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_prepare_invocation( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_op_t * op, + axis2_msg_ctx_t * msg_ctx); + + /** + * Prepares the SOAP envelope using the payload. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param to_send payload to be sent in AXIOM node format + * @return a pointer to message context struct filled with the SOAP + * envelope to be sent + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_op_client_prepare_soap_envelope( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axiom_node_t * to_send); + + /** + * Tries to infer the transport looking at the URL, the URL can be http:// + * tcp:// mail:// local://. The method will look for the transport name as the + * protocol part of the transport. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param epr endpoint reference struct representing the endpoint URL + * @return pointer to the transport description with inferred information + */ + AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL + axis2_op_client_infer_transport( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_endpoint_ref_t * epr); + + /** + * Creates default SOAP envelope. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @return pointer to default SOAP envelope created + */ + AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL + axis2_op_client_create_default_soap_envelope( + axis2_op_client_t * op_client, + const axutil_env_t * env); + + /** + * Engage named module. The named module must have been configured in + * the Axis2 configuration. For a module to be detected by the + * deployment engine, the modules has to be placed in the + * AXIS2_REPOSITORY/modules directory. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param qname QName representing the module name + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_engage_module( + axis2_op_client_t * op_client, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Sets SOAP version URI. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param soap_version_uri SOAP version URI + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_set_soap_version_uri( + axis2_op_client_t * op_client, + const axutil_env_t * env, + const axis2_char_t * soap_version_uri); + + /** + * Sets SOAP action. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param soap_action SOAP action + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_set_soap_action( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axutil_string_t * soap_action); + + /** + * Sets WSA action. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param wsa_action Web services Addressing action + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_client_set_wsa_action( + axis2_op_client_t * op_client, + const axutil_env_t * env, + const axis2_char_t * wsa_action); + + /** + * Gets service context. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @return pointer to service context struct if set, else NULL + */ + AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL + axis2_op_client_get_svc_ctx( + const axis2_op_client_t * op_client, + const axutil_env_t * env); + + + /** + * Sets whether to reuse op client. + * @param op_client pointer to op client struct + * @param env pointer to environment struct + * @param reuse flag is a boolean value + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_client_set_reuse( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_bool_t reuse); + + /** + * Sends a message represented by the given message context and captures + * the response in return message context. + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing the message to + * be sent + * @return message context representing the received response + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_op_client_two_way_send( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Receives a message corresponding to a request depicted by given + * message context. + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing the response to + * be received + * @return message context representing the received response + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_op_client_receive( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_OP_CLIENT_H */ diff --git a/include/axis2_op_ctx.h b/include/axis2_op_ctx.h new file mode 100644 index 0000000..f29ec60 --- /dev/null +++ b/include/axis2_op_ctx.h @@ -0,0 +1,307 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_OP_CTX_H +#define AXIS2_OP_CTX_H + +/** + * @defgroup axis2_op_ctx operation context + * @ingroup axis2_context + * operation context represents a running "instance" of an operation. + * operation context allows messages to be grouped into operations as in + * WSDL 2.0 specification. operations are essentially arbitrary message exchange + * patterns (MEP). So as messages are being exchanged, operation context remembers + * the state of message exchange pattern specifics. + * The implementation of operation context supports MEPs which have one input + * message and/or one output message. In order to support other MEPs one must + * extend this struct. + * @{ + */ + +/** + * @file axis2_op_ctx.h + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_op_ctx */ + typedef struct axis2_op_ctx axis2_op_ctx_t; + + struct axis2_svc_ctx; + + /** + * Creates an operation context struct instance. + * @param env pointer to environment struct + * @param op pointer to operation that is related to operation context. + * operation context does not assume the ownership of the struct + * @param svc_ctx pointer to parent service context + * @return pointer to newly created operation context + */ + AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL + axis2_op_ctx_create( + const axutil_env_t * env, + struct axis2_op *op, + struct axis2_svc_ctx *svc_ctx); + + /** + * Gets base which is of context type. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to base context + */ + AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL + axis2_op_ctx_get_base( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Frees operation context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_ctx_free( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env); + + /** + * Initializes operation context. This method traverses through all the + * message contexts stored within it and initialize them all. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param conf pointer to conf configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_init( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Gets operation the operation context is related to. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to operation + */ + AXIS2_EXTERN struct axis2_op *AXIS2_CALL + axis2_op_ctx_get_op( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Gets parent which is of service context type. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to service context within which this operation + * context lives + */ + AXIS2_EXTERN struct axis2_svc_ctx *AXIS2_CALL + axis2_op_ctx_get_parent( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Adds a message context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * does not assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_add_msg_ctx( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Gets message context with the given message ID. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param message_id message label of type axis2_wsdl_msg_labels_t. + * This can be one of AXIS2_WSDL_MESSAGE_LABEL_IN or AXIS2_WSDL_MESSAGE_LABEL_OUT + * from the axis2_wsdl_msg_labels enum. + * @return pointer to message context with given ID + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + axis2_op_ctx_get_msg_ctx( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env, + const axis2_wsdl_msg_labels_t message_id); + + /** + * Gets the bool value indicating if the MEP is complete. + * MEP is considered complete when all the messages that + * are associated with the MEP has arrived. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if MEP invocation is complete, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_ctx_get_is_complete( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating if the MEP is complete. + * MEP is considered complete when all the messages that + * are associated with the MEP has arrived. + * @param op_ctx pointer to operating context + * @param env pointer to environment struct + * @param is_complete AXIS2_TRUE if MEP invocation is complete, else + * AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_complete( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + axis2_bool_t is_complete); + + /** + * Cleans up the operation context. Clean up includes removing all + * message context references recorded in operation context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_cleanup( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env); + + /** + * Sets parent service context. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param svc_ctx pointer to service context, message context does not + * assume the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_parent( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + struct axis2_svc_ctx *svc_ctx); + + /** + * Gets the message context map. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return pointer to hash table containing message contexts + */ + AXIS2_EXTERN axis2_msg_ctx_t **AXIS2_CALL + axis2_op_ctx_get_msg_ctx_map( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Sets the bool value indicating the status of response. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param response_written AXIS2_TRUE if response is written, else + * AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_response_written( + axis2_op_ctx_t * op_ctx, + const axutil_env_t * env, + const axis2_bool_t response_written); + + /** + * Checks the response status, whether it is written or not. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if response is already written, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_ctx_get_response_written( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Destroys mutex used to synchronize the read/write operations + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return returns void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_op_ctx_destroy_mutex( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env); + + /** + * Checks whether op_ctx is in use. This is necessary when destroying the + * thread mutex at the http_worker to check whether the operation context + * is still in use + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if still in use, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_op_ctx_is_in_use( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** + * Set operation context's is_in_use attribute. This is necessary when + * destroying the thread mutex at the http_worker to check whether the + * operation context is still in use + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @param is_in_use AXIS2_TRUE if still in use, else AXIS2_FALSE + * @return AXIS2_TRUE if still in use, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_set_in_use( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env, + axis2_bool_t is_in_use); + + /** + * Incrementing the op_ctx ref count. This is necessary when + * prevent freeing op_ctx through op_client when it is in use + * as in sandesha where the msg_cts is stored. + * @param op_ctx pointer to operation context + * @param env pointer to environment struct + * @return AXIS2_TRUE if still in use, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_op_ctx_increment_ref( + axis2_op_ctx_t * op_ctx, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_OP_CTX_H */ diff --git a/include/axis2_options.h b/include/axis2_options.h new file mode 100644 index 0000000..4ed2185 --- /dev/null +++ b/include/axis2_options.h @@ -0,0 +1,848 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_OPTIONS_H +#define AXIS2_OPTIONS_H + +/** @defgroup axis2_options options + * @ingroup axis2_client_api + * The options struct holds user options to be used by client when invocation + * services. In addition to the end point reference information, options + * struct also hold addressing, transport and timeout related information. + * User specific properties could also set on top of options. + * @{ + */ + +/** + * @file axis2_options.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** Default timeout */ +#define AXIS2_DEFAULT_TIMEOUT_MILLISECONDS 30000 + +/** Timeout in seconds waiting for a response envelope */ +#define AXIS2_TIMEOUT_IN_SECONDS "time_out" + +/** Copy properties */ +#define AXIS2_COPY_PROPERTIES "copy_properties" + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_options */ + typedef struct axis2_options axis2_options_t; + + /** + * Gets Web Services Addressing (WSA) action. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return WSA action string if set, else NULL + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_options_get_action( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets WSA fault to address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing fault to + * address if set, else NULL + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_options_get_fault_to( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets WSA from address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing from + * address if set, else NULL + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_options_get_from( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets transport receiver. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to transport receiver struct if set, else NULL + */ + AXIS2_EXTERN axis2_transport_receiver_t *AXIS2_CALL + axis2_options_get_transport_receiver( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets transport in. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to transport in struct if set, else NULL + */ + AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL + axis2_options_get_transport_in( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets transport in protocol. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to transport in protocol string if set, else NULL + */ + AXIS2_EXTERN AXIS2_TRANSPORT_ENUMS AXIS2_CALL + axis2_options_get_transport_in_protocol( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets message ID. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to message ID string if set, else NULL + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_options_get_message_id( + const axis2_options_t * options_t, + const axutil_env_t * env); + + /** + * Gets the properties hash map. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to properties hash map if set, else NULL + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_options_get_properties( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets a property corresponding to the given key. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param key key of the property to be returned + * @return value corresponding to the given key + */ + AXIS2_EXTERN void *AXIS2_CALL + axis2_options_get_property( + const axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * key); + + /** + * Gets relates to information. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to relates to struct if set, else NULL + */ + AXIS2_EXTERN axis2_relates_to_t *AXIS2_CALL + axis2_options_get_relates_to( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets WSA reply to address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing reply to + * address if set, else NULL + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_options_get_reply_to( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets transport out. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to transport out struct if set, else NULL + */ + AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL + axis2_options_get_transport_out( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets transport out protocol. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to transport out protocol string if set, else NULL + */ + AXIS2_EXTERN AXIS2_TRANSPORT_ENUMS AXIS2_CALL + axis2_options_get_sender_transport_protocol( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets SOAP version URI. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return string representing SOAP version URI + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_options_get_soap_version_uri( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets the wait time after which a client times out in a blocking scenario. + * The default is AXIS2_DEFAULT_TIMEOUT_MILLISECONDS. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return timeout in milliseconds + */ + AXIS2_EXTERN long AXIS2_CALL + axis2_options_get_timeout_in_milli_seconds( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets WSA to address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to endpoint reference struct representing to + * address if set, else NULL + */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_options_get_to( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets use separate listener status. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if using separate listener, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_options_get_use_separate_listener( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets the parent options. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to the parent options struct if set, else NULL + */ + AXIS2_EXTERN axis2_options_t *AXIS2_CALL + axis2_options_get_parent( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Sets the parent options. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param parent pointer to parent options struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_parent( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_options_t * parent); + + /** + * Sets WSA action + * @param options pointer to options struct + * @param env pointer to environment struct + * @param action pointer to action string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_action( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * action); + + /** + * Sets fault to address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param fault_to pointer to endpoint reference struct representing + * fault to address. options takes over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_fault_to( + axis2_options_t * options, + const axutil_env_t * env, + axis2_endpoint_ref_t * fault_to); + + /** + * Sets from address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param from pointer to endpoint reference struct representing + * from to address. options takes over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_from( + axis2_options_t * options, + const axutil_env_t * env, + axis2_endpoint_ref_t * from); + + /** + * sets from address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param to pointer to endpoint reference struct representing + * to address. Options takes over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_to( + axis2_options_t * options, + const axutil_env_t * env, + axis2_endpoint_ref_t * to); + + /** + * Sets transport receiver. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param receiver pointer to transport receiver struct. options takes + * over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_transport_receiver( + axis2_options_t * options, + const axutil_env_t * env, + axis2_transport_receiver_t * receiver); + + /** + * Sets transport in description. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param transport_in pointer to transport_in struct. options takes + * over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_transport_in( + axis2_options_t * options, + const axutil_env_t * env, + axis2_transport_in_desc_t * transport_in); + + /** + * Sets transport in protocol. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param in_protocol pointer to in_protocol struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_transport_in_protocol( + axis2_options_t * options, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS transport_in_protocol); + + /** + * Sets message ID. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param message_id pointer to message_id struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_message_id( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * message_id); + + /** + * Sets the properties hash map. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param properties pointer to properties hash map. options takes + * over the ownership of the hash struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_properties( + axis2_options_t * options, + const axutil_env_t * env, + axutil_hash_t * properties); + + /** + * Sets a property with the given key value. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param property_key property key string + * @param property pointer to property to be set + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_property( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * property_key, + const void *property); + + /** + * Sets relates to. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param relates_to pointer to relates_to struct. options takes + * over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_relates_to( + axis2_options_t * options, + const axutil_env_t * env, + axis2_relates_to_t * relates_to); + + /** + * Sets reply to address. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param reply_to pointer to endpoint reference struct representing + * reply to address. options takes over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_reply_to( + axis2_options_t * options, + const axutil_env_t * env, + axis2_endpoint_ref_t * reply_to); + + /** + * Sets the transport out description. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param transport_out pointer to transport out description struct. + * options takes over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_transport_out( + axis2_options_t * options, + const axutil_env_t * env, + axis2_transport_out_desc_t * transport_out); + + /** + * Sets the sender transport. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param sender_transport name of the sender transport to be set + * @param conf pointer to conf struct, it is from the conf that the + * transport is picked with the given name + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_sender_transport( + axis2_options_t * options, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS sender_transport, + axis2_conf_t * conf); + + /** + * Sets the SOAP version URI. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param soap_version_uri URI of the SOAP version to be set, can be + * either AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI or + * AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_soap_version_uri( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * soap_version_uri); + + /** + * Sets timeout in Milli seconds. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param timeout_in_milli_seconds timeout in milli seconds + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_timeout_in_milli_seconds( + axis2_options_t * options, + const axutil_env_t * env, + const long timeout_in_milli_seconds); + + /** + * Sets transport information. Transport information includes the name + * of the sender transport, name of the receiver transport and if a + * separate listener to be used to receive response. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param sender_transport name of sender transport to be used + * @param receiver_transport name of receiver transport to be used + * @param use_separate_listener bool value indicating whether to use + * a separate listener or not. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_transport_info( + axis2_options_t * options, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS sender_transport, + const AXIS2_TRANSPORT_ENUMS receiver_transport, + const axis2_bool_t use_separate_listener); + + /** + * Sets the bool value indicating whether to use a separate listener or not. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param use_separate_listener bool value indicating whether to use + * a separate listener or not. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_use_separate_listener( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_bool_t use_separate_listener); + + /** + * Adds a WSA reference parameter. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param reference_parameter pointer to reference parameter in the form + * of an AXIOM tree. options takes over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_add_reference_parameter( + axis2_options_t * options, + const axutil_env_t * env, + axiom_node_t * reference_parameter); + + /** + * Gets manage session bool value. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if session is managed, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_options_get_manage_session( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Sets manage session bool value. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param manage_session manage session bool value + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_manage_session( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_bool_t manage_session); + + /** + * Sets WSA message information headers. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param pointer to message information headers struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_msg_info_headers( + axis2_options_t * options, + const axutil_env_t * env, + axis2_msg_info_headers_t * msg_info_headers); + + /** + * Gets WSA message information headers. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return pointer to message information headers struct if set, + * else NULL + */ + AXIS2_EXTERN axis2_msg_info_headers_t *AXIS2_CALL + axis2_options_get_msg_info_headers( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets SOAP version. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return AXIOM_SOAP11 if SOAP version 1.1 is in use, else AXIOM_SOAP12 + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_options_get_soap_version( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Sets SOAP version. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param soap_version soap version, either AXIOM_SOAP11 or AXIOM_SOAP12 + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_soap_version( + axis2_options_t * options, + const axutil_env_t * env, + const int soap_version); + + /** + * Enable/disable MTOM handling. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param enable_mtom AXIS2_TRUE if MTOM is to be enabled, AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_enable_mtom( + axis2_options_t * options, + const axutil_env_t * env, + axis2_bool_t enable_mtom); + + /** + * Gets Enable/disable MTOM status. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if MTOM enabled, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_options_get_enable_mtom( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Gets SOAP action. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return SOAP Action string if set, else NULL + */ + AXIS2_EXTERN axutil_string_t *AXIS2_CALL + axis2_options_get_soap_action( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Sets SOAP action + * @param options pointer to options struct + * @param env pointer to environment struct + * @param action pointer to SOAP action string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_soap_action( + axis2_options_t * options, + const axutil_env_t * env, + axutil_string_t * soap_action); + + /** + * Sets xml parser reset + * @param options pointer to options struct + * @param env pointer to environment struct + * @param reset flag is a boolean value + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_xml_parser_reset( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_bool_t paser_reset_flag); + + /** + * Gets xml parser reset value, + * @param options pointer to options struct + * @param env pointer to environment struct + * @return xml parser reset boolean value + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_options_get_xml_parser_reset( + const axis2_options_t * options, + const axutil_env_t * env); + + /** + * Frees options struct. + * @param options pointer to options struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_options_free( + axis2_options_t * options, + const axutil_env_t * env); + + /** + * Sets the bool value indicating whether to enable REST or not. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param enable_rest bool value indicating whether to enable REST + * or not, AXIS2_TRUE to enable, AXIS2_FALSE to disable + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_enable_rest( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_bool_t enable_rest); + + /** + * Sets the bool value indicating whether to test whether HTTP + * Authentication is required or not. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param test_http_auth bool value indicating whether to test + * or not, AXIS2_TRUE to enable, AXIS2_FALSE to disable + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_test_http_auth( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_bool_t test_http_auth); + + /** + * Sets the bool value indicating whether to test whether Proxy + * Authentication is required or not. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param test_proxy_auth bool value indicating whether to test + * or not, AXIS2_TRUE to enable, AXIS2_FALSE to disable + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_test_proxy_auth( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_bool_t test_proxy_auth); + + /** + * Sets the HTTP method to be used + * @param options pointer to options struct + * @param env pointer to environment struct + * @param http_method string representing HTTP method to use, + * can be either AXIS2_HTTP_GET or AXIS2_HTTP_POST + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_http_method( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * http_method); + + /** + * Sets the Additional HTTP Headers to be sent. + * @param options pointer to options struct + * @param env pointer to environment struct + * @param http_header_list array list containing + * HTTP Headers. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_http_headers( + axis2_options_t * options, + const axutil_env_t * env, + axutil_array_list_t * http_header_list); + + /** + * Creates the options struct. + * @param env pointer to environment struct + * @return a pointer to newly created options struct, or NULL on error + * with error code set in environment's error. + */ + AXIS2_EXTERN axis2_options_t *AXIS2_CALL + axis2_options_create( + const axutil_env_t * env); + + /** + * Creates the options struct with given parent. + * @param env pointer to environment struct + * @param parent pointer to parent struct + * @return a pointer to newly created options struct. Newly created options + * assumes ownership of the parent + * or NULL on error with error code set in environment's error. + */ + AXIS2_EXTERN axis2_options_t *AXIS2_CALL + axis2_options_create_with_parent( + const axutil_env_t * env, + axis2_options_t * parent); + + /** + * Sets HTTP authentication information. + * @param env pointer to environment struct + * @param parent pointer to parent struct + * @param username string representing username + * @param password string representing password + * @param auth_type use "Basic" to force basic authentication + * and "Digest" to force digest authentication or NULL for not + * forcing authentication + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_http_auth_info( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * username, + const axis2_char_t * password, + const axis2_char_t * auth_type); + + /** + * Sets proxy authentication information. + * @param env pointer to environment struct + * @param parent pointer to parent struct + * @param username string representing username + * @param password string representing password + * @param auth_type use "Basic" to force basic authentication + * and "Digest" to force digest authentication or NULL for not + * forcing authentication + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_options_set_proxy_auth_info( + axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * username, + const axis2_char_t * password, + const axis2_char_t * auth_type); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_OPTIONS_H */ diff --git a/include/axis2_out_transport_info.h b/include/axis2_out_transport_info.h new file mode 100644 index 0000000..1161062 --- /dev/null +++ b/include/axis2_out_transport_info.h @@ -0,0 +1,115 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_OUT_TRANSPORT_INFO_H +#define AXIS2_OUT_TRANSPORT_INFO_H + +/** + * @defgroup axis2_out_transport_info out transport info + * @ingroup axis2_core_trans + * Description + * @{ + */ + +/** + * @file axis2_out_transport_info.h + * @brief axis2 Out Transport Info + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_out_transport_info */ + typedef struct axis2_out_transport_info axis2_out_transport_info_t; + + typedef struct axis2_out_transport_info_ops axis2_out_transport_info_ops_t; + + struct axis2_out_transport_info_ops + { + axis2_status_t( + AXIS2_CALL + * set_content_type)( + axis2_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * content_type); + + axis2_status_t( + AXIS2_CALL + * set_char_encoding)( + axis2_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding); + + axis2_status_t( + AXIS2_CALL + * set_cookie_header)( + axis2_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * cookie_header); + + axis2_status_t( + AXIS2_CALL + * set_session)( + axis2_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value); + + void( + AXIS2_CALL + * free)( + axis2_out_transport_info_t * info, + const axutil_env_t * env); + }; + + struct axis2_out_transport_info + { + const axis2_out_transport_info_ops_t *ops; + }; + + /** Set content type. */ +#define AXIS2_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_transport_info, \ + env, content_type) ((out_transport_info->ops)->set_content_type(out_transport_info, env, content_type)) + + /** Set cahr encoding. */ +#define AXIS2_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(out_transport_info, \ + env, encoding) ((out_transport_info->ops)->set_char_encoding(out_transport_info, env, encoding)) + + /** Set cookie header. */ +#define AXIS2_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_transport_info, \ + env, cookie_header) ((out_transport_info->ops)->set_cookie_header(out_transport_info, env, cookie_header)) + + /** Set session. */ +#define AXIS2_OUT_TRANSPORT_INFO_SET_SESSION(out_transport_info, \ + env, session_id, session_value) ((out_transport_info->ops)->set_session(out_transport_info, env, session_id, session_value)) + + /** Free. */ +#define AXIS2_OUT_TRANSPORT_INFO_FREE(out_transport_info, env)\ + ((out_transport_info->ops)->free(out_transport_info, env)) + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_OUT_TRANSPORT_INFO_H */ diff --git a/include/axis2_phase.h b/include/axis2_phase.h new file mode 100644 index 0000000..e0231d8 --- /dev/null +++ b/include/axis2_phase.h @@ -0,0 +1,352 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_PHASE_H +#define AXIS2_PHASE_H + +/** + * @defgroup axis2_phase phases + * @ingroup axis2_engine + * phase is a logical unit of execution in the Axis2 engine's execution flows. + * A phase encapsulates one or more handlers in a given sequence to be invoked. + * The sequencing of handlers within a phase are often defined by module + * configuration which specifies where in the phase's handler chain a given + * handler should be placed. + * Calling invoke on phase triggers invoke on the handlers stored within the + * phase in the sequence they are ordered. + * @{ + */ + +/** + * @file axis2_phase.h + */ + +#include +#include +#include +#include +#include +#include + +/** + * A given handler's location within the list of handlers is before a particular + * handler and after another particular handler. + */ +#define AXIS2_PHASE_BOTH_BEFORE_AFTER 0 + +/** + * A given handler's location within the list of handlers is before another + * given handler. + */ +#define AXIS2_PHASE_BEFORE 1 + +/** + * A given handler's location within the list of handlers is after another + * given handler. + */ +#define AXIS2_PHASE_AFTER 2 + +/** + * A given handler's location within the list of handlers could be anywhere in + * the list. + */ +#define AXIS2_PHASE_ANYWHERE 3 + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for axis2_phase */ + typedef struct axis2_phase axis2_phase_t; + + struct axis2_msg_ctx; + + /** + * Adds given handler to the specified position in the handler array list. + * @param phase pointer to phase struct + * @param env pointer to environment struct + * @param index index + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_add_handler_at( + axis2_phase_t * phase, + const axutil_env_t * env, + const int index, + axis2_handler_t * handler); + + /** + * Adds the given handler to the end of the handler list. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_add_handler( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Remove the given handler from the handler list. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_remove_handler( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Invokes the phase. This function will in turn call invoke method of + * each handler in the handler list, in sequence, starting from the + * beginning of the list to the end of the list. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_invoke( + axis2_phase_t * phase, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + + /** + * Gets phase name. + * @param phase pointer to phase + * @param env pointer to environment struct + * @return returns name of phase + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_phase_get_name( + const axis2_phase_t * phase, + const axutil_env_t * env); + + /** + * Gets handler count in the handler list. + * @param phase pointer to phase + * @param env pointer to environment struct + * @return the number of handlers in the handler list + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_phase_get_handler_count( + const axis2_phase_t * phase, + const axutil_env_t * env); + + /** + * Sets the first handler in the handler list. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_set_first_handler( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Sets the last handler in the handler list. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_set_last_handler( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Adds handler within the handler description to the list of handlers + * in the phase. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler_desc pointer to handler description, phase does not + * assume the ownership of neither the handler description not the handler + * within the handler description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_add_handler_desc( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_desc_t * handler_desc); + + /** + * Remove handler within the handler description from the list of handlers + * in the phase. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler_desc pointer to handler description, phase does not + * assume the ownership of neither the handler description not the handler + * within the handler description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_remove_handler_desc( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_desc_t * handler_desc); + + /** + * Inserts the handler into handler list of the phase based on the phase + * rules associated with the handler. This function takes into account + * the before rules of the handler. Before rules specify the location + * of a current handler in the handler list, before which the given + * handler is to be placed. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_insert_before( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Inserts the handler into handler list of the phase based on the phase + * rules associated with the handler. This function takes into account + * the after rules of the handler. After rules specify the location + * of a current handler in the handler list, after which the given + * handler is to be placed. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_insert_after( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Inserts the handler into handler list of the phase based on both + * before and after phase rules associated with the handler. + * This method assume that both the before and after cannot be the same + * handler . That condition is not checked by this function. + * It should be checked before calling this function + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler pointer to handler, phase does not assume the + * ownership of the handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_phase_insert_before_and_after( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler); + + /** + * Inserts the handler to the correct location in the handler list of + * the phase. Location is evaluated based on the phase rules. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param handler_desc pointer to handler description, phase does not + * assume the ownership of neither the handler description not the handler + * within the handler description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_insert_handler_desc( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_desc_t * handler_desc); + + /** + * Gets all the handlers in the phase. + * @param phase pointer to phase + * @param env pointer to environment struct + * @return pointer to array list containing the list of handlers + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phase_get_all_handlers( + const axis2_phase_t * phase, + const axutil_env_t * env); + + /** + * Invokes handlers starting from the given handler index. + * @param phase pointer to phase + * @param env pointer to environment struct + * @param paused_handler_index index of the handler to start the + * invocation from + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_phase_invoke_start_from_handler( + axis2_phase_t * phase, + const axutil_env_t * env, + const int paused_handler_index, + struct axis2_msg_ctx *msg_ctx); + + /** + * Frees phase struct. + * @param phase pointer to phase + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_phase_free( + axis2_phase_t * phase, + const axutil_env_t * env); + + /** + * creates phase struct instance. + * @param env pointer to environment struct + * @param phase_name name of the phase to be created + * @return pointer to newly created phase + */ + AXIS2_EXTERN axis2_phase_t *AXIS2_CALL + axis2_phase_create( + const axutil_env_t * env, + const axis2_char_t * phase_name); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_increment_ref( + axis2_phase_t * phase, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_PHASE_H */ diff --git a/include/axis2_phase_holder.h b/include/axis2_phase_holder.h new file mode 100644 index 0000000..d24efae --- /dev/null +++ b/include/axis2_phase_holder.h @@ -0,0 +1,170 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_PHASE_HOLDER_H +#define AXIS2_PHASE_HOLDER_H + +/** + * @defgroup axis2_phase_holder phase holder + * @ingroup axis2_phase_resolver + * phase holder is used by phase resolver to hold information related to + * phases and handlers within a phase. This struct hold the list of phases + * found in the services.xml and axis2.xml. + * @{ + */ + +/** + * @file axis2_phase_holder.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_phase_holder */ + typedef struct axis2_phase_holder axis2_phase_holder_t; + + struct axis2_phase; + struct axis2_handler_desc; + struct axis2_handler; + struct axis2_phase_rule; + + /** + * Frees phase holder. + * @param phase_holder pointer to phase holder + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_phase_holder_free( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env); + + /** + * Checks if the named phase exist. + * @param phase_holder pointer to phase holder + * @param env pointer to environment struct + * @param phase_name phase name string + * @return AXIS2_TRUE if the named phase exist, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_phase_holder_is_phase_exist( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env, + const axis2_char_t * phase_name); + + /** + * Adds given handler to phase holder. + * @param phase_holder pointer to phase holder + * @param env pointer to environment struct + * @para handler pointer to handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_holder_add_handler( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env, + struct axis2_handler_desc *handler); + + /** + * Removes given handler from phase holder. + * @param phase_holder pointer to phase holder + * @param env pointer to environment struct + * @para handler pointer to handler + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_holder_remove_handler( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env, + struct axis2_handler_desc *handler); + + /** + * Gets the named phase from phase array list. + * @param phase_holder pointer to phase holder + * @param env pointer to environment struct + * @param phase_name pointer to phase name + * @return pointer to named phase if it exists, else NULL. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_phase *AXIS2_CALL + axis2_phase_holder_get_phase( + const axis2_phase_holder_t * phase_holder, + const axutil_env_t * env, + const axis2_char_t * phase_name); + + /** + * Builds the transport phase. This method loads the corresponding handlers and added them into + * correct phase. This function is no longer used in Axis2/C and + * marked as deprecated. + * @deprecated + * @param phase_holder pointer to phase holder + * @param env pointer to environment struct + * @param phase pointer to phase, phase holder does not assume the + * ownership the phase + * @param handlers pointer to array list of handlers, phase holder does + * not assume the ownership of the list + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_holder_build_transport_handler_chain( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env, + struct axis2_phase *phase, + axutil_array_list_t * handlers); + + /** + * Creates phase holder struct. + * @param env pointer to environment struct + * @return pointer to newly created phase holder + */ + AXIS2_EXTERN axis2_phase_holder_t *AXIS2_CALL + axis2_phase_holder_create( + const axutil_env_t * env); + + /** + * Creates phase holder struct with given list of phases. + * @param env pointer to environment struct + * @param phases pointer to array list of phases + * @return pointer to newly created phase holder + */ + AXIS2_EXTERN axis2_phase_holder_t *AXIS2_CALL + + axis2_phase_holder_create_with_phases( + const axutil_env_t * env, + axutil_array_list_t * phases); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_PHASE_HOLDER_H */ diff --git a/include/axis2_phase_meta.h b/include/axis2_phase_meta.h new file mode 100644 index 0000000..10e5555 --- /dev/null +++ b/include/axis2_phase_meta.h @@ -0,0 +1,89 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_PHASE_META_H +#define AXIS2_PHASE_META_H + +/** + * @defgroup axis2_phase_meta phase meta data + * @ingroup axis2_engine + * @{ + */ + +/** + * @file axis2_conf.h + * @brief Axis2 configuration interface + */ + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Axis2 in flow */ + + /*#define AXIS2_IN_FLOW 1*/ + + /** Axis2 out flow */ + + /*#define AXIS2_OUT_FLOW 2*/ + + /** Axis2 fault in flow */ + + /*#define AXIS2_FAULT_IN_FLOW 3*/ + + /** Axis2 fault out flow */ + + /*#define AXIS2_FAULT_OUT_FLOW 4*/ + + /** phase transport in */ +#define AXIS2_PHASE_TRANSPORT_IN "Transport" + + /** phase pre dispatch */ +#define AXIS2_PHASE_PRE_DISPATCH "PreDispatch" + + /** phase dispatch */ +#define AXIS2_PHASE_DISPATCH "Dispatch" + + /** phase post dispatch */ +#define AXIS2_PHASE_POST_DISPATCH "PostDispatch" + + /** phase policy determination */ +#define AXIS2_PHASE_POLICY_DETERMINATION "PolicyDetermination" + + /** phase message processing */ +#define AXIS2_PHASE_MESSAGE_PROCESSING "MessageProcessing" + + /** phase message out */ +#define AXIS2_PHASE_MESSAGE_OUT "MessageOut" + + /** + * All the handlers inside transport_sender and tranport_recievre in axis2.xml gose + * to this phase + */ +#define AXIS2_TRANSPORT_PHASE "TRANSPORT" + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_PHASE_META_H */ diff --git a/include/axis2_phase_resolver.h b/include/axis2_phase_resolver.h new file mode 100644 index 0000000..e3b1af1 --- /dev/null +++ b/include/axis2_phase_resolver.h @@ -0,0 +1,275 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_PHASE_RESOLVER_H +#define AXIS2_PHASE_RESOLVER_H + +/** + * @defgroup axis2_phase_resolver phase resolver + * @ingroup axis2_phase_resolver + * + * Engaging modules into axis2 configuration, services and operations are done here. + * This is accomplished mainly by following operations respectively. + * axis2_phase_resolver_engage_module_globally(). + * axis2_phase_resolver_engage_module_to_svc(). + * axis2_phase_resolver_engage_module_to_op(). + * The user normally engage a module programmatically or using configuration files. When an + * application client engage a module programmatically he can use axis2_op_client_engage_module() + * function, or axis2_svc_client_engage_module() function. Engaging using configuration files means + * adding a module_ref parameter into services.xml or axis2.xml. + * In whatever way engaging a module finally sums upto addding module handlers into each operations flows + * in the order defined in module.xml. Here flows in operations are actually array lists of user defined + * phases (See op.c). + * + * Above functions in phase resolver add module handlers into operation flows as mentioned above as well + * as add module handlers into system defined phases. User defined phases are added into each operation + * at deployment time before handlers are added into them by phase resolver. System define phases + * are added into axis2_conf_t structure and predefined handlers are added to them before module handlers + * are added to them by phase resolver. + * + * Modules defined in axis2.xml are engaged by call to axis2_conf_engage_module() function. Modules defined in + * services xml are engaged by call to axis2_svc_enage_module() or axis2_svc_grp_engage_module(). Modules + * define in operation tag under services.xml are engaged by call to axis2_op_engage_module() function. + * These function in tern call one of axis2_phase_resolver_engage_module_globally() or + * axis2_phase_resolver_engage_module_to_svc() or axis2_phase_resolver_engage_module_to_op. + * + * Also when you add a service programmaticaly into axis2_conf_t you need to build execution chains for that + * services operations. + * axis2_phase_resolver_build_execution_chains_for_svc() is the function to be called for that purpose. + * This will extract the already engaged modules for the configuration and service and add handlers from + * them into operation phases. + * + * @{ + */ + +/** + * @file axis2_phase_resolver.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for axis2_phase_resolver */ + typedef struct axis2_phase_resolver axis2_phase_resolver_t; + + struct axis2_phase; + struct axis2_handler_desc; + struct axis2_module_desc; + struct axis2_handler; + struct axis2_phase_rule; + struct axis2_svc; + struct axis2_conf; + struct axis2_op; + struct axis2_phase_holder; + + /** + * Frees phase resolver. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_phase_resolver_free( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env); + + /** + * Engages the given module globally. Engaging a module globally means + * that the given module would be engaged to all operations in all + * services. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @param module pointer to module + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_phase_resolver_engage_module_globally( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + struct axis2_module_desc *module); + + /** + * Engages the given module to the given service. This means + * the given module would be engaged to all operations of the given + * service. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @param svc pointer to service + * @param module_desc pointer to module description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_phase_resolver_engage_module_to_svc( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + struct axis2_svc *svc, + struct axis2_module_desc *module_desc); + + /** + * Engages the given module to the given operation. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @param axis_op pointer to axis operation + * @param pointer to module description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_resolver_engage_module_to_op( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + struct axis2_op *axis_op, + struct axis2_module_desc *module_desc); + + /** + * Builds the execution chains for service. Execution chains are collection of phases that are + * invoked in the execution path. Execution chains for system defined phases are created when + * call to engage_module_globally() function. Here it is created for service operations. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_resolver_build_execution_chains_for_svc( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env); + + /** + * Builds execution chains for given module operation. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @param op pointer to operation + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_phase_resolver_build_execution_chains_for_module_op( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + struct axis2_op *op); + + /** + * Disengages the given module from the given service. This means + * the given module would be disengaged from all operations of the given + * service. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @param svc pointer to service + * @param module_desc pointer to module description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_resolver_disengage_module_from_svc( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + struct axis2_svc *svc, + struct axis2_module_desc *module_desc); + + /** + * Disengages the given module from the given operation. + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @param axis_op pointer to axis operation + * @param pointer to module description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_resolver_disengage_module_from_op( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + struct axis2_op *axis_op, + struct axis2_module_desc *module_desc); + + /** + * Builds transport chains. This function is no longer used in Axis2/C and hence + * marked as deprecated. + * @deprecated + * @param phase_resolver pointer to phase resolver + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_resolver_build_transport_chains( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env); + + /** + * Creates phase resolver struct. + * @param env pointer to environment struct + * @return pointer to newly created phase resolver + */ + AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL + + axis2_phase_resolver_create( + const axutil_env_t * env); + + /** + * Creates phase resolver struct with given configuration. + * @param env pointer to environment struct + * @param axis2_config pointer to aixs2 configuration, phase resolver + * created would not assume ownership of configuration + * @return pointer to newly created phase resolver + */ + AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL + + axis2_phase_resolver_create_with_config( + const axutil_env_t * env, + struct axis2_conf *axis2_config); + + /** + * Creates phase resolver struct with given configuration and service. + * @param env pointer to environment struct + * @param aixs2_config pointer to aixs2 configuration, phase resolver + * created would not assume ownership of configuration + * @param svc pointer to service, phase resolver + * created would not assume ownership of service + * @return pointer to newly created phase resolver + */ + AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL + + axis2_phase_resolver_create_with_config_and_svc( + const axutil_env_t * env, + struct axis2_conf *axis2_config, + struct axis2_svc *svc); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_PHASE_RESOLVER_H */ diff --git a/include/axis2_phase_rule.h b/include/axis2_phase_rule.h new file mode 100644 index 0000000..de5b645 --- /dev/null +++ b/include/axis2_phase_rule.h @@ -0,0 +1,216 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_PHASE_RULE_H +#define AXIS2_PHASE_RULE_H + +/** + * @defgroup axis2_phase_rule phase rule + * @ingroup axis2_desc + * phase rule encapsulates data and operations related to phase rules for a + * given handler. phase rule lives within a handler. + * phase rules of a handler specify the relative location of the + * handler within the phase to which it belongs, with respect to other handlers + * in the phase or first and last positions of the handler chain of the phase. + * @{ + */ + +/** + * @file axis2_phase_rule.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_phase_rule */ + typedef struct axis2_phase_rule axis2_phase_rule_t; + + /** + * Gets the name of the handler before which the handler associated with + * this rule should be placed. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @return name of handler before which the handler should be placed + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_phase_rule_get_before( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env); + + /** + * Sets the name of the handler before which the handler associated with + * this rule should be placed. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @param before name of handler before which the handler should be placed + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_rule_set_before( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env, + const axis2_char_t * before); + + /** + * Gets the name of the handler after which the handler associated with + * this rule should be placed. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @return name of handler after which the handler should be placed + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_phase_rule_get_after( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env); + + /** + * Sets the name of the handler after which the handler associated with + * this rule should be placed. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @param after name of handler after which the handler should be placed + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_rule_set_after( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env, + const axis2_char_t * after); + + /** + * Gets name. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @return name string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_phase_rule_get_name( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env); + + /** + * Sets name. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @param name name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_rule_set_name( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Checks if the handler is the first in phase. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @return AXIS2_TRUE if the handler associated with this rule is the + * first in phase, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_phase_rule_is_first( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env); + + /** + * Sets handler to be the first in phase. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @param first AXIS2_TRUE if the handler associated with this rule is the + * first in phase, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_rule_set_first( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env, + axis2_bool_t first); + + /** + * Checks if the handler is the last in phase. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @return AXIS2_TRUE if the handler associated with this rule is the + * last in phase, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_phase_rule_is_last( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env); + + /** + * Sets handler to be the last in phase. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @param last AXIS2_TRUE if the handler associated with this rule is the + * last in phase, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phase_rule_set_last( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env, + axis2_bool_t last); + + /** + * Frees phase rule. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_phase_rule_free( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env); + + /** + * Clones phase rule. + * @param phase_rule pointer to phase rule + * @param env pointer to environment struct + * @return pointer to newly cloned phase rule + */ + AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL + axis2_phase_rule_clone( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env); + + /** + * Creates a phase rule struct instance. + * @param env pointer to environment struct + * @param phase_name name of the phase rule + * @return pointer to newly created phase rule + */ + AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL + axis2_phase_rule_create( + const axutil_env_t * env, + const axis2_char_t * name); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_PHASE_RULE_H */ diff --git a/include/axis2_phases_info.h b/include/axis2_phases_info.h new file mode 100644 index 0000000..9c1a1f7 --- /dev/null +++ b/include/axis2_phases_info.h @@ -0,0 +1,238 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_PHASES_INFO_H +#define AXIS2_PHASES_INFO_H + +/** @defgroup axis2_phases_info phases information + * @ingroup axis2_deployment + * + * In deployment engine when configuration builder parse phase order elements in axis2.xml, for + * phases defined in a phase order it will create a phase name list and add it to the phases + * info. There are four phase orders. inflow, outflow, in faultflow and out faultflow. + * So configuration builder add array lists for each of this phase orders into the phases info. + * + * At the time of module engagement phase resolver call the functions here to retrieve phase + * lists for each flow for the purpose of adding handlers. When such a request come what each + * function do is, create phase instances list for corresponding phase names stored in the phase name + * list for that flow and return. + * + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_phases_info */ + typedef struct axis2_phases_info axis2_phases_info_t; + + /** Deallocate memory + * @param pahses_info pointer to phases info + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_phases_info_free( + axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * Set the inflow phase names as an array list. These phases are defined in the inflow phase + * order element defined in axis2.xml. + * + * @param phases_info pointer to phases info + * @param env pointer to environment struct + * @param in_phases inter to in phases + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phases_info_set_in_phases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * in_phases); + + /** + * Set the outflow phase names as an array list. These phases are defined in the outflow phase + * order element defined in axis2.xml. + * + * @param phases_info pointer to phases info + * @param env pointer to environment struct + * @param out_phases pointer to out phases + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phases_info_set_out_phases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * out_phases); + + /** + * Set the INfaultflow phase names as an array list. These phases are defined in the INfaultflow + * phase order element defined in axis2.xml. + * + * @param phases_info pointer to phases info + * @param env pointer to environment struct + * @param in_faultphases pionter to in fault phases + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_phases_info_set_in_faultphases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * in_faultphases); + + /** + * Set the Outfaultflow phase names as an array list. These phases are defined in the + * Outfaultflow phase order element defined in axis2.xml. + * + * @param phases_info pointer to phases info + * @param env pointer to env + * @param out_faultphases pointer to out fault phases + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_phases_info_set_out_faultphases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * out_faultphases); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_in_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_out_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @parma env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_in_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_out_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_op_in_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_op_out_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_op_in_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_phases_info_get_op_out_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env); + + /** + * @param phases_info pointer to phases info + * @param env pointer to environment struct + * @param axis2_opt pointer to axis2 opt + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_phases_info_set_op_phases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + struct axis2_op *axis2_opt); + + /** create Phases Info struct + * @param env pointer to environment struct + * @return pointer to newly created phases info + */ + AXIS2_EXTERN axis2_phases_info_t *AXIS2_CALL + axis2_phases_info_create( + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_phases_info_copy_flow( + const axutil_env_t * env, + const axutil_array_list_t * flow_to_copy); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /*AXIS2_PHASES_INFO_H */ diff --git a/include/axis2_policy_include.h b/include/axis2_policy_include.h new file mode 100644 index 0000000..c088aeb --- /dev/null +++ b/include/axis2_policy_include.h @@ -0,0 +1,215 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_POLICY_INCLUDE_H +#define AXIS2_POLICY_INCLUDE_H + +/** + * @defgroup axis2_policy_include policy include + * @ingroup axis2_desc + * @{ + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_policy_include */ + typedef struct axis2_policy_include axis2_policy_include_t; + + typedef enum axis2_policy_types + { + AXIS2_POLICY = 0, + AXIS2_MODULE_POLICY, + AXIS2_SERVICE_POLICY, + AXIS2_OPERATION_POLICY, + AXIS2_MESSAGE_POLICY, + AXIS2_PORT_POLICY, + AXIS2_PORT_TYPE_POLICY, + AXIS2_BINDING_POLICY, + AXIS2_BINDING_OPERATION_POLICY, + AXIS2_INPUT_POLICY, + AXIS2_OUTPUT_POLICY, + AXIS2_BINDING_INPUT_POLICY, + AXIS2_BINDING_OUTPUT_POLICY, + AXIS2_MODULE_OPERATION_POLICY, + AXIS2_POLICY_REF, + AXIS2_ANON_POLICY + } axis2_policy_types; + + /** + * Creates policy include struct. + * @param env pointer to environment struct + * @return pointer to newly created policy include + */ + AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL + + axis2_policy_include_create( + const axutil_env_t * env); + + AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL + + axis2_policy_include_create_with_desc( + const axutil_env_t * env, + axis2_desc_t * desc); + + /** + * Frees policy include. + * @param policy_include pointer to policy include + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_policy_include_free( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_policy_include_free( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_policy_include_set_registry( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_registry_t * registry); + + AXIS2_EXTERN neethi_registry_t *AXIS2_CALL + + axis2_policy_include_get_registry( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_policy_include_set_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_policy_t * policy); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_policy_include_update_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_policy_t * policy); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_policy_include_set_effective_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + neethi_policy_t * effective_policy); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_policy_include_set_desc( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_desc_t * desc); + + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_policy_include_get_desc( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL + + axis2_policy_include_get_parent( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + axis2_policy_include_get_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + + axis2_policy_include_get_effective_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_policy_include_get_policy_elements( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_policy_include_get_policy_elements_with_type( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + int type); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_policy_include_register_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_char_t * key, + neethi_policy_t * effective_policy); + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + + axis2_policy_include_get_policy_with_key( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_char_t * key); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_policy_include_add_policy_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + int type, + neethi_policy_t * policy); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_policy_include_add_policy_reference_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + int type, + neethi_reference_t * reference); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_policy_include_remove_policy_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env, + axis2_char_t * policy_uri); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_policy_include_remove_all_policy_element( + axis2_policy_include_t * policy_include, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_POLICY_INCLUDE_H */ diff --git a/include/axis2_raw_xml_in_out_msg_recv.h b/include/axis2_raw_xml_in_out_msg_recv.h new file mode 100644 index 0000000..8ffe9bb --- /dev/null +++ b/include/axis2_raw_xml_in_out_msg_recv.h @@ -0,0 +1,59 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_RAW_XML_IN_OUT_MSG_RECV_H +#define AXIS2_RAW_XML_IN_OUT_MSG_RECV_H + +/** @defgroup axis2_raw_xml_in_out_msg_recv raw XML in-out message receiver + * @ingroup axis2_receivers + * @{ + */ + +/** + * @file axis2_ws_info.h + * @brief Axis2 Raw Xml In Out Message Receiver interface + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * Creates raw xml in out message receiver struct + * @return pointer to newly created raw xml in out message receiver + */ + AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL + + axis2_raw_xml_in_out_msg_recv_create( + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_RAW_XML_IN_OUT_MSG_RECV_H */ diff --git a/include/axis2_relates_to.h b/include/axis2_relates_to.h new file mode 100644 index 0000000..5775545 --- /dev/null +++ b/include/axis2_relates_to.h @@ -0,0 +1,129 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_RELATES_TO_H +#define AXIS2_RELATES_TO_H + +/** + * @defgroup axis2_relates_to relates to + * @ingroup axis2_addr + * relates to encapsulates data that indicate how a message relates to + * another message. + * The related message is identified by a URI that corresponds to the + * related message's message ID. The type of the relationship is also captured + * by relates to. Basically relates to handles the following WS-Addressing + * header xs:anyURI + * @{ + */ + +/** + * @file axis2_relates_to.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_relates_to */ + typedef struct axis2_relates_to axis2_relates_to_t; + + /** + * creates relates to struct. + * @param env pointer to environment struct + * @param value value string + * @param relationship_type relationship type string + */ + AXIS2_EXTERN axis2_relates_to_t *AXIS2_CALL + axis2_relates_to_create( + const axutil_env_t * env, + const axis2_char_t * value, + const axis2_char_t * relationship_type); + + /** + * Gets value. The value field represents the URI that corresponds to the + * related message's message ID + * @param relates_to pointer to relates to struct + * @param env pointer to environment struct + * @return value string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_relates_to_get_value( + const axis2_relates_to_t * relates_to, + const axutil_env_t * env); + + /** + * Sets value. The value field represents the URI that corresponds to the + * related message's message ID + * @param relates_to pointer to relates to struct + * @param env pointer to environment struct + * @param value value string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_relates_to_set_value( + struct axis2_relates_to *relates_to, + const axutil_env_t * env, + const axis2_char_t * value); + + /** + * Gets relationship type. + * @param relates_to pointer to relates to struct + * @param env pointer to environment struct + * @return relationship type string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_relates_to_get_relationship_type( + const axis2_relates_to_t * relates_to, + const axutil_env_t * env); + + /** + * Sets relationship type. + * @param relates_to pointer to relates to struct + * @param env pointer to environment struct + * @param relationship_type relationship type string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_relates_to_set_relationship_type( + struct axis2_relates_to *relates_to, + const axutil_env_t * env, + const axis2_char_t * relationship_type); + + /** + * Frees relates to struct. + * @param relates_to pointer to relates to struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_relates_to_free( + struct axis2_relates_to *relates_to, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_RELATES_TO_H */ diff --git a/include/axis2_simple_http_svr_conn.h b/include/axis2_simple_http_svr_conn.h new file mode 100644 index 0000000..37b9979 --- /dev/null +++ b/include/axis2_simple_http_svr_conn.h @@ -0,0 +1,204 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_SIMPLE_HTTP_SVR_CONN_H +#define AXIS2_SIMPLE_HTTP_SVR_CONN_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_simple_http_svr_conn.h + * @brief Axis2 simple http server connection + */ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_simple_http_svr_conn axis2_simple_http_svr_conn_t; + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_simple_http_svr_conn_close( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_simple_http_svr_conn_is_open( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + * @param keep_alive + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_simple_http_svr_conn_set_keep_alive( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env, + axis2_bool_t keep_alive); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_simple_http_svr_conn_is_keep_alive( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + + axis2_simple_http_svr_conn_get_stream( + const axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_http_response_writer_t *AXIS2_CALL + + axis2_simple_http_svr_conn_get_writer( + const axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_http_simple_request_t *AXIS2_CALL + axis2_simple_http_svr_conn_read_request( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + * @param response response + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_simple_http_svr_conn_write_response( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env, + axis2_http_simple_response_t * response); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + * @param timeout timeout + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_simple_http_svr_conn_set_rcv_timeout( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env, + int timeout); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + * @param timeout timeout + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_simple_http_svr_conn_set_snd_timeout( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env, + int timeout); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_simple_http_svr_conn_get_svr_ip( + const axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_simple_http_svr_conn_get_peer_ip( + const axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + + /** + * @param svr_conn pointer to server connection struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_simple_http_svr_conn_free( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * creates axis2_simple_http_svr_conn struct + * @param env pointer to environment struct + * @param sockfd sockfd + */ + AXIS2_EXTERN axis2_simple_http_svr_conn_t *AXIS2_CALL + + axis2_simple_http_svr_conn_create( + const axutil_env_t * env, + int sockfd); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SIMPLE_HTTP_SVR_CONN_H */ diff --git a/include/axis2_stub.h b/include/axis2_stub.h new file mode 100644 index 0000000..0d502ca --- /dev/null +++ b/include/axis2_stub.h @@ -0,0 +1,200 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_STUB_H +#define AXIS2_STUB_H + +/** @defgroup axis2_stub stub + * @ingroup axis2_client_api + * stub is a wrapper API for service client that helps users to use client API + * easily. + * @sa axis2_svc_client + * @{ + */ + +/** + * @file axis2_stub.h + */ + +#include +#include +#include +#include +#include + +/** DEPRECATED: Please use AXIOM_SOAP11 instead. + Constant value representing SOAP version 1.1 */ +#define AXIOM_SOAP_11 1 + +/** DEPRECATED: Please use AXIOM_SOAP12 instead. + Constant value representing SOAP version 1.2 */ +#define AXIOM_SOAP_12 2 + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_stub */ + typedef struct axis2_stub axis2_stub_t; + + /** + * Frees stub struct. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_stub_free( + axis2_stub_t * stub, + const axutil_env_t * env); + + /** + * Sets the endpoint reference. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @param endpoint_ref pointer to endpoint reference. stub assumes the + * ownership of the endpoint reference struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_stub_set_endpoint_ref( + axis2_stub_t * stub, + const axutil_env_t * env, + axis2_endpoint_ref_t * endpoint_ref); + + /** + * Sets the endpoint reference, represented by a string. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @param endpoint_uri pointer to endpoint uri string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_stub_set_endpoint_uri( + axis2_stub_t * stub, + const axutil_env_t * env, + const axis2_char_t * endpoint_uri); + + /** + * Sets the bool value specifying whether to use a separate listener + * for receive channel. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @param use_separate whether to use a separate listener + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_stub_set_use_separate_listener( + axis2_stub_t * stub, + const axutil_env_t * env, + const axis2_bool_t use_separate_listener); + + /** + * Sets the SOAP version. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @param soap_version int value representing the SOAP version + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_stub_set_soap_version( + axis2_stub_t * stub, + const axutil_env_t * env, + const int soap_version); + + /** + * Gets the service context ID. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @return service context ID if set, else NULL + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_stub_get_svc_ctx_id( + const axis2_stub_t * stub, + const axutil_env_t * env); + + /** + * Engages the named module. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @param module_name string representing the name of the module + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_stub_engage_module( + axis2_stub_t * stub, + const axutil_env_t * env, + const axis2_char_t * module_name); + + /** + * Gets the service client instance used by this stub. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @return pointer to service client struct used by the stub + */ + AXIS2_EXTERN axis2_svc_client_t *AXIS2_CALL + axis2_stub_get_svc_client( + const axis2_stub_t * stub, + const axutil_env_t * env); + + /** + * Gets the options used on top of the service client used by this stub. + * @param stub pointer to stub struct + * @param env pointer to environment struct + * @return pointer to options used by the service client of this stub + */ + AXIS2_EXTERN axis2_options_t *AXIS2_CALL + axis2_stub_get_options( + const axis2_stub_t * stub, + const axutil_env_t * env); + + /** + * Creates a stub instance. + * @param env pointer to environment struct + * @param endpoint_ref pointer to endpoint reference struct representing the + * stub endpoint. Newly created stub assumes ownership of the endpoint + * @param client_home name of the directory that contains the Axis2/C repository + * @return pointer to newly created axis2_stub struct + */ + AXIS2_EXTERN axis2_stub_t *AXIS2_CALL + axis2_stub_create_with_endpoint_ref_and_client_home( + const axutil_env_t * env, + axis2_endpoint_ref_t * endpoint_ref, + const axis2_char_t * client_home); + + /** + * Creates a stub instance. + * @param env pointer to environment struct + * @param endpoint_uri string representing the endpoint reference + * @param client_home name of the directory that contains the Axis2/C repository + * @return pointer to newly created axis2_stub struct + */ + AXIS2_EXTERN axis2_stub_t *AXIS2_CALL + axis2_stub_create_with_endpoint_uri_and_client_home( + const axutil_env_t * env, + const axis2_char_t * endpoint_uri, + const axis2_char_t * client_home); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_STUB_H */ diff --git a/include/axis2_svc.h b/include/axis2_svc.h new file mode 100644 index 0000000..c710587 --- /dev/null +++ b/include/axis2_svc.h @@ -0,0 +1,1236 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_SVC_H +#define AXIS2_SVC_H + +/** @defgroup axis2_svc service + * @ingroup axis2_desc + * service represents the static structure of a service in a service group. + * In Axis2 description hierarchy, a service lives inside the service group to + * which it belongs. + * services are configured in services.xml files located in the respective + * service group folders of the services folder in the repository. + * In services.xml file, services are declared in association with a given + * service group or at top level as a stand alone service. In cases where a + * service is configured without an associated service group, a service group + * with the same name as that of the service would be created by the deployment + * engine and the service would be associated with that newly created service + * group. The deployment engine would create service instances to represent + * those configured services in services.xml files and would associate them with + * the respective service group in the configuration. + * service encapsulates data on engaged module information, the XML schema + * defined in WSDL that is associated with the service and the operations of + * the service. + * @{ + */ + +/** + * @file axis2_svc.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc */ + typedef struct axis2_svc axis2_svc_t; + + struct axis2_svc_grp; + struct axis2_flow_container; + struct axutil_param_container; + struct axis2_module_desc; + struct axis2_conf; + + /** + * Frees service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_free( + axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Adds operation. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param op pointer to operation struct, service assumes ownership of + * operation + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_add_op( + axis2_svc_t * svc, + const axutil_env_t * env, + struct axis2_op *op); + + /** + * Gets operation corresponding to the given QName. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param op_qname pointer to QName representing operation QName + * @return pointer to operation corresponding to given QName + */ + AXIS2_EXTERN struct axis2_op *AXIS2_CALL + axis2_svc_get_op_with_qname( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axutil_qname_t * op_qname); + + /** + * Gets the RESTful operation list corresponding to the given method + * and first constant part of location. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param http_method HTTPMethod + * @param http_location HTTPLocation + * @return pointer to operation corresponding to given method and + * location + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_svc_get_rest_op_list_with_method_and_location( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * http_method, + const axis2_char_t * http_location); + + + /** + * Gets the RESTful operation map for a given service + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to hash with the information + * (method, url)=> processing structure for each ops + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_svc_get_rest_map( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Gets operation corresponding to the name. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param op_name operation name string + * @return pointer to operation corresponding to given name + */ + AXIS2_EXTERN struct axis2_op *AXIS2_CALL + axis2_svc_get_op_with_name( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * op_name); + + /** + * Gets all operations of service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to hash map containing all operations of the service + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_svc_get_all_ops( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Sets parent which is of type service group. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param svc_grp pointer to parent service group + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_parent( + axis2_svc_t * svc, + const axutil_env_t * env, + struct axis2_svc_grp *svc_grp); + + /** + * Gets parent which is of type service group. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to parent service group + */ + AXIS2_EXTERN struct axis2_svc_grp *AXIS2_CALL + axis2_svc_get_parent( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Sets QName. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param qname pointer to QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_qname( + axis2_svc_t * svc, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Gets QName. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to QName + */ + AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL + axis2_svc_get_qname( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Adds given parameter to operation. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param param pointer to parameter, service assumes ownership of + * parameter + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_add_param( + axis2_svc_t * svc, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets named parameter. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param name name string + * @return pointer to named parameter if exists, else NULL. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_svc_get_param( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Remove a parameter. + * @param svc pointer to service struct + * @param env pointer to the environment + * @Param param_name parameter name to be removed + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_remove_param( + const axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_char_t *param_name); + + /** + * Gets all parameters stored within service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to array list of parameters, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_svc_get_all_params( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Checks if the named parameter is locked. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param param_name parameter name + * @return AXIS2_TRUE if the named parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_svc_is_param_locked( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Engages given module to service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param module_desc pointer to module description to be engaged, + * service does not assume the ownership of module + * @param conf pointer to configuration, it is configuration that holds + * module information + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_engage_module( + axis2_svc_t * svc, + const axutil_env_t * env, + struct axis2_module_desc *module_desc, + struct axis2_conf *conf); + + /** + * Disengages given module from service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param module_desc pointer to module description to be engaged, + * service does not assume the ownership of module + * @param conf pointer to configuration, it is configuration that holds + * module information + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_disengage_module( + axis2_svc_t * svc, + const axutil_env_t * env, + struct axis2_module_desc *module_desc, + struct axis2_conf *conf); + + /** + * Check whether a given module is engaged to the service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param module_qname pointer to module qname to be engaged, + * @return AXIS2_TRUE if module is engaged, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_svc_is_module_engaged( + axis2_svc_t * svc, + const axutil_env_t * env, + axutil_qname_t * module_qname); + + /** + * Return the engaged module list. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return engaged module list + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_svc_get_engaged_module_list( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Adds operations defined in a module to this service. It is possible + * to define operations that are associated to a module in a module.xml + * file. These operations in turn could be invoked in relation to a + * service. This method allows those module related operation to be + * added to a service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param module_desc pointer to module description containing module + * related operation information. service does not assume the ownership + * of module description + * @param conf pointer to configuration, it is configuration that stores + * the modules + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_add_module_ops( + axis2_svc_t * svc, + const axutil_env_t * env, + struct axis2_module_desc *module_desc, + struct axis2_conf *axis2_config); + + /** + * Adds given module description to engaged module list. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param module_desc pointer to module description, service does not + * assume the ownership of module description + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /*AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_add_to_engaged_module_list(axis2_svc_t *svc, + const axutil_env_t *env, + struct axis2_module_desc *module_desc); */ + + /** + * Gets all engaged modules. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to array list containing all engaged modules + */ + /*AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_svc_get_all_engaged_modules(const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets style. Style can be either RPC or document literal. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param style style of service as defined in WSDL + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_style( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * style); + + /** + * Gets style. Style can be either RPC or document literal. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return string representing the style of service + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_get_style( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Gets in flow. In flow is the list of phases invoked + * along in path. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to flow representing in flow + */ + /*AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_svc_get_in_flow(const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets in flow. In flow is the list of phases invoked + * along in path. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param in_flow pointer to flow representing in flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /*AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_in_flow(axis2_svc_t *svc, + const axutil_env_t *env, + struct axis2_flow *in_flow); */ + + /** + * Gets out flow. Out flow is the list of phases invoked + * along out path. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to flow representing out flow + */ + /*AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_svc_get_out_flow( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets out flow. Out flow is the list of phases invoked + * along out path. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return out_flow pointer to flow representing out flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /*AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_out_flow( + axis2_svc_t *svc, + const axutil_env_t *env, + struct axis2_flow *out_flow); */ + + /** + * Gets fault in flow. Fault in flow is the list of phases invoked + * along in path if a fault happens. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to flow representing fault in flow + */ + /*AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_svc_get_fault_in_flow( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets fault in flow. Fault in flow is the list of phases invoked + * along in path if a fault happens. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param fault_flow pointer to flow representing fault in flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /*AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_fault_in_flow( + axis2_svc_t *svc, + const axutil_env_t *env, + struct axis2_flow *fault_flow); */ + + /** + * Gets fault out flow. Fault out flow is the list of phases invoked + * along out path if a fault happens. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to flow representing fault out flow + */ + /*AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_svc_get_fault_out_flow( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets fault out flow. Fault out flow is the list of phases invoked + * along out path if a fault happens. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param fault_flow pointer to flow representing fault out flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /*AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_fault_out_flow( + axis2_svc_t *svc, + const axutil_env_t *env, + struct axis2_flow *fault_flow); */ + + /** + * Gets operation corresponding to given SOAP Action. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param soap_action SOAP action string + * @return pointer to operation corresponding to given SOAP action if + * one exists, else NULL. Returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_op *AXIS2_CALL + axis2_svc_get_op_by_soap_action( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * soap_action); + + /** + * Gets operation corresponding to given SOAP Action and endpoint QName. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param soap_action SOAP action string + * @param endpoint pointer QName representing endpoint URI + * @return pointer operation corresponding to given SOAP Action and + * endpoint QName. + */ + /*AXIS2_EXTERN struct axis2_op *AXIS2_CALL + + axis2_svc_get_op_by_soap_action_and_endpoint( + const axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_char_t *soap_action, + const axutil_qname_t *endpoint); */ + + /** + * Gets service name. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return service name string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_get_name( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Sets service name. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param svc_name service name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_name( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + /** + * Sets current time as last update time of the service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_last_update( + axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Gets last update time of the service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return last updated time in seconds + */ + AXIS2_EXTERN long AXIS2_CALL + axis2_svc_get_last_update( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Get the description of the services, which is in the + * service.xml, tag + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return services description string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_get_svc_desc( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Set the description of the service which is in service.xml + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_svc_desc( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * svc_desc); + + /** + * Get the static wsdl file of the services, which is in the + * service.xml, wsdl_path parameter + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return static wsdl file location + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_get_svc_wsdl_path( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Set the wsdl path of the service which is in service.xml + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_svc_wsdl_path( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * wsdl_path); + + /** + * Get the folder path on disk of the services, which is in the + * service.xml + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return folder path on disk + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_get_svc_folder_path( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Set the folder path of the service which is in service.xml + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_svc_folder_path( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * folder_path); + + /** + * Gets the name of the file that holds the implementation of the + * service. service implementation is compiled into shared libraries + * and is placed in the respective sub folder in the services folder + * of Axis2 repository. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return file name string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_get_file_name( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Sets the name of the file that holds the implementation of the + * service. service implementation is compiled into shared libraries + * and is placed in the respective sub folder in the services folder + * of Axis2 repository. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param file_name file name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_file_name( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * file_name); + + /** + * Gets all endpoints associated with the service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to hash map containing all endpoints + */ + /*AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + + axis2_svc_get_all_endpoints( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets the list of endpoints associated with the service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param endpoints pointer to hash map containing all endpoints + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /*AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_all_endpoints( + axis2_svc_t *svc, + const axutil_env_t *env, + axutil_hash_t *endpoints); */ + + /** + * Gets namespace. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return namespace URI string + */ + /*AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_svc_get_namespace( + const axis2_svc_t *svc, + const axutil_env_t *env); + */ + + /** + * Adds WS-Addressing mapping for a given operation. The services.xml + * configuration file could specify a SOAP action that would map to + * one of the service operations. This method could be used to register + * that mapping against operations. WS-Addressing based dispatcher + * makes use of this mapping to identify the operation to be invoked, + * given WSA action. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param wsa_action WSA action string + * @param op pointer to operation that maps to the given WSA action + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_add_mapping( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * wsa_action, + struct axis2_op *axis2_op); + + /** + * Adds a REST mapping for a given RESTful operation. The services.xml + * configuration file could specify a HTTP Method and Location that would + * map to one of the service operations. This method could be used to register + * that mapping against operations. The REST based dispatcher makes use + * of this mapping to identify the operation to be invoked, given the URL. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param method REST HTTP Method + * @param location REST HTTP Location + * @param op pointer to operation that maps to the given WSA action + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_add_rest_mapping( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * method, + const axis2_char_t * location, + struct axis2_op *axis2_op); + + /** + * Adds a module qname to list of module QNames associated with service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param module_qname pointer to QName to be added, this method clones + * the QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_add_module_qname( + axis2_svc_t * svc, + const axutil_env_t * env, + const axutil_qname_t * module_qname); + + /** + * Gets all module QNames associated with the service as a list. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to array list containing QNames + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_svc_get_all_module_qnames( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Checks if the XML schema location is adjusted. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return AXIS2_TRUE if XML schema is adjusted, else AXIS2_FALSE + */ + /*AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_svc_is_schema_location_adjusted( + axis2_svc_t *svc, + const axutil_env_t *env); + */ + + /** + * Sets the bool value indicating if the XML schema location is adjusted. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param adjusted AXIS2_TRUE if XML schema is adjusted, else AXIS2_FALSE + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_schema_location_adjusted( + axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_bool_t adjusted); */ + + /** + * Gets XML schema mapping table for service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to hash map with XML schema mappings, returns a + * reference, not a cloned copy + */ + /* + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + + axis2_svc_axis2_svc_get_schema_mapping_table( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets XML schema mapping table for service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param table pointer to hash map with XML schema mappings, service + * assumes ownership of the map + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_schema_mapping_table( + axis2_svc_t *svc, + const axutil_env_t *env, + axutil_hash_t *table); */ + + /** + * Gets custom schema prefix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return custom schema prefix string + */ + /* + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_svc_get_custom_schema_prefix( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets custom schema prefix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param prefix custom schema prefix string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_custom_schema_prefix( + axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_char_t *prefix); */ + + /** + * Gets custom schema suffix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return custom schema suffix string + */ + /* + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_svc_get_custom_schema_suffix( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets custom schema suffix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param suffix custom schema suffix string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_custom_schema_suffix( + axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_char_t *suffix); */ + + /** + * Prints the schema to given stream. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param out_stream stream to print to + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_print_schema( + axis2_svc_t *svc, + const axutil_env_t *env, + axutil_stream_t *out_stream); */ + + /** + * Gets the XML schema at the given index of XML schema array list. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param index index of the XML schema to be retrieved + * @return pointer to XML schema, returns a reference, not a cloned copy + */ + /*AXIS2_EXTERN xml_schema_t *AXIS2_CALL + + axis2_svc_get_schema( + const axis2_svc_t *svc, + const axutil_env_t *env, + const int index); */ + + /** + * Adds all namespaces in the namespace map to the XML schema at + * the given index of the XML schema array list. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param index index of the XML schema to be processed + * @return pointer to XML schema with namespaces added, + * returns a reference, not a cloned copy + */ + + /* AXIS2_EXTERN xml_schema_t *AXIS2_CALL + + axis2_svc_add_all_namespaces( + axis2_svc_t *svc, + const axutil_env_t *env, + int index);*/ + + /** + * Gets the list of XML schemas associated with service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to array list of XML schemas, returns a reference, + * not a cloned copy + */ + /* + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_svc_get_all_schemas( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Adds the given XML schema to the list of XML schemas associated + * with the service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param schema pointer to XML schema struct, service assumes the + * ownership of struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_add_schema( + axis2_svc_t *svc, + const axutil_env_t *env, + xml_schema_t *schema); */ + + /** + * Adds the list of all XML schemas to service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param schemas pointer to array list containing XML schemas + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_add_all_schemas( + axis2_svc_t *svc, + const axutil_env_t *env, + axutil_array_list_t *schemas); */ + + /** + * Gets XML schema's target namespace. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return XML schema target namespace string + */ + /* + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_svc_get_schema_target_ns( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets XML schema's target namespace. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param ns namespace string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_schema_target_ns( + axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_char_t *ns); */ + + /** + * Gets XML schema's target namespace prefix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return XML schema target namespace prefix string + */ + /* + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_svc_get_schema_target_ns_prefix( + const axis2_svc_t *svc, + const axutil_env_t *env); */ + + /** + * Sets XML schema's target namespace prefix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param prefix namespace prefix string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /* + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_set_schema_target_ns_prefix( + axis2_svc_t *svc, + const axutil_env_t *env, + const axis2_char_t *prefix); */ + + /** + * Gets target namespace. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return target namespace as a string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_get_target_ns( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Sets target namespace. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param ns target namespace as a string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + saxis2_svc_et_target_ns( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * ns); + + /** + * Gets target namespace prefix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return target namespace prefix string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_svc_get_target_ns_prefix( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Sets target namespace prefix. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param prefix target namespace prefix string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_target_ns_prefix( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * prefix); + + /** + * Gets XML schemas element corresponding to the given QName. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param qname QName of the XML schema element to be retrieved + * @return pointer to XML schema element, returns a reference, not a + * cloned copy + */ + /*AXIS2_EXTERN xml_schema_element_t *AXIS2_CALL + + axis2_svc_get_schema_element( + const axis2_svc_t *svc, + const axutil_env_t *env, + const axutil_qname_t *qname); */ + + /** + * Gets the namespace map with all namespaces related to service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return pointer to hash map containing all namespaces, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + gaxis2_svc_et_ns_map( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Sets the namespace map with all namespaces related to service. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @param ns_map pointer to hash map containing all namespaces + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_ns_map( + axis2_svc_t * svc, + const axutil_env_t * env, + axutil_hash_t * ns_map); + + /** + * Populates the schema mappings. This method is used in code generation + * and WSDL generation (WSDL2C and C2WSDL). This method deals with the + * imported schemas that would be there in the WSDL. + * @param svc pointer to service struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + /*AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_populate_schema_mappings( + axis2_svc_t *svc, + const axutil_env_t *env); */ + + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + + axis2_svc_get_param_container( + const axis2_svc_t * svc, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL + + axis2_svc_get_flow_container( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /** + * Creates a service struct instance. + * @param env pointer to environment struct + * @return pointer to newly created service + */ + AXIS2_EXTERN axis2_svc_t *AXIS2_CALL + axis2_svc_create( + const axutil_env_t * env); + + /** + * Creates a service struct with given QName. + * @param env pointer to environment struct + * @param qname service QName + * @return pointer to newly created service + */ + AXIS2_EXTERN axis2_svc_t *AXIS2_CALL + axis2_svc_create_with_qname( + const axutil_env_t * env, + const axutil_qname_t * qname); + + AXIS2_EXTERN void *AXIS2_CALL + axis2_svc_get_impl_class( + const axis2_svc_t * svc, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_set_impl_class( + axis2_svc_t * svc, + const axutil_env_t * env, + void *impl_class); + + /** + * Gets base description. + * @param svc pointer to message + * @param env pointer to environment struct + * @return pointer to base description struct + */ + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_svc_get_base( + const axis2_svc_t * svc, + const axutil_env_t * env); + + /* Get the mutex associated with this service + * @param svc pointer to message + * @param env pointer to environment struct + * @return pointer to a axutil_thread_mutext_t + */ + AXIS2_EXTERN axutil_thread_mutex_t * AXIS2_CALL + axis2_svc_get_mutex( + const axis2_svc_t * svc, + const axutil_env_t * env); + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SVC_H */ diff --git a/include/axis2_svc_client.h b/include/axis2_svc_client.h new file mode 100644 index 0000000..eb13c66 --- /dev/null +++ b/include/axis2_svc_client.h @@ -0,0 +1,642 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_SVC_CLIENT_H +#define AXIS2_SVC_CLIENT_H + +/** + * @defgroup axis2_svc_client service client + * @ingroup axis2_client_api + * The service client interface serves as the primary client + * interface for consuming services. You can set the options to be + * used by the service client and then invoke an operation on a given + * service. There are several ways of invoking a service operation, + * which are based on the concept of a message exchange pattern + * (MEP). The two basic MEPs supported by service client are out-only + * and out-in. Each MEP can be used in either blocking or + * non-blocking mode. The operation invocations using the service + * client API are based on the XML-in/XML-out principle: both the + * payload to be sent to the service and the result from the service + * are in XML, represented in AXIOM. + * @{ + */ + +/** + * @file axis2_svc_client.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc_client */ + typedef struct axis2_svc_client axis2_svc_client_t; + + /** + * Returns the axis2_svc_t this is a client for. This is primarily + * useful when the service is created anonymously or from WSDL. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return a pointer to axis service struct, or NULL if no service + * is associated. Returns a reference, not a cloned copy. + */ + AXIS2_EXTERN axis2_svc_t *AXIS2_CALL + axis2_svc_client_get_svc( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Returns the axis2_conf_ctx_t. This is useful when creating service clients using + * the same configuration context as the original service client. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return a pointer to axis configuration context struct, or NULL. + * Returns a reference, not a cloned copy. + */ + AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL + axis2_svc_client_get_conf_ctx( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Sets the options to be used by service client. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param options pointer to options struct to be set + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_set_options( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axis2_options_t * options); + + /** + * Gets options used by service client. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return a pointer to the options struct if options set, else NULL. + * Returns a reference, not a cloned copy. + */ + AXIS2_EXTERN const axis2_options_t *AXIS2_CALL + axis2_svc_client_get_options( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Sets the overriding options. The overriding client options related + * to this service interaction override any options that the + * underlying operation client may have. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param options pointer to options struct to be set + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_set_override_options( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axis2_options_t * override_options); + + /** + * Gets the overriding options. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return pointer to overriding options struct if options set, else NULL. + * Returns a reference, not a cloned copy. + */ + AXIS2_EXTERN const axis2_options_t *AXIS2_CALL + axis2_svc_client_get_override_options( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Engages the named module. The engaged modules extend the message + * processing when consuming services. Modules help to apply QoS + * norms in messaging. Once a module is engaged to a service client, + * the axis2_engine makes sure to invoke the module for all the + * interactions between the client and the service. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param module_name name of the module to be engaged + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_engage_module( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axis2_char_t * module_name); + + /** + * Dis-engages the named module. Dis-engaging a module on a service + * client ensures that the axis2_engine would not invoke the named + * module when sending and receiving messages. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param module_name name of the module to be dis-engaged + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_disengage_module( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axis2_char_t * module_name); + + /** + * Adds an XML element as a header to be sent to the server side. + * This allows users to go beyond the usual XML-in/XML-out pattern, + * and send custom SOAP headers. Once added, service client owns + * the header and will clean up when the service client is freed. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param header om node representing the SOAP header in XML + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_add_header( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + axiom_node_t * header); + + /** + * Removes all the headers added to service client. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_remove_all_headers( + axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * This method can be used to send an XML message. + * This is a simple method to invoke a service operation whose MEP is + * Robust Out-Only. If a fault triggers on server side, this method + * would report an error back to the caller. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param op_qname operation qname. NULL is equivalent to an + * operation name of "__OPERATION_ROBUST_OUT_ONLY__" + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_send_robust_with_op_qname( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axutil_qname_t * op_qname, + const axiom_node_t * payload); + + /** + * This method can be used to send an XML message. + * This is a simple method to invoke a service operation whose MEP is + * Robust Out-Only. If a fault triggers on server side, this method + * would report an error back to the caller. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * operation name of "__OPERATION_ROBUST_OUT_ONLY__" + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_send_robust( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axiom_node_t * payload); + + /** + * Sends a message and forget about it. This method is used to interact with + * a service operation whose MEP is In-Only. That is, there is no + * opportunity to get an error from the service via this method; one may still + * get client-side errors, such as host unknown etc. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param op_qname operation qname. NULL is equivalent to an + * operation name of "__OPERATION_OUT_ONLY__" + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_client_fire_and_forget_with_op_qname( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axutil_qname_t * op_qname, + const axiom_node_t * payload); + + /** + * Sends a message and forget about it. This method is used to interact with + * a service operation whose MEP is In-Only. That is, there is no + * opportunity to get an error from the service via this method; one may still + * get client-side errors, such as host unknown etc. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_client_fire_and_forget( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axiom_node_t * payload); + + /** + * Sends XML request and receives XML response. + * This method is used to interact with a service operation whose MEP is In-Out. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param op_qname operation qname. NULL is equivalent to an + * operation name of "__OPERATION_OUT_IN__" + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + * @return pointer to OM node representing the XML response. The + * caller owns the returned node. + */ + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + axis2_svc_client_send_receive_with_op_qname( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axutil_qname_t * op_qname, + const axiom_node_t * payload); + + /** + * Sends XML request and receives XML response. + * This method is used to interact with a service operation whose MEP is In-Out. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + * @return pointer to OM node representing the XML response. The + * caller owns the returned node. + */ + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + axis2_svc_client_send_receive( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axiom_node_t * payload); + + /** + * Sends XML request and receives XML response, but does not block for response. + * This method is used to interact in non-blocking mode with a service + * operation whose MEP is In-Out. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param op_qname operation qname. NULL is equivalent to an + * operation name of "__OPERATION_OUT_IN__" + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + * @callback pointer to callback struct used to capture response + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_client_send_receive_non_blocking_with_op_qname( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axutil_qname_t * op_qname, + const axiom_node_t * payload, + axis2_callback_t * callback); + + /** + * Sends XML request and receives XML response, but does not block for response. + * This method is used to interact in non-blocking mode with a service + * operation whose MEP is In-Out. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param payload pointer to OM node representing the XML payload to be sent. + * The caller has control over the payload until the service client frees it. + * @callback pointer to callback struct used to capture response + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_client_send_receive_non_blocking( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axiom_node_t * payload, + axis2_callback_t * callback); + + /** + * Creates an op_client for a specific operation. This is the way to + * create a full functional MEP client which can be used to exchange + * messages for this specific operation. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param op_qname axutil_qname_t of the operation + * @return pointer to newly created op_client configured for the given operation + */ + AXIS2_EXTERN axis2_op_client_t *AXIS2_CALL + axis2_svc_client_create_op_client( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axutil_qname_t * op_qname); + + /** + * Cleans up service client invocation. This will close the output + * stream and/or remove entry from waiting queue of the transport + * listener queue. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_finalize_invoke( + axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Gets the service client's own endpoint_ref, that is the + * endpoint the client will be sending from. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param transport name of the transport, e.g "http" + * @return pointer to the endpoint_ref struct. Returns a reference, + * not a cloned copy. + */ + AXIS2_EXTERN const axis2_endpoint_ref_t *AXIS2_CALL + axis2_svc_client_get_own_endpoint_ref( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env, + const axis2_char_t * transport); + + /** + * Gets the target endpoint ref. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return pointer to the endpoint_ref struct. Returns a reference, + * not a cloned copy. + */ + AXIS2_EXTERN const axis2_endpoint_ref_t *AXIS2_CALL + axis2_svc_client_get_target_endpoint_ref( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Sets the target endpoint ref. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param target_epr pointer to the endpoint_ref struct to be set as + * target. service client takes over the ownership of the struct. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_set_target_endpoint_ref( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + axis2_endpoint_ref_t * target_epr); + + /** + * Sets the proxy with authentication support. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param proxy_host pointer to the proxy_host settings to be set + * @param proxy_port pointer to the proxy_port settings to be set + * @param username pointer to the username associated with proxy + * which is required for authentication + * @param password pointer to the password associated with proxy + * which is required for authentication + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_set_proxy_with_auth( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + axis2_char_t * proxy_host, + axis2_char_t * proxy_port, + axis2_char_t * username, + axis2_char_t * password); + + /** + * Sets the proxy. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @param proxy_host pointer to the proxy_host settings to be set + * @param proxy_port pointer to the proxy_port settings to be set + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_set_proxy( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + axis2_char_t * proxy_host, + axis2_char_t * proxy_port); + + /** + * Gets the service context. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return pointer to service context struct. service client owns + * the returned pointer. + */ + AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL + axis2_svc_client_get_svc_ctx( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Frees the service client. + * @param svc_client pointer to service client struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_client_free( + axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Gets the operation client + * @param svc_client pointer to service_client struct + * @param env env pointer to environment struct + * @return pointer to service context struct. service client owns + * the returned pointer + */ + AXIS2_EXTERN axis2_op_client_t *AXIS2_CALL + axis2_svc_client_get_op_client( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Creates a service client struct. + * @param env pointer to environment struct + * @param client_home name of the directory that contains the Axis2/C repository + * @return a pointer to newly created service client struct, + * or NULL on error with error code set in environment's error + */ + AXIS2_EXTERN axis2_svc_client_t *AXIS2_CALL + axis2_svc_client_create( + const axutil_env_t * env, + const axis2_char_t * client_home); + + /** + * Creates a service client struct for a specified service and configuration + * context. + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context. Newly created client + * assumes ownership of the conf_ctx + * @param svc pointer to service struct representing the service to be consumed. + * Newly created client assumes ownership of the service + * @param client_home name of the directory that contains the Axis2/C repository + * @return a pointer to newly created service client struct, + * or NULL on error with error code set in environment's error + */ + AXIS2_EXTERN axis2_svc_client_t *AXIS2_CALL + axis2_svc_client_create_with_conf_ctx_and_svc( + const axutil_env_t * env, + const axis2_char_t * client_home, + axis2_conf_ctx_t * conf_ctx, + axis2_svc_t * svc); + + /** + * Gets the last response SOAP envelope. + * @param svc_client pointer to service_client struct + * @param env env pointer to environment struct + * @return pointer to SOAP envelope that was returned as a result + * when send_receieve was called last time + */ + AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL + axis2_svc_client_get_last_response_soap_envelope( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Gets the boolean value indicating if the last response had a SOAP fault. + * @param svc_client pointer to service_client struct + * @param env env pointer to environment struct + * @return AXIS2_TRUE if there was a fault, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_svc_client_get_last_response_has_fault( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Gets the authentication type required. + * @param svc_client pointer to service_client struct + * @param env env pointer to environment struct + * @return AXIS2_TRUE if the operation succeeded, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_svc_client_get_auth_type( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Gets the boolean value indicating whether HTTP Authentication + * is required. + * @param svc_client pointer to service_client struct + * @param env env pointer to environment struct + * @return AXIS2_TRUE if Authentication is required, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_svc_client_get_http_auth_required( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Gets the boolean value indicating whether Proxy Authentication + * is required. + * @param svc_client pointer to service_client struct + * @param env env pointer to environment struct + * @return AXIS2_TRUE if Authentication is required, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_svc_client_get_proxy_auth_required( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Create a policy object and set it to the description hierarchy + * @param svc_client pointer to service_client struct + * @param env pointer to environment struct + * @param root_node pointer to a policy node + * @return AXIS2_FAILURE if there was a fault, else AXIS2_SUCCESS + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_set_policy_from_om( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + axiom_node_t * root_node); + + /** + * Set the given policy object to the description hierarchy + * @param svc_client pointer to service_client struct + * @param env pointer to environment struct + * @param policy neethi_policy_t to a policy struct + * @return AXIS2_FAILURE if there was a fault, else AXIS2_SUCCESS + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_set_policy( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + neethi_policy_t * policy); + + /** + * Gets the HTTP Headers of the last response. + * @param svc_client pointer to service_client struct + * @param env pointer to environment struct + * @return list of HTTP Response Headers + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + axis2_svc_client_get_http_headers( + axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Gets the HTTP Status Code of the last response. + * @param svc_client pointer to service_client struct + * @param env pointer to environment struct + * @return HTTP Status Code + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_svc_client_get_http_status_code( + axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** + * Close the service client. + * @param svc_client pointer to service_client struct + * @param env pointer to environment struct + * @return AXIS2_FAILURE if there was a fault, else AXIS2_SUCCESS + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_client_close( + axis2_svc_client_t * svc_client, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SVC_CLIENT_H */ diff --git a/include/axis2_svc_ctx.h b/include/axis2_svc_ctx.h new file mode 100644 index 0000000..c88d2f4 --- /dev/null +++ b/include/axis2_svc_ctx.h @@ -0,0 +1,196 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_SVC_CTX_H +#define AXIS2_SVC_CTX_H + +/** + * @defgroup axis2_svc_ctx service context + * @ingroup axis2_context + * service context represents a running "instance" of a service. + * service context allows instance of operations belonging to a service to be + * grouped. + * @{ + */ + +/** + * @file axis2_svc_ctx.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc_ctx */ + typedef struct axis2_svc_ctx axis2_svc_ctx_t; + + /** + * Creates a service context struct that corresponds to the given service + * and with the given parent service group context. + * @param env pointer to environment struct + * @param svc pointer to service that this service context represents, + * service context does not assume the ownership of service + * @param svc_grp_ctx pointer to service group context, the parent of the + * newly created service context. service context does not assume the + * ownership of parent + * @return pointer to newly created service context + */ + AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL + axis2_svc_ctx_create( + const axutil_env_t * env, + struct axis2_svc *svc, + struct axis2_svc_grp_ctx *svc_grp_ctx); + + /** + * Gets base which is of type context. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @return pointer to context, returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL + axis2_svc_ctx_get_base( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env); + + /** + * Gets parent which is of type service group context. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @return pointer to parent service group context + */ + AXIS2_EXTERN struct axis2_svc_grp_ctx *AXIS2_CALL + axis2_svc_ctx_get_parent( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env); + + /** + * Sets parent which is of type service group context. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @param parent parent of service context which is of type + * service group context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_ctx_set_parent( + axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env, + struct axis2_svc_grp_ctx *parent); + + /** + * Frees service context instance. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_ctx_free( + struct axis2_svc_ctx *svc_ctx, + const axutil_env_t * env); + + /** + * Initializes service context. This method locates the corresponding + * service that is related to the service context from configuration + * using service qname and keeps a reference to it for future use. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @param conf pointer to configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_ctx_init( + struct axis2_svc_ctx *svc_ctx, + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Gets the ID of the service that this service context is an instance + * of. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @return service ID string. + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_ctx_get_svc_id( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env); + + /** + * Gets the service that this service context represents. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @return pointer to service, returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_svc_ctx_get_svc( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env); + + /** + * Sets the service that this service context represents. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @param svc pointer to service struct, service context does not assume + * the ownership of the struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_ctx_set_svc( + axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env, + struct axis2_svc *svc); + + /** + * Gets configuration context which is the super root (super most parent) + * of the context hierarchy to which this service context belongs. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @return pointer to configuration context + */ + AXIS2_EXTERN struct axis2_conf_ctx *AXIS2_CALL + axis2_svc_ctx_get_conf_ctx( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env); + + /** + * Creates an operation context for the named operation. The named + * operation should be one of the operations in the service related + * to this service context. + * @param svc_ctx pointer to service context + * @param env pointer to environment struct + * @param qname pointer to qname that represents the operation name. + * @return pointer to operation context + */ + AXIS2_EXTERN struct axis2_op_ctx *AXIS2_CALL + axis2_svc_ctx_create_op_ctx( + struct axis2_svc_ctx *svc_ctx, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SVC_CTX_H */ diff --git a/include/axis2_svc_grp.h b/include/axis2_svc_grp.h new file mode 100644 index 0000000..4f05296 --- /dev/null +++ b/include/axis2_svc_grp.h @@ -0,0 +1,368 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_SVC_GRP_H +#define AXIS2_SVC_GRP_H + +/** + * @defgroup axis2_svc_grp service group + * @ingroup axis2_desc + * service group represents the static structure of a service group in + * the Axis2 configuration. + * In Axis2 description hierarchy, a service group lives inside the + * configuration. service groups are configured in services.xml files located + * in the respective service group folders of the services folder in the repository. + * In services.xml file, services groups are declared at top level. + * A service group can have one or more services associated with it. + * Sometimes services.xml would not have a service group defined, but only a + * service. In such cases a service group with the same name as that of the + * service mentioned in services.xml would be created by the deployment + * engine and the service would be associated with that newly created service + * group. The deployment engine would create service group instances to represent + * those configured service groups in services.xml files and would store + * them in the configuration. + * service group encapsulates data on engaged module information and the + * service associated with service group. + * @{ + */ + +/** + * @file axis2_svc_grp.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc_grp */ + typedef struct axis2_svc_grp axis2_svc_grp_t; + + struct axis2_svc; + struct axis2_svc_grp_ctx; + + /** + * Frees service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_grp_free( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Sets service group name. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param svc_grp_name service group name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_set_name( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axis2_char_t * svc_grp_name); + + /** + * Gets service group name. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @return service group name string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_grp_get_name( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Adds given service to service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param service service to be added, service group assumes ownership + * of service + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_add_svc( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + struct axis2_svc *svc); + + /** + * Gets named service from service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param svc_qname pointer to QName of the service + * @return pointer to service corresponding to given QName, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_svc_grp_get_svc( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axutil_qname_t * svc_qname); + + /** + * Gets all services associated with service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @return pointer to hash table containing all services, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_svc_grp_get_all_svcs( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Removes named service from service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param svc_name pointer to service QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_remove_svc( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axutil_qname_t * svc_qname); + + /** + * Adds parameter. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param param pointer to parameter, service group assumes ownership + * of parameter + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_add_param( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets named parameter. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param name parameter name + * @return pointer to named parameter if exists, else NULL. Returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + axis2_svc_grp_get_param( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axis2_char_t * name); + + /** + * Remove a parameter. + * @param svc_grp pointer to service grp struct + * @param env pointer to the environment + * @Param param_name parameter name to be removed + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_remove_param( + const axis2_svc_grp_t *svc_grp, + const axutil_env_t *env, + const axis2_char_t *param_name); + + /** + * Gets all parameters set on service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @return pointer to array list containing parameter, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_svc_grp_get_all_params( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Checks if the named parameter is locked. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param param_name pointer to param name + * @return AXIS2_TRUE if the named parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_svc_grp_is_param_locked( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Adds given module QName to list of module QNames. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param module_name pointer to module QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_add_module_qname( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axutil_qname_t * module_qname); + + /** + * Gets parent which is of type configuration. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @return pointer to parent configuration, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_svc_grp_get_parent( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Sets parent which is of type configuration. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param parent parent configuration, service group does not assume + * the ownership of configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_set_parent( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + struct axis2_conf *parent); + + /** + * Engages named module to service group. Engaging a module to service + * group would ensure that the same module would be engaged to all + * services within the group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param module_name pointer to module QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_engage_module( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axutil_qname_t * module_qname); + + /** + * Gets all module QNames associated with service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @return pointer to array list containing all QNames, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_svc_grp_get_all_module_qnames( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Adds module reference. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param moduleref pointer to module QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_add_module_ref( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axutil_qname_t * moduleref); + + /** + * Gets all module references. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @return pointer to array list containing module reference, returns + * a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_svc_grp_get_all_module_refs( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Gets service group context related to this service group. + * @param svc_grp pointer to service group struct + * @param env pointer to environment struct + * @param parent pointer to configuration context which is the parent of + * the context hierarchy + * @return pointer to service group context related to this service + * group, returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_svc_grp_ctx *AXIS2_CALL + + axis2_svc_grp_get_svc_grp_ctx( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + struct axis2_conf_ctx *parent); + + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + + axis2_svc_grp_get_param_container( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + + /** + * Creates a service group struct instance. + * @param env pointer to environment struct + * @return pointer to newly created service group + */ + AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL + axis2_svc_grp_create( + const axutil_env_t * env); + + /** + * Creates service group with given configuration as the parent. + * @param env pointer to environment struct + * @param conf pointer to configuration, service group created does not + * assume ownership of configuration + * @return pointer to newly created service group + */ + AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL + axis2_svc_grp_create_with_conf( + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Gets base description. + * @param svc_grp pointer to message + * @param env pointer to environment struct + * @return pointer to base description struct + */ + AXIS2_EXTERN axis2_desc_t *AXIS2_CALL + axis2_svc_grp_get_base( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SVC_GRP_H */ diff --git a/include/axis2_svc_grp_ctx.h b/include/axis2_svc_grp_ctx.h new file mode 100644 index 0000000..0ae9c96 --- /dev/null +++ b/include/axis2_svc_grp_ctx.h @@ -0,0 +1,194 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_SVC_GRP_CTX_H +#define AXIS2_SVC_GRP_CTX_H + +/** + * @defgroup axis2_svc_grp_ctx service group context + * @ingroup axis2_context + * service group context represents a running "instance" of a service group. + * service group context allows instance of services belonging to a service + * group to be grouped. + * @{ + */ + +/** + * @file axis2_svc_grp_ctx.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_svc_grp; + + /** Type name for struct svc_grp_ctx */ + typedef struct axis2_svc_grp_ctx axis2_svc_grp_ctx_t; + + /** + * Creates a service group context struct. + * @param env pointer to environment struct + * @param svc_grp pointer to service group that this service context + * represents, service group context does not assume the ownership of the struct + * @param conf_ctx pointer to configuration context, the parent context + * of the newly created service group context, service group context does not + * assume the ownership of the struct + * @return pointer to newly created service group context + */ + AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL + axis2_svc_grp_ctx_create( + const axutil_env_t * env, + struct axis2_svc_grp *svc_grp, + struct axis2_conf_ctx *conf_ctx); + + /** + * Gets base which is of type context. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment + * @return pointer to base context struct, returns a reference not a + * cloned copy + */ + AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL + axis2_svc_grp_ctx_get_base( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env); + + /** + * Gets parent. configuration context is the parent of any service group + * context instance. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @return pointer to configuration context, parent of service group + */ + AXIS2_EXTERN struct axis2_conf_ctx *AXIS2_CALL + axis2_svc_grp_ctx_get_parent( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env); + + /** + * Frees service group context. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_grp_ctx_free( + struct axis2_svc_grp_ctx *svc_grp_ctx, + const axutil_env_t * env); + + /** + * Initializes service group context. In this method, it pics the + * related service group from configuration and keeps a reference + * for future use. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @param conf pointer to configuration + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_ctx_init( + struct axis2_svc_grp_ctx *svc_grp_ctx, + const axutil_env_t * env, + struct axis2_conf *conf); + + /** + * Gets service group context ID. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @return service group context ID string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_grp_ctx_get_id( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env); + + /** + * Sets service group context ID. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @param id service group context ID + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_ctx_set_id( + struct axis2_svc_grp_ctx *svc_grp_ctx, + const axutil_env_t * env, + const axis2_char_t * id); + + /** + * Gets named service context. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @param svc_name name of service context to be retrieved + * @return pointer to named service context + */ + AXIS2_EXTERN struct axis2_svc_ctx *AXIS2_CALL + axis2_svc_grp_ctx_get_svc_ctx( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + /** + * Fills service context map. This will create one service context per + * each service in the service group related to this service context. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_grp_ctx_fill_svc_ctx_map( + struct axis2_svc_grp_ctx *svc_grp_ctx, + const axutil_env_t * env); + + /** + * Gets service group related to this service context. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @return pointer to service group that this service group context + * represents + */ + AXIS2_EXTERN struct axis2_svc_grp *AXIS2_CALL + axis2_svc_grp_ctx_get_svc_grp( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env); + + /** + * Gets service context map containing all service contexts. + * @param svc_grp_ctx pointer to service group context + * @param env pointer to environment struct + * @return pointer to hash table containing the service context map + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_svc_grp_ctx_get_svc_ctx_map( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SVC_GRP_CTX_H */ diff --git a/include/axis2_svc_name.h b/include/axis2_svc_name.h new file mode 100644 index 0000000..72422bb --- /dev/null +++ b/include/axis2_svc_name.h @@ -0,0 +1,135 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_SVC_NAME_H +#define AXIS2_SVC_NAME_H + +/** + * @defgroup axis2_svc_name service name + * @ingroup axis2_addr + * service name provides a full description of the service endpoint. service + * name contains a QName identifying the WSDL service element that contains + * the definition of the endpoint being conveyed. It also contains an optional + * non-qualified name that identifies the specific port in the service that + * corresponds to the endpoint. + * @{ + */ + +/** + * @file axis2_svc_name.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc_name */ + typedef struct axis2_svc_name axis2_svc_name_t; + + /** + * Creates a service name struct with given QName and endpoint name. + * @param env pointer to environment struct + * @param qname pointer to QName, this method creates a clone of QName + * @param endpoint_name endpoint name string + * @return pointer to newly create service name struct + */ + AXIS2_EXTERN axis2_svc_name_t *AXIS2_CALL + axis2_svc_name_create( + const axutil_env_t * env, + const axutil_qname_t * qname, + const axis2_char_t * endpoint_name); + + /** + * Gets QName. QName identifies the WSDL service element that contains + * the definition of the endpoint being conveyed. + * @param svc_name pointer to service name struct + * @param env pointer to environment struct + * @return pointer to QName struct, returns a reference, not a cloned + * copy + */ + AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL + axis2_svc_name_get_qname( + const axis2_svc_name_t * svc_name, + const axutil_env_t * env); + + /** + * Sets QName. QName identifies the WSDL service element that contains + * the definition of the endpoint being conveyed. + * @param svc_name pointer to service name struct + * @param env pointer to environment struct + * @param qname pointer to QName, service name creates a clone of QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_name_set_qname( + struct axis2_svc_name *svc_name, + const axutil_env_t * env, + const axutil_qname_t * qname); + + /** + * Gets endpoint name. Endpoint name is a non-qualified name that + * identifies the specific port in the service that corresponds to + * the endpoint. + * @param svc_name pointer to service name struct + * @param env pointer to environment struct + * @return endpoint name string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + axis2_svc_name_get_endpoint_name( + const axis2_svc_name_t * svc_name, + const axutil_env_t * env); + + /** + * Sets endpoint name. Endpoint name is a non-qualified name that + * identifies the specific port in the service that corresponds to + * the endpoint. + * @param svc_name pointer to service name struct + * @param env pointer to environment struct + * @param endpoint_name endpoint name string + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_name_set_endpoint_name( + struct axis2_svc_name *svc_name, + const axutil_env_t * env, + const axis2_char_t * endpoint_name); + + /** + * Frees service name struct. + * @param svc_name pointer to service name struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_name_free( + struct axis2_svc_name *svc_name, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SVC_NAME_H */ diff --git a/include/axis2_svc_skeleton.h b/include/axis2_svc_skeleton.h new file mode 100644 index 0000000..27d08a9 --- /dev/null +++ b/include/axis2_svc_skeleton.h @@ -0,0 +1,182 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_SVC_SKELETON_H +#define AXIS2_SVC_SKELETON_H + +/** + * @defgroup axis2_soc_api service API + * @ingroup axis2 + * @{ + * @} + */ + +/** + * @defgroup axis2_svc_skeleton service skeleton + * @ingroup axis2_svc_api + * service skeleton API should be implemented by all services + * that are to be deployed with Axis2/C engine. + * @{ + */ + +/** + * @file axis2_svc_skeleton.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc_skeleton_ops */ + typedef struct axis2_svc_skeleton_ops axis2_svc_skeleton_ops_t; + + /** Type name for struct axis2_svc_skeleton */ + typedef struct axis2_svc_skeleton axis2_svc_skeleton_t; + + /** + * service skeleton ops struct. + * Encapsulator struct for operations of axis2_svc_skeleton. + */ + struct axis2_svc_skeleton_ops + { + + /** + * Initializes the service implementation. + * @param svc_skeleton pointer to svc_skeleton struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + int( + AXIS2_CALL + * init)( + axis2_svc_skeleton_t * svc_skeleton, + const axutil_env_t * env); + + /** + * Invokes the service. This function should be used to call up the + * functions implementing service operations. + * @param svc_skeli pointer to svc_skeli struct + * @param env pointer to environment struct + * @param node pointer to node struct + * @param msg_ctx pointer to message context struct + * @return pointer to AXIOM node resulting from the invocation. + * In case of one way operations, NULL would be returned with + * status in environment error set to AXIS2_SUCCESS. On error + * NULL would be returned with error status set to AXIS2_FAILURE + */ + axiom_node_t *( + AXIS2_CALL + * invoke)( + axis2_svc_skeleton_t * svc_skeli, + const axutil_env_t * env, + axiom_node_t * node, + axis2_msg_ctx_t * msg_ctx); + + /** + * This method would be called if a fault is detected. + * @param svc_skeli pointer to svc_skeli struct + * @param env pointer to environment struct + * @param node pointer to node struct + * @return pointer to AXIOM node reflecting the fault, NULL on error + */ + axiom_node_t *( + AXIS2_CALL + * on_fault)( + axis2_svc_skeleton_t * svc_skeli, + const axutil_env_t * env, + axiom_node_t * node); + + /** + * Frees service implementation. + * @param svc_skeli pointer to svc_skeli struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + int( + AXIS2_CALL + * free)( + axis2_svc_skeleton_t * svc_skeli, + const axutil_env_t * env); + + /** + * Initializes the service implementation. + * @param svc_skeleton pointer to svc_skeleton struct + * @param env pointer to environment struct + * @param conf pointer to axis2c configuration struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + int( + AXIS2_CALL + * init_with_conf)( + axis2_svc_skeleton_t * svc_skeleton, + const axutil_env_t * env, + struct axis2_conf * conf); + }; + + /** + * service skeleton struct. + */ + struct axis2_svc_skeleton + { + + /** operations of service skeleton */ + const axis2_svc_skeleton_ops_t *ops; + + /** Array list of functions, implementing the service operations */ + axutil_array_list_t *func_array; + }; + + /*************************** Function macros **********************************/ + + /** Initialize the svc skeleton. + @sa axis2_svc_skeleton_ops#init */ +#define AXIS2_SVC_SKELETON_INIT(svc_skeleton, env) \ + ((svc_skeleton)->ops->init (svc_skeleton, env)) + + /** Initialize the svc skeleton with axis2c configuration struct. + @sa axis2_svc_skeleton_ops#init_with_conf */ +#define AXIS2_SVC_SKELETON_INIT_WITH_CONF(svc_skeleton, env, conf) \ + ((svc_skeleton)->ops->init_with_conf (svc_skeleton, env, conf)) + + /** Frees the svc skeleton. + @sa axis2_svc_skeleton_ops#free */ +#define AXIS2_SVC_SKELETON_FREE(svc_skeleton, env) \ + ((svc_skeleton)->ops->free (svc_skeleton, env)) + + /** Invokes axis2 service skeleton. + @sa axis2_svc_skeleton_ops#invoke */ +#define AXIS2_SVC_SKELETON_INVOKE(svc_skeleton, env, node, msg_ctx) \ + ((svc_skeleton)->ops->invoke (svc_skeleton, env, node, msg_ctx)) + + /** Called on fault. + @sa axis2_svc_skeleton_ops#on_fault */ +#define AXIS2_SVC_SKELETON_ON_FAULT(svc_skeleton, env, node) \ + ((svc_skeleton)->ops->on_fault (svc_skeleton, env, node)) + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SVC_SKELETON_H */ diff --git a/include/axis2_svr_callback.h b/include/axis2_svr_callback.h new file mode 100644 index 0000000..47ba646 --- /dev/null +++ b/include/axis2_svr_callback.h @@ -0,0 +1,95 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_SVR_CALLBACK_H +#define AXIS2_SVR_CALLBACK_H + +/** @defgroup axis2_svr_callback server callback + * @ingroup axis2_svc_api + * @{ + */ + +/** + * @file axis2_svr_callback.h + * @brief axis Server Callback interface + */ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include +#include +#include + + /** Type name for struct axis2_svr_callback */ + typedef struct axis2_svr_callback axis2_svr_callback_t; + + /** + * Deallocate memory + * @param svr_callback pointer to server callback struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svr_callback_free( + axis2_svr_callback_t * svr_callback, + const axutil_env_t * env); + + /** + * Handle result + * @param svr_callback pointer to server callback struct + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svr_callback_handle_result( + axis2_svr_callback_t * svr_callback, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Handle fault + * @param svr_callback pointer to server callback struct + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svr_callback_handle_fault( + axis2_svr_callback_t * svr_callback, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Create Server Callback struct + * @param env pointer to environment struct + * @return newly created server callback object + */ + AXIS2_EXTERN axis2_svr_callback_t *AXIS2_CALL + axis2_svr_callback_create( + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SVR_CALLBACK_H */ diff --git a/include/axis2_thread_mutex.h b/include/axis2_thread_mutex.h new file mode 100644 index 0000000..6512812 --- /dev/null +++ b/include/axis2_thread_mutex.h @@ -0,0 +1,112 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_THREAD_MUTEX_H +#define AXIS2_THREAD_MUTEX_H + +/** + * @file axutil_thread_mutex.h + * @brief AXIS2 Thread Mutex Routines + */ + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + /** + * @defgroup axis2_mutex thread mutex routines + * @ingroup axis2_util + * @{ + */ + + /** Opaque thread-local mutex structure */ + typedef struct axutil_thread_mutex_t axutil_thread_mutex_t; + +#define AXIS2_THREAD_MUTEX_DEFAULT 0x0 /**< platform-optimal lock behavior */ + +#define AXIS2_THREAD_MUTEX_NESTED 0x1 /**< enable nested (recursive) locks */ + +#define AXIS2_THREAD_MUTEX_UNNESTED 0x2 /**< disable nested locks */ + + /** + * Create and initialize a mutex that can be used to synchronize threads. + * + * @param flags Or'ed value of: + * 
+     *           AXIS2_THREAD_MUTEX_DEFAULT   platform-optimal lock behavior.
+     *           AXIS2_THREAD_MUTEX_NESTED    enable nested (recursive) locks.
+     *           AXIS2_THREAD_MUTEX_UNNESTED  disable nested locks (non-recursive).
+     *
+ * @param allocator the allocator from which to allocate the mutex. + * @return mutex the memory address where the newly created mutex will be + * stored. + * @warning Be cautious in using AXIS2_THREAD_MUTEX_DEFAULT. While this is the + * most optimial mutex based on a given platform's performance charateristics, + * it will behave as either a nested or an unnested lock. + */ + AXIS2_EXTERN axutil_thread_mutex_t *AXIS2_CALL + + axutil_thread_mutex_create( + axutil_allocator_t * allocator, + unsigned int flags); + + /** + * Acquire the lock for the given mutex. If the mutex is already locked, + * the current thread will be put to sleep until the lock becomes available. + * @param mutex the mutex on which to acquire the lock. + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axutil_thread_mutex_lock( + axutil_thread_mutex_t * mutex); + + /** + * Attempt to acquire the lock for the given mutex. If the mutex has already + * been acquired, the call returns immediately + * @param mutex the mutex on which to attempt the lock acquiring. + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axutil_thread_mutex_trylock( + axutil_thread_mutex_t * mutex); + + /** + * Release the lock for the given mutex. + * @param mutex the mutex from which to release the lock. + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axutil_thread_mutex_unlock( + axutil_thread_mutex_t * mutex); + + /** + * Destroy the mutex and free the memory associated with the lock. + * @param mutex the mutex to destroy. + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axutil_thread_mutex_destroy( + axutil_thread_mutex_t * mutex); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_THREAD_MUTEX_H */ diff --git a/include/axis2_transport_in_desc.h b/include/axis2_transport_in_desc.h new file mode 100644 index 0000000..bd96331 --- /dev/null +++ b/include/axis2_transport_in_desc.h @@ -0,0 +1,329 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_TRANSPORT_IN_DESC_H +#define AXIS2_TRANSPORT_IN_DESC_H + +/** + * @defgroup axis2_transport_in_desc transport in description + * @ingroup axis2_desc + * transport in description represents a transport receiver configured in + * Axis2 configuration. There can be multiple transport receivers configured + * in axis2.xml file and each of them will be represented with a transport + * in description instance. deployment engine takes care of creating and + * instantiating transport in descriptions. + * transport in description encapsulates flows related to the transport in + * and also holds a reference to related transport receiver. + * @{ + */ + +/** + * @file axis2_transport_in_desc.h + * @brief Axis2 description transport in interface + */ + +#include +#include +#include +#include +#include +#include + +/*#include */ +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_transport_in_desc */ + typedef struct axis2_transport_in_desc axis2_transport_in_desc_t; + + struct axis2_phase; + struct axis2_transport_receiver; + + /** + * Frees transport in description. + * @param transport_in_desc pointer to transport in description struct + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_in_desc_free( + axis2_transport_in_desc_t * transport_in_desc, + const axutil_env_t * env); + + /** + * Frees transport in description given as a void parameter. + * @param transport_in pointer to transport in description as a void + * pointer + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_in_desc_free_void_arg( + void *transport_in, + const axutil_env_t * env); + + /** + * Gets transport enum. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @return transport enum + */ + AXIS2_EXTERN AXIS2_TRANSPORT_ENUMS AXIS2_CALL + + axis2_transport_in_desc_get_enum( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env); + + /** + * Sets transport enum. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @param trans_enum transport enum + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_transport_in_desc_set_enum( + struct axis2_transport_in_desc *transport_in, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Gets in flow. In flow represents the list of phases invoked + * along the receive path. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @return pointer to flow representing in flow, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_transport_in_desc_get_in_flow( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env); + + /** + * Sets in flow. In flow represents the list of phases invoked + * along the receive path. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @param in_flow pointer to in flow representing in flow, transport in + * description assumes ownership of the flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_in_desc_set_in_flow( + struct axis2_transport_in_desc *transport_in, + const axutil_env_t * env, + struct axis2_flow *in_flow); + + /** + * Gets fault in flow. Fault in flow represents the list of phases + * invoked along the receive path if a fault happens. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @return pointer to flow representing fault in flow, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_transport_in_desc_get_fault_in_flow( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env); + + /** + * Sets fault in flow. Fault in flow represents the list of phases + * invoked along the receive path if a fault happens. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @param fault_in_flow pointer to flow representing fault in flow, + * transport in description assumes the ownership of the flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_in_desc_set_fault_in_flow( + struct axis2_transport_in_desc *transport_in, + const axutil_env_t * env, + struct axis2_flow *fault_in_flow); + + /** + * Gets transport receiver associated with the transport in description. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @return pointer to transport receiver, returns a reference, not + * a cloned copy + */ + AXIS2_EXTERN struct axis2_transport_receiver *AXIS2_CALL + + axis2_transport_in_desc_get_recv( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env); + + /** + * Sets transport receiver associated with the transport in description. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @param recv pointer to transport receiver, transport in + * description assumes ownership of the receiver + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_transport_in_desc_set_recv( + struct axis2_transport_in_desc *transport_in, + const axutil_env_t * env, + struct axis2_transport_receiver *recv); + + /** + * Gets the transport in phase associated with transport in description. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @return transport in phase, returns a reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_phase *AXIS2_CALL + + axis2_transport_in_desc_get_in_phase( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env); + + /** + * Sets the transport in phase associated with transport in description. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @param in_phase pointer to phase representing transport in phase, + * transport in description assumes ownership of phase + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_in_desc_set_in_phase( + struct axis2_transport_in_desc *transport_in, + const axutil_env_t * env, + struct axis2_phase *in_phase); + + /** + * Gets the transport fault phase associated with transport in description. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @return pointer to phase representing fault phase + */ + AXIS2_EXTERN struct axis2_phase *AXIS2_CALL + + axis2_transport_in_desc_get_fault_phase( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env); + + /** + * Sets the transport fault phase associated with transport in description. + * @param transport_in pointer to transport in description struct + * @param env pointer to environment struct + * @param fault_phase pointer to fault phase + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_in_desc_set_fault_phase( + struct axis2_transport_in_desc *transport_in, + const axutil_env_t * env, + struct axis2_phase *fault_phase); + + /** + * Adds given parameter. + * @param transport_in_desc pointer to transport in description struct + * @param env pointer to environment struct + * @param param pointer to parameter, transport in description assumes + * ownership of parameter + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_transport_in_desc_add_param( + axis2_transport_in_desc_t * transport_in_desc, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets named parameter. + * @param transport_in_desc pointer to transport in description struct + * @param env pointer to environment struct + * @param param_name parameter name string + * @return pointer to named parameter if it exists, else NULL. Returns + * a reference, not a cloned copy + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + + axis2_transport_in_desc_get_param( + const axis2_transport_in_desc_t * transport_in_desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Checks if the named parameter is locked. + * @param transport_in_desc pointer to transport in description struct + * @param env pointer to environment struct + * @param param_name parameter name string + * @return AXIS2_TRUE if named parameter is locked, else AXIS2_FALSE + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_transport_in_desc_is_param_locked( + axis2_transport_in_desc_t * transport_in_desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + + axis2_transport_in_desc_param_container( + const axis2_transport_in_desc_t * transport_in_desc, + const axutil_env_t * env); + + /** + * Creates transport in description with given transport enum. + * @param env pointer to environment struct + * @param trans_enum transport enum + * @return pointer to newly created phase holder + */ + AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL + + axis2_transport_in_desc_create( + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Frees transport in description given as a void parameter. + * @param transport_in pointer to transport in description as a void + * pointer + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_in_desc_free_void_arg( + void *transport_in, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_TRANSPORT_IN_DESC_H */ diff --git a/include/axis2_transport_out_desc.h b/include/axis2_transport_out_desc.h new file mode 100644 index 0000000..4dcc629 --- /dev/null +++ b/include/axis2_transport_out_desc.h @@ -0,0 +1,327 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_TRANSPORT_OUT_DESC_H +#define AXIS2_TRANSPORT_OUT_DESC_H + +/** + * @defgroup axis2_transport_out_desc transport out description + * @ingroup axis2_desc + * transport out description represents a transport sender configured in + * Axis2 configuration. There can be multiple transport senders configured + * in axis2.xml file and each of them will be represented with a transport + * out description instance. deployment engine takes care of creating and + * instantiating transport out descriptions. + * transport out description encapsulates flows related to the transport out + * and also holds a reference to related transport sender. + * @{ + */ + +/** + * @file axis2_transport_out_desc.h + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_transport_out_desc */ + typedef struct axis2_transport_out_desc axis2_transport_out_desc_t; + + struct axis2_phase; + struct axis2_transport_sender; + + /** + * Frees transport out description. + * @param transport_out_dec pointer to transport out description + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_out_desc_free( + axis2_transport_out_desc_t * transport_out_desc, + const axutil_env_t * env); + + /** + * Frees transport out description given as a void pointer. + * @param transport_out_dec pointer to transport out description as a + * void pointer + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_out_desc_free_void_arg( + void *transport_out, + const axutil_env_t * env); + + /** + * Gets transport enum. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @return transport enum + */ + AXIS2_EXTERN AXIS2_TRANSPORT_ENUMS AXIS2_CALL + + axis2_transport_out_desc_get_enum( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env); + + /** + * Sets transport enum. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @param trans_enum transport enum + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_transport_out_desc_set_enum( + struct axis2_transport_out_desc *transport_out, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Gets out flow. Out flow represents the list of phases invoked + * along the sender path. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @return pointer to flow representing out flow, returns a reference, + * not a cloned copy + */ + AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_transport_out_desc_get_out_flow( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env); + + /** + * Sets out flow. Out flow represents the list of phases invoked + * along the sender path. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @param out_flow pointer to out flow, transport out description + * assumes ownership of flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_out_desc_set_out_flow( + struct axis2_transport_out_desc *transport_out, + const axutil_env_t * env, + struct axis2_flow *out_flow); + + /** + * Gets fault out flow. Fault out flow represents the list of phases + * invoked along the sender path if a fault happens. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @return pointer to flow representing fault out flow + */ + AXIS2_EXTERN struct axis2_flow *AXIS2_CALL + + axis2_transport_out_desc_get_fault_out_flow( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env); + + /** + * Sets fault out flow. Fault out flow represents the list of phases + * invoked along the sender path if a fault happens. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @param fault_out_flow pointer to fault_out_flow + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_out_desc_set_fault_out_flow( + struct axis2_transport_out_desc *transport_out, + const axutil_env_t * env, + struct axis2_flow *fault_out_flow); + + /** + * Gets transport sender. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @return pointer to transport sender associated wit the transport out + * description, returns a reference, not a cloned copy + */ + AXIS2_EXTERN axis2_transport_sender_t *AXIS2_CALL + + axis2_transport_out_desc_get_sender( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env); + + /** + * Sets transport sender. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @param sender pointer to transport sender, transport description + * assumes ownership of sender + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_out_desc_set_sender( + struct axis2_transport_out_desc *transport_out, + const axutil_env_t * env, + axis2_transport_sender_t * sender); + + /** + * Gets transport out phase. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @return pointer to phase representing transport out phase, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_phase *AXIS2_CALL + + axis2_transport_out_desc_get_out_phase( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env); + + /** + * Sets transport out phase. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @param out_phase pointer to phase representing transport out phase, + * transport out description assumes ownership of phase + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_out_desc_set_out_phase( + struct axis2_transport_out_desc *transport_out, + const axutil_env_t * env, + struct axis2_phase *out_phase); + + /** + * Gets fault phase. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @return pointer to phase representing fault phase, returns a + * reference, not a cloned copy + */ + AXIS2_EXTERN struct axis2_phase *AXIS2_CALL + + axis2_transport_out_desc_get_fault_phase( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env); + + /** + * Sets fault phase. + * @param transport_out pointer to transport_out + * @param env pointer to environment struct + * @param fault_phase pointer to phase representing fault phase, + * transport description assumes ownership of phase + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_out_desc_set_fault_phase( + struct axis2_transport_out_desc *transport_out, + const axutil_env_t * env, + struct axis2_phase *fault_phase); + + /** + * Adds parameter. + * @param transport_out_desc pointer to tarn sport out description + * @param env pointer to environment struct + * @param param pointer to parameter, transport out description assumes + * ownership of parameter + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_transport_out_desc_add_param( + axis2_transport_out_desc_t * transport_out_desc, + const axutil_env_t * env, + axutil_param_t * param); + + /** + * Gets named parameter. + * @param transport_out_desc pointer to transport out description + * @param env pointer to environment struct + * @param param_name parameter name string + */ + AXIS2_EXTERN axutil_param_t *AXIS2_CALL + + axis2_transport_out_desc_get_param( + const axis2_transport_out_desc_t * transport_out_desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + /** + * Checks if the named parameter is locked. + * @param transport_out_desc pointer to transport out description + * @param env pointer to environment struct + * @param param_name pointer to parameter name + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + + axis2_transport_out_desc_is_param_locked( + axis2_transport_out_desc_t * transport_out_desc, + const axutil_env_t * env, + const axis2_char_t * param_name); + + AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL + + axis2_transport_out_desc_param_container( + const axis2_transport_out_desc_t * transport_out_desc, + const axutil_env_t * env); + + /** + * Creates transport out description with given transport enum. + * @param env pointer to environment struct + * @param trans_enum pointer to transport enum + * @return pointer to newly created transport out + */ + AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL + + axis2_transport_out_desc_create( + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum); + + /** + * Frees transport out description given as a void pointer. + * @param transport_out_dec pointer to transport out description as a + * void pointer + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_out_desc_free_void_arg( + void *transport_out, + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_TRANSPORT_OUT_DESC_H */ diff --git a/include/axis2_transport_receiver.h b/include/axis2_transport_receiver.h new file mode 100644 index 0000000..7af1973 --- /dev/null +++ b/include/axis2_transport_receiver.h @@ -0,0 +1,256 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_TRANSPORT_RECEIVER_H +#define AXIS2_TRANSPORT_RECEIVER_H + +/** + * @defgroup axis2_transport transport + * @ingroup axis2 + * @{ + * @} + */ + +/** @defgroup axis2_transport_receiver transport receiver + * @ingroup axis2_transport + * Description. + * @{ + */ + +/** + * @file axis2_transport_receiver.h + * @brief Axis2 description transport receiver interface + */ + + #include + #include + #include + #include + #include + #include + #include + #include + + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf_ctx; + struct axis2_transport_in_desc; + + /** Type name for axis2_transport_receiver */ + typedef struct axis2_transport_receiver axis2_transport_receiver_t; + + /** Type name for axis2_transport_receiver_ops */ + typedef struct axis2_transport_receiver_ops axis2_transport_receiver_ops_t; + + /** + * @brief Description Transport Receiver ops struct + * Encapsulator struct for ops of axis2_transport_receiver + */ + struct axis2_transport_receiver_ops + { + + /** + * @param transport_receiver pointer to transport receiver + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context + * @param intrasport_in pointer to transport_in + */ + axis2_status_t(AXIS2_CALL * init)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env, + struct axis2_conf_ctx * conf_ctx, + struct axis2_transport_in_desc * transport_in); + + /** + * @param transport_receiver + * @param env pointer to environment struct + */ + axis2_status_t(AXIS2_CALL * start)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + /** + * @param tranport_receiver pointer to transport receiver + * @param env pointer to environment struct + * @param svc_name pointer to service name + */ + axis2_endpoint_ref_t *(AXIS2_CALL * get_reply_to_epr)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + /** + * @param tranport_receiver pointer to transport receiver + * @param env pointer to environment struct + * @param svc_name pointer to service name + */ + axis2_endpoint_ref_t *(AXIS2_CALL * get_epr_for_service)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + /** + * @param tranport_receiver pointer to transport receiver + * @param env pointer to environment struct + * @param svc_name pointer to service name + */ + axis2_char_t *(AXIS2_CALL * get_server_ip)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + /** + * @param tranport_receiver pointer to transport receiver + * @param env pointer to environment struct + * @param svc_name pointer to service name + */ + void (AXIS2_CALL * set_server_ip)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env, + axis2_char_t * ip); + + /** + * @param server pointer to server + * @param env pointer to environment struct + */ + struct axis2_conf_ctx *(AXIS2_CALL * get_conf_ctx)( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + + /** + * @param server pointer to server + * @param env pointer to environment struct + */ + axis2_bool_t(AXIS2_CALL * is_running)( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + + void(AXIS2_CALL * set_is_application_client_side)( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_bool_t is_application_client_side); + + /** + * @param transport_receiver pointer to transport receiver + * @param env pointer to environment struct + */ + axis2_status_t(AXIS2_CALL * stop)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + /** + * De-allocate memory + * @param transport_receiver pointer to transport receiver + * @param env pointer to environment struct + */ + void(AXIS2_CALL * free)( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + }; + + /** + * @brief Transport Receiver struct + */ + struct axis2_transport_receiver + { + const axis2_transport_receiver_ops_t *ops; + }; + + /** Frees the transport receiver. + @sa axis2_transport_receiver#free */ + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_receiver_free( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + /** Initialize the transport receiver. + @sa axis2_transport_receiver#init */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_transport_receiver_init( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env, + struct axis2_conf_ctx *conf_ctx, + struct axis2_transport_in_desc *transport_in); + + /** Start + @sa axis2_transport_receiver#start */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_transport_receiver_start( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + /** Stop. + @sa axis2_transport_receiver#stop */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_transport_receiver_stop( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + /** Get reply to epr. + @sa axis2_transport_receiver#get_reply_to_epr */ + AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL + axis2_transport_receiver_get_reply_to_epr( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + /** Get conf ctx. + @sa axis2_transport_receiver#get_conf_ctx */ + AXIS2_EXTERN struct axis2_conf_ctx *AXIS2_CALL + axis2_transport_receiver_get_conf_ctx( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + /** Is running. + @sa axis2_transport_receiver#is_running */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_transport_receiver_is_running( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_receiver_set_is_application_client_side( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env, + axis2_bool_t is_application_client_side); + + AXIS2_EXTERN axis2_endpoint_ref_t* AXIS2_CALL + axis2_transport_receiver_get_epr_for_service(axis2_transport_receiver_t *transport_receiver, + const axutil_env_t *env, + const axis2_char_t *svc_name); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_transport_receiver_get_server_ip( + axis2_transport_receiver_t *transport_receiver, + const axutil_env_t *env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_transport_receiver_set_server_ip( + axis2_transport_receiver_t *transport_receiver, + const axutil_env_t *env, + axis2_char_t *serverip); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_TRANSPORT_RECEIVER_H */ diff --git a/include/axis2_transport_sender.h b/include/axis2_transport_sender.h new file mode 100644 index 0000000..70a8586 --- /dev/null +++ b/include/axis2_transport_sender.h @@ -0,0 +1,173 @@ + +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_TRANSPORT_SENDER_H +#define AXIS2_TRANSPORT_SENDER_H + +/** @defgroup axis2_transport_sender transport sender + * @ingroup axis2_transport + * Description + * @{ + */ + +/** + * @file axis2_transport_sender.h + * @brief Axis2 description transport sender interface + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_transport_out_desc; + struct axis2_ctx; + struct axis2_msg_ctx; + struct axis2_handler; + + /** Type name for struct axis2_transport_sender */ + typedef struct axis2_transport_sender axis2_transport_sender_t; + + /** Type name for struct axis2_transport_sender_ops */ + typedef struct axis2_transport_sender_ops axis2_transport_sender_ops_t; + + /** + * @brief Description Transport Sender ops struct + * Encapsulator struct for ops of axis2_transport_sender + */ + struct axis2_transport_sender_ops + { + + /** + * Initialize + * @param transport_sender pointer to transport sender + * @param env pointer to environment + * @param conf_ctx pointer to configuration context + * @param transport_out pointer to transport_out + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + axis2_status_t( + AXIS2_CALL + * init)( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + struct axis2_conf_ctx * conf_ctx, + struct axis2_transport_out_desc * transport_out); + + /** + * Invoke + * @param transport_sender pointer to transport sender + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + axis2_status_t( + AXIS2_CALL + * invoke)( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); + + /** + * Clean up + * @param transport_sender pointer to transport sender + * @param env pointer to environmnet struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + axis2_status_t( + AXIS2_CALL + * cleanup)( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); + + /** De-allocate memory + * @param transport_sender pointer to transport sender + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + void( + AXIS2_CALL + * free)( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env); + + }; + + /** + * Transport Sender struct + * This send the SOAP Message to other SOAP nodes and this alone write the SOAP + * Message to the wire. Out flow must be end with one of this kind + */ + struct axis2_transport_sender + { + + /** operations of axis transport sender */ + const axis2_transport_sender_ops_t *ops; + }; + + /** + * Creates phase holder struct + * @param env pointer to environment struct + * @return pointer to newly created transport sender + */ + AXIS2_EXTERN axis2_transport_sender_t *AXIS2_CALL + + axis2_transport_sender_create( + const axutil_env_t * env); + + /*************************** Function macros **********************************/ + + /** Frees the axis2 transport sender. + @sa axis2_transport_sender_ops#free */ +#define AXIS2_TRANSPORT_SENDER_FREE(transport_sender, env) \ + ((transport_sender->ops)->free (transport_sender, env)) + + /** Initialize the axis2 transport sender. + @sa axis2_transport_sender_ops#init */ +#define AXIS2_TRANSPORT_SENDER_INIT(transport_sender, env, conf_context, transport_out) \ + ((transport_sender->ops)->init (transport_sender, env, conf_context, transport_out)) + + /** Invoke. + @sa axis2_transport_sender_ops#invoke */ +#define AXIS2_TRANSPORT_SENDER_INVOKE(transport_sender, env, msg_ctx) \ + ((transport_sender->ops)->invoke (transport_sender, env, msg_ctx)) + + /** Cleanup. + @sa axis2_transport_sender_ops#cleanup */ +#define AXIS2_TRANSPORT_SENDER_CLEANUP(transport_sender, env, msg_ctx) \ + ((transport_sender->ops)->cleanup (transport_sender, env, msg_ctx)) + + /*************************** End of function macros ***************************/ + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_TRANSPORT_SENDER_H */ diff --git a/include/axis2_util.h b/include/axis2_util.h new file mode 100644 index 0000000..b600efd --- /dev/null +++ b/include/axis2_util.h @@ -0,0 +1,61 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_UTIL_H +#define AXIS2_UTIL_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_UTIL_H */ -- cgit v1.1-32-gdbae