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 --- src/Makefile.am | 1 + src/core/Makefile.am | 1 + src/core/addr/Makefile.am | 13 + src/core/addr/any_content_type.c | 120 + src/core/addr/endpoint_ref.c | 375 ++ src/core/addr/msg_info_headers.c | 448 +++ src/core/addr/relates_to.c | 164 + src/core/addr/svc_name.c | 151 + src/core/clientapi/Makefile.am | 17 + src/core/clientapi/async_result.c | 83 + src/core/clientapi/callback.c | 272 ++ src/core/clientapi/callback_recv.c | 199 + src/core/clientapi/listener_manager.c | 302 ++ src/core/clientapi/op_client.c | 1439 ++++++++ src/core/clientapi/options.c | 1068 ++++++ src/core/clientapi/stub.c | 228 ++ src/core/clientapi/svc_client.c | 1624 ++++++++ src/core/context/Makefile.am | 13 + src/core/context/conf_ctx.c | 599 +++ src/core/context/ctx.c | 197 + src/core/context/msg_ctx.c | 2768 ++++++++++++++ src/core/context/op_ctx.c | 420 +++ src/core/context/svc_ctx.c | 200 + src/core/context/svc_grp_ctx.c | 256 ++ src/core/deployment/Makefile.am | 38 + src/core/deployment/arch_file_data.c | 369 ++ src/core/deployment/arch_reader.c | 313 ++ src/core/deployment/axis2_arch_file_data.h | 265 ++ src/core/deployment/axis2_arch_reader.h | 152 + src/core/deployment/axis2_conf_builder.h | 116 + src/core/deployment/axis2_dep_engine.h | 418 +++ src/core/deployment/axis2_deployment.h | 119 + src/core/deployment/axis2_desc_builder.h | 292 ++ src/core/deployment/axis2_module_builder.h | 101 + src/core/deployment/axis2_repos_listener.h | 144 + src/core/deployment/axis2_svc_builder.h | 149 + src/core/deployment/axis2_svc_grp_builder.h | 122 + src/core/deployment/axis2_ws_info.h | 144 + src/core/deployment/axis2_ws_info_list.h | 192 + src/core/deployment/conf_builder.c | 1337 +++++++ src/core/deployment/conf_init.c | 460 +++ src/core/deployment/dep_engine.c | 1988 ++++++++++ src/core/deployment/desc_builder.c | 1148 ++++++ src/core/deployment/module_builder.c | 514 +++ src/core/deployment/phases_info.c | 564 +++ src/core/deployment/repos_listener.c | 398 ++ src/core/deployment/svc_builder.c | 840 +++++ src/core/deployment/svc_grp_builder.c | 264 ++ src/core/deployment/ws_info.c | 158 + src/core/deployment/ws_info_list.c | 370 ++ src/core/description/Makefile.am | 24 + src/core/description/desc.c | 261 ++ src/core/description/flow.c | 130 + src/core/description/flow_container.c | 173 + src/core/description/handler_desc.c | 333 ++ src/core/description/module_desc.c | 470 +++ src/core/description/msg.c | 407 ++ src/core/description/op.c | 1383 +++++++ src/core/description/phase_rule.c | 254 ++ src/core/description/policy_include.c | 612 +++ src/core/description/svc.c | 1543 ++++++++ src/core/description/svc_grp.c | 600 +++ src/core/description/transport_in_desc.c | 305 ++ src/core/description/transport_out_desc.c | 299 ++ src/core/engine/Makefile.am | 47 + src/core/engine/addr_disp.c | 255 ++ src/core/engine/axis2_disp_checker.h | 105 + src/core/engine/conf.c | 1835 +++++++++ src/core/engine/ctx_handler.c | 204 + src/core/engine/disp.c | 185 + src/core/engine/disp_checker.c | 284 ++ src/core/engine/engine.c | 915 +++++ src/core/engine/handler.c | 133 + src/core/engine/phase.c | 1275 +++++++ src/core/engine/req_uri_disp.c | 206 ++ src/core/engine/rest_disp.c | 350 ++ src/core/engine/soap_action_disp.c | 155 + src/core/engine/soap_body_disp.c | 231 ++ src/core/phaseresolver/Makefile.am | 9 + src/core/phaseresolver/phase_holder.c | 243 ++ src/core/phaseresolver/phase_resolver.c | 2016 ++++++++++ src/core/receivers/Makefile.am | 11 + src/core/receivers/msg_recv.c | 560 +++ src/core/receivers/raw_xml_in_out_msg_recv.c | 442 +++ src/core/receivers/svr_callback.c | 112 + src/core/transport/Makefile.am | 8 + src/core/transport/amqp/Makefile.am | 4 + src/core/transport/amqp/receiver/Makefile.am | 25 + .../transport/amqp/receiver/axis2_amqp_receiver.c | 275 ++ .../transport/amqp/receiver/axis2_amqp_receiver.h | 82 + .../amqp/receiver/qpid_receiver/Makefile.am | 29 + .../receiver/qpid_receiver/axis2_qpid_receiver.cpp | 167 + .../receiver/qpid_receiver/axis2_qpid_receiver.h | 39 + .../axis2_qpid_receiver_interface.cpp | 102 + .../qpid_receiver/axis2_qpid_receiver_interface.h | 58 + .../qpid_receiver/axis2_qpid_receiver_listener.cpp | 123 + .../qpid_receiver/axis2_qpid_receiver_listener.h | 43 + .../qpid_receiver/request_processor/Makefile.am | 20 + .../axis2_amqp_request_processor.c | 334 ++ .../axis2_amqp_request_processor.h | 55 + src/core/transport/amqp/sender/Makefile.am | 26 + src/core/transport/amqp/sender/axis2_amqp_sender.c | 344 ++ src/core/transport/amqp/sender/axis2_amqp_sender.h | 63 + .../transport/amqp/sender/qpid_sender/Makefile.am | 23 + .../amqp/sender/qpid_sender/axis2_qpid_sender.cpp | 242 ++ .../amqp/sender/qpid_sender/axis2_qpid_sender.h | 49 + .../qpid_sender/axis2_qpid_sender_interface.cpp | 130 + .../qpid_sender/axis2_qpid_sender_interface.h | 50 + src/core/transport/amqp/server/Makefile.am | 1 + .../amqp/server/axis2_amqp_server/Makefile.am | 33 + .../server/axis2_amqp_server/axis2_amqp_server.c | 232 ++ .../server/axis2_amqp_server/axis2_amqp_server.h | 41 + src/core/transport/amqp/util/Makefile.am | 18 + src/core/transport/amqp/util/axis2_amqp_defines.h | 65 + src/core/transport/amqp/util/axis2_amqp_util.c | 823 +++++ src/core/transport/amqp/util/axis2_amqp_util.h | 143 + src/core/transport/http/Makefile.am | 1 + src/core/transport/http/common/Makefile.am | 29 + .../transport/http/common/http_accept_record.c | 165 + src/core/transport/http/common/http_header.c | 168 + .../http/common/http_out_transport_info.c | 353 ++ src/core/transport/http/common/http_request_line.c | 227 ++ .../transport/http/common/http_response_writer.c | 176 + .../transport/http/common/http_simple_request.c | 433 +++ .../transport/http/common/http_simple_response.c | 615 ++++ src/core/transport/http/common/http_status_line.c | 267 ++ src/core/transport/http/common/http_worker.c | 2064 +++++++++++ .../transport/http/common/simple_http_svr_conn.c | 504 +++ src/core/transport/http/receiver/Makefile.am | 21 + src/core/transport/http/receiver/http_receiver.c | 508 +++ src/core/transport/http/receiver/http_svr_thread.c | 315 ++ src/core/transport/http/sender/Makefile.am | 51 + src/core/transport/http/sender/http_client.c | 965 +++++ src/core/transport/http/sender/http_sender.c | 3332 +++++++++++++++++ .../transport/http/sender/http_transport_sender.c | 859 +++++ src/core/transport/http/sender/libcurl/Makefile.am | 2 + .../transport/http/sender/libcurl/axis2_libcurl.c | 1169 ++++++ .../transport/http/sender/libcurl/axis2_libcurl.h | 53 + .../transport/http/sender/libcurl/libcurl_stream.c | 192 + .../transport/http/sender/libcurl/libcurl_stream.h | 51 + src/core/transport/http/sender/ssl/Makefile.am | 2 + src/core/transport/http/sender/ssl/ssl_stream.c | 239 ++ src/core/transport/http/sender/ssl/ssl_stream.h | 50 + src/core/transport/http/sender/ssl/ssl_utils.c | 227 ++ src/core/transport/http/sender/ssl/ssl_utils.h | 56 + src/core/transport/http/server/CGI/Makefile.am | 31 + .../transport/http/server/CGI/axis2_cgi_main.c | 280 ++ .../http/server/CGI/axis2_cgi_out_transport_info.c | 160 + .../http/server/CGI/axis2_cgi_out_transport_info.h | 62 + .../transport/http/server/CGI/axis2_cgi_stream.c | 164 + .../transport/http/server/CGI/axis2_cgi_stream.h | 44 + .../transport/http/server/CGI/axis2_cgi_types.h | 34 + src/core/transport/http/server/IIS/README | 61 + .../http/server/IIS/axis2_iis_constants.h | 51 + .../http/server/IIS/axis2_iis_out_transport_info.c | 153 + .../http/server/IIS/axis2_iis_out_transport_info.h | 61 + .../transport/http/server/IIS/axis2_iis_regedit.js | 84 + .../transport/http/server/IIS/axis2_iis_stream.c | 313 ++ .../transport/http/server/IIS/axis2_iis_stream.h | 45 + .../transport/http/server/IIS/axis2_iis_worker.c | 607 +++ .../transport/http/server/IIS/axis2_iis_worker.h | 62 + .../transport/http/server/IIS/axis2_isapi_plugin.c | 476 +++ .../IIS/iis_iaspi_plugin_51/axis2_isapi_51.c | 153 + src/core/transport/http/server/IIS/mod_axis2.def | 7 + src/core/transport/http/server/Makefile.am | 2 + src/core/transport/http/server/apache2/Makefile.am | 40 + .../server/apache2/apache2_out_transport_info.c | 191 + .../transport/http/server/apache2/apache2_stream.c | 292 ++ .../transport/http/server/apache2/apache2_stream.h | 46 + .../transport/http/server/apache2/apache2_worker.c | 1687 +++++++++ .../apache2/axis2_apache2_out_transport_info.h | 61 + .../http/server/apache2/axis2_apache2_worker.h | 78 + src/core/transport/http/server/apache2/mod_axis2.c | 844 +++++ .../http/server/simple_axis2_server/Makefile.am | 30 + .../server/simple_axis2_server/http_server_main.c | 310 ++ src/core/transport/http/util/Makefile.am | 14 + .../transport/http/util/http_transport_utils.c | 3885 ++++++++++++++++++++ src/core/transport/tcp/Makefile.am | 3 + src/core/transport/tcp/axis2_simple_tcp_svr_conn.h | 155 + src/core/transport/tcp/axis2_tcp_server.h | 60 + src/core/transport/tcp/axis2_tcp_svr_thread.h | 117 + src/core/transport/tcp/axis2_tcp_transport.h | 89 + .../transport/tcp/axis2_tcp_transport_sender.h | 59 + src/core/transport/tcp/axis2_tcp_worker.h | 95 + src/core/transport/tcp/receiver/Makefile.am | 23 + .../transport/tcp/receiver/simple_tcp_svr_conn.c | 181 + src/core/transport/tcp/receiver/tcp_receiver.c | 400 ++ src/core/transport/tcp/receiver/tcp_svr_thread.c | 297 ++ src/core/transport/tcp/receiver/tcp_worker.c | 180 + src/core/transport/tcp/sender/Makefile.am | 26 + .../transport/tcp/sender/tcp_transport_sender.c | 477 +++ src/core/transport/tcp/server/Makefile.am | 1 + .../tcp/server/simple_tcp_server/Makefile.am | 30 + .../tcp/server/simple_tcp_server/tcp_server_main.c | 262 ++ src/core/transport/transport_receiver.c | 114 + src/core/util/Makefile.am | 9 + src/core/util/core_utils.c | 1635 ++++++++ src/modules/Makefile.am | 1 + src/modules/mod_addr/Makefile.am | 21 + src/modules/mod_addr/addr_in_handler.c | 746 ++++ src/modules/mod_addr/addr_out_handler.c | 833 +++++ src/modules/mod_addr/mod_addr.c | 155 + src/modules/mod_addr/module.xml | 19 + src/modules/mod_log/Makefile.am | 22 + src/modules/mod_log/log_in_handler.c | 90 + src/modules/mod_log/log_out_handler.c | 88 + src/modules/mod_log/mod_log.c | 141 + src/modules/mod_log/mod_log.h | 50 + src/modules/mod_log/module.xml | 19 + 209 files changed, 71767 insertions(+) create mode 100644 src/Makefile.am create mode 100644 src/core/Makefile.am create mode 100644 src/core/addr/Makefile.am create mode 100644 src/core/addr/any_content_type.c create mode 100644 src/core/addr/endpoint_ref.c create mode 100644 src/core/addr/msg_info_headers.c create mode 100644 src/core/addr/relates_to.c create mode 100644 src/core/addr/svc_name.c create mode 100644 src/core/clientapi/Makefile.am create mode 100644 src/core/clientapi/async_result.c create mode 100644 src/core/clientapi/callback.c create mode 100644 src/core/clientapi/callback_recv.c create mode 100644 src/core/clientapi/listener_manager.c create mode 100644 src/core/clientapi/op_client.c create mode 100644 src/core/clientapi/options.c create mode 100644 src/core/clientapi/stub.c create mode 100644 src/core/clientapi/svc_client.c create mode 100644 src/core/context/Makefile.am create mode 100644 src/core/context/conf_ctx.c create mode 100644 src/core/context/ctx.c create mode 100644 src/core/context/msg_ctx.c create mode 100644 src/core/context/op_ctx.c create mode 100644 src/core/context/svc_ctx.c create mode 100644 src/core/context/svc_grp_ctx.c create mode 100644 src/core/deployment/Makefile.am create mode 100644 src/core/deployment/arch_file_data.c create mode 100644 src/core/deployment/arch_reader.c create mode 100644 src/core/deployment/axis2_arch_file_data.h create mode 100644 src/core/deployment/axis2_arch_reader.h create mode 100644 src/core/deployment/axis2_conf_builder.h create mode 100644 src/core/deployment/axis2_dep_engine.h create mode 100644 src/core/deployment/axis2_deployment.h create mode 100644 src/core/deployment/axis2_desc_builder.h create mode 100644 src/core/deployment/axis2_module_builder.h create mode 100644 src/core/deployment/axis2_repos_listener.h create mode 100644 src/core/deployment/axis2_svc_builder.h create mode 100644 src/core/deployment/axis2_svc_grp_builder.h create mode 100644 src/core/deployment/axis2_ws_info.h create mode 100644 src/core/deployment/axis2_ws_info_list.h create mode 100644 src/core/deployment/conf_builder.c create mode 100644 src/core/deployment/conf_init.c create mode 100644 src/core/deployment/dep_engine.c create mode 100644 src/core/deployment/desc_builder.c create mode 100644 src/core/deployment/module_builder.c create mode 100644 src/core/deployment/phases_info.c create mode 100644 src/core/deployment/repos_listener.c create mode 100644 src/core/deployment/svc_builder.c create mode 100644 src/core/deployment/svc_grp_builder.c create mode 100644 src/core/deployment/ws_info.c create mode 100644 src/core/deployment/ws_info_list.c create mode 100644 src/core/description/Makefile.am create mode 100644 src/core/description/desc.c create mode 100644 src/core/description/flow.c create mode 100644 src/core/description/flow_container.c create mode 100644 src/core/description/handler_desc.c create mode 100644 src/core/description/module_desc.c create mode 100644 src/core/description/msg.c create mode 100644 src/core/description/op.c create mode 100644 src/core/description/phase_rule.c create mode 100644 src/core/description/policy_include.c create mode 100644 src/core/description/svc.c create mode 100644 src/core/description/svc_grp.c create mode 100644 src/core/description/transport_in_desc.c create mode 100644 src/core/description/transport_out_desc.c create mode 100644 src/core/engine/Makefile.am create mode 100644 src/core/engine/addr_disp.c create mode 100644 src/core/engine/axis2_disp_checker.h create mode 100644 src/core/engine/conf.c create mode 100644 src/core/engine/ctx_handler.c create mode 100644 src/core/engine/disp.c create mode 100644 src/core/engine/disp_checker.c create mode 100644 src/core/engine/engine.c create mode 100644 src/core/engine/handler.c create mode 100644 src/core/engine/phase.c create mode 100644 src/core/engine/req_uri_disp.c create mode 100644 src/core/engine/rest_disp.c create mode 100644 src/core/engine/soap_action_disp.c create mode 100644 src/core/engine/soap_body_disp.c create mode 100644 src/core/phaseresolver/Makefile.am create mode 100644 src/core/phaseresolver/phase_holder.c create mode 100644 src/core/phaseresolver/phase_resolver.c create mode 100644 src/core/receivers/Makefile.am create mode 100644 src/core/receivers/msg_recv.c create mode 100644 src/core/receivers/raw_xml_in_out_msg_recv.c create mode 100644 src/core/receivers/svr_callback.c create mode 100644 src/core/transport/Makefile.am create mode 100644 src/core/transport/amqp/Makefile.am create mode 100644 src/core/transport/amqp/receiver/Makefile.am create mode 100644 src/core/transport/amqp/receiver/axis2_amqp_receiver.c create mode 100644 src/core/transport/amqp/receiver/axis2_amqp_receiver.h create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/Makefile.am create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.cpp create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.h create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.cpp create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.h create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.cpp create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.h create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/request_processor/Makefile.am create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.c create mode 100644 src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.h create mode 100644 src/core/transport/amqp/sender/Makefile.am create mode 100644 src/core/transport/amqp/sender/axis2_amqp_sender.c create mode 100644 src/core/transport/amqp/sender/axis2_amqp_sender.h create mode 100644 src/core/transport/amqp/sender/qpid_sender/Makefile.am create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h create mode 100644 src/core/transport/amqp/server/Makefile.am create mode 100644 src/core/transport/amqp/server/axis2_amqp_server/Makefile.am create mode 100644 src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.c create mode 100644 src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.h create mode 100644 src/core/transport/amqp/util/Makefile.am create mode 100644 src/core/transport/amqp/util/axis2_amqp_defines.h create mode 100644 src/core/transport/amqp/util/axis2_amqp_util.c create mode 100644 src/core/transport/amqp/util/axis2_amqp_util.h create mode 100644 src/core/transport/http/Makefile.am create mode 100644 src/core/transport/http/common/Makefile.am create mode 100644 src/core/transport/http/common/http_accept_record.c create mode 100644 src/core/transport/http/common/http_header.c create mode 100644 src/core/transport/http/common/http_out_transport_info.c create mode 100644 src/core/transport/http/common/http_request_line.c create mode 100644 src/core/transport/http/common/http_response_writer.c create mode 100644 src/core/transport/http/common/http_simple_request.c create mode 100644 src/core/transport/http/common/http_simple_response.c create mode 100644 src/core/transport/http/common/http_status_line.c create mode 100644 src/core/transport/http/common/http_worker.c create mode 100644 src/core/transport/http/common/simple_http_svr_conn.c create mode 100644 src/core/transport/http/receiver/Makefile.am create mode 100644 src/core/transport/http/receiver/http_receiver.c create mode 100644 src/core/transport/http/receiver/http_svr_thread.c create mode 100644 src/core/transport/http/sender/Makefile.am create mode 100644 src/core/transport/http/sender/http_client.c create mode 100644 src/core/transport/http/sender/http_sender.c create mode 100644 src/core/transport/http/sender/http_transport_sender.c create mode 100644 src/core/transport/http/sender/libcurl/Makefile.am create mode 100644 src/core/transport/http/sender/libcurl/axis2_libcurl.c create mode 100644 src/core/transport/http/sender/libcurl/axis2_libcurl.h create mode 100644 src/core/transport/http/sender/libcurl/libcurl_stream.c create mode 100644 src/core/transport/http/sender/libcurl/libcurl_stream.h create mode 100644 src/core/transport/http/sender/ssl/Makefile.am create mode 100644 src/core/transport/http/sender/ssl/ssl_stream.c create mode 100644 src/core/transport/http/sender/ssl/ssl_stream.h create mode 100644 src/core/transport/http/sender/ssl/ssl_utils.c create mode 100644 src/core/transport/http/sender/ssl/ssl_utils.h create mode 100644 src/core/transport/http/server/CGI/Makefile.am create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_main.c create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_stream.c create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_stream.h create mode 100644 src/core/transport/http/server/CGI/axis2_cgi_types.h create mode 100644 src/core/transport/http/server/IIS/README create mode 100644 src/core/transport/http/server/IIS/axis2_iis_constants.h create mode 100644 src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c create mode 100644 src/core/transport/http/server/IIS/axis2_iis_out_transport_info.h create mode 100644 src/core/transport/http/server/IIS/axis2_iis_regedit.js create mode 100644 src/core/transport/http/server/IIS/axis2_iis_stream.c create mode 100644 src/core/transport/http/server/IIS/axis2_iis_stream.h create mode 100644 src/core/transport/http/server/IIS/axis2_iis_worker.c create mode 100644 src/core/transport/http/server/IIS/axis2_iis_worker.h create mode 100644 src/core/transport/http/server/IIS/axis2_isapi_plugin.c create mode 100644 src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c create mode 100644 src/core/transport/http/server/IIS/mod_axis2.def create mode 100644 src/core/transport/http/server/Makefile.am create mode 100644 src/core/transport/http/server/apache2/Makefile.am create mode 100644 src/core/transport/http/server/apache2/apache2_out_transport_info.c create mode 100644 src/core/transport/http/server/apache2/apache2_stream.c create mode 100644 src/core/transport/http/server/apache2/apache2_stream.h create mode 100644 src/core/transport/http/server/apache2/apache2_worker.c create mode 100644 src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.h create mode 100644 src/core/transport/http/server/apache2/axis2_apache2_worker.h create mode 100644 src/core/transport/http/server/apache2/mod_axis2.c create mode 100644 src/core/transport/http/server/simple_axis2_server/Makefile.am create mode 100644 src/core/transport/http/server/simple_axis2_server/http_server_main.c create mode 100644 src/core/transport/http/util/Makefile.am create mode 100644 src/core/transport/http/util/http_transport_utils.c create mode 100644 src/core/transport/tcp/Makefile.am create mode 100644 src/core/transport/tcp/axis2_simple_tcp_svr_conn.h create mode 100644 src/core/transport/tcp/axis2_tcp_server.h create mode 100644 src/core/transport/tcp/axis2_tcp_svr_thread.h create mode 100644 src/core/transport/tcp/axis2_tcp_transport.h create mode 100644 src/core/transport/tcp/axis2_tcp_transport_sender.h create mode 100644 src/core/transport/tcp/axis2_tcp_worker.h create mode 100644 src/core/transport/tcp/receiver/Makefile.am create mode 100644 src/core/transport/tcp/receiver/simple_tcp_svr_conn.c create mode 100644 src/core/transport/tcp/receiver/tcp_receiver.c create mode 100644 src/core/transport/tcp/receiver/tcp_svr_thread.c create mode 100644 src/core/transport/tcp/receiver/tcp_worker.c create mode 100644 src/core/transport/tcp/sender/Makefile.am create mode 100644 src/core/transport/tcp/sender/tcp_transport_sender.c create mode 100644 src/core/transport/tcp/server/Makefile.am create mode 100644 src/core/transport/tcp/server/simple_tcp_server/Makefile.am create mode 100644 src/core/transport/tcp/server/simple_tcp_server/tcp_server_main.c create mode 100644 src/core/transport/transport_receiver.c create mode 100644 src/core/util/Makefile.am create mode 100644 src/core/util/core_utils.c create mode 100644 src/modules/Makefile.am create mode 100644 src/modules/mod_addr/Makefile.am create mode 100644 src/modules/mod_addr/addr_in_handler.c create mode 100644 src/modules/mod_addr/addr_out_handler.c create mode 100644 src/modules/mod_addr/mod_addr.c create mode 100644 src/modules/mod_addr/module.xml create mode 100644 src/modules/mod_log/Makefile.am create mode 100644 src/modules/mod_log/log_in_handler.c create mode 100644 src/modules/mod_log/log_out_handler.c create mode 100644 src/modules/mod_log/mod_log.c create mode 100644 src/modules/mod_log/mod_log.h create mode 100644 src/modules/mod_log/module.xml (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..1c054db --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1 @@ +SUBDIRS = core modules diff --git a/src/core/Makefile.am b/src/core/Makefile.am new file mode 100644 index 0000000..a3316e6 --- /dev/null +++ b/src/core/Makefile.am @@ -0,0 +1 @@ +SUBDIRS = addr context description phaseresolver receivers util clientapi deployment transport/http/util transport/http/common engine transport diff --git a/src/core/addr/Makefile.am b/src/core/addr/Makefile.am new file mode 100644 index 0000000..1f7512f --- /dev/null +++ b/src/core/addr/Makefile.am @@ -0,0 +1,13 @@ +noinst_LTLIBRARIES = libaxis2_addr.la + +libaxis2_addr_la_SOURCES = relates_to.c \ + svc_name.c \ + any_content_type.c \ + endpoint_ref.c \ + msg_info_headers.c + + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/addr/any_content_type.c b/src/core/addr/any_content_type.c new file mode 100644 index 0000000..1a9e6a1 --- /dev/null +++ b/src/core/addr/any_content_type.c @@ -0,0 +1,120 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_any_content_type +{ + + /** map of values in the any content type */ + axutil_hash_t *value_map; +}; + +AXIS2_EXTERN axis2_any_content_type_t *AXIS2_CALL +axis2_any_content_type_create( + const axutil_env_t * env) +{ + axis2_any_content_type_t *any_content_type = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + any_content_type = AXIS2_MALLOC(env->allocator, sizeof(axis2_any_content_type_t)); + if(!any_content_type) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + any_content_type->value_map = NULL; + + any_content_type->value_map = axutil_hash_make(env); + + if(!(any_content_type->value_map)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_any_content_type_free(any_content_type, env); + return NULL; + } + + return any_content_type; +} + +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) +{ + axis2_char_t *temp = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(any_content_type->value_map) + { + axis2_char_t *name = NULL; + + name = axutil_qname_to_string((axutil_qname_t *)qname, env); + axutil_hash_set(any_content_type->value_map, name, AXIS2_HASH_KEY_STRING, value); + + temp = axutil_hash_get(any_content_type->value_map, name, AXIS2_HASH_KEY_STRING); + if(temp) + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +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) +{ + if(any_content_type->value_map) + { + axis2_char_t *name = NULL; + + name = axutil_qname_to_string((axutil_qname_t *)qname, env); + return axutil_hash_get(any_content_type->value_map, name, AXIS2_HASH_KEY_STRING); + } + return NULL; +} + +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) +{ + return any_content_type->value_map; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_any_content_type_free( + axis2_any_content_type_t * any_content_type, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(any_content_type->value_map) + { + axutil_hash_free(any_content_type->value_map, env); + } + + AXIS2_FREE(env->allocator, any_content_type); + + return; +} diff --git a/src/core/addr/endpoint_ref.c b/src/core/addr/endpoint_ref.c new file mode 100644 index 0000000..dd351f0 --- /dev/null +++ b/src/core/addr/endpoint_ref.c @@ -0,0 +1,375 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_endpoint_ref +{ + + /** endpoint address */ + axis2_char_t *address; + + /** interface qname */ + axutil_qname_t *interface_qname; + + /** reference parameters */ + axutil_array_list_t *ref_param_list; + + /** meta data */ + axutil_array_list_t *metadata_list; + + /** reference parameter attribute list */ + axutil_array_list_t *ref_attribute_list; + + /** meta data attribute list */ + axutil_array_list_t *meta_attribute_list; + + /** extensible element list */ + axutil_array_list_t *extension_list; + + /** service name */ + axis2_svc_name_t *svc_name; +}; + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_endpoint_ref_create( + const axutil_env_t * env, + const axis2_char_t * address) +{ + axis2_endpoint_ref_t *endpoint_ref = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + endpoint_ref = AXIS2_MALLOC(env->allocator, sizeof(axis2_endpoint_ref_t)); + if(!endpoint_ref) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + endpoint_ref->address = NULL; + endpoint_ref->interface_qname = NULL; + endpoint_ref->ref_param_list = NULL; + endpoint_ref->metadata_list = NULL; + endpoint_ref->ref_attribute_list = NULL; + endpoint_ref->meta_attribute_list = NULL; + endpoint_ref->extension_list = NULL; + endpoint_ref->svc_name = NULL; + + if(address) + { + endpoint_ref->address = axutil_strdup(env, address); + if(!(endpoint_ref->address)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_endpoint_ref_free(endpoint_ref, env); + return NULL; + } + } + + return endpoint_ref; +} + +const axis2_char_t *AXIS2_CALL +axis2_endpoint_ref_get_address( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env) +{ + return endpoint_ref->address; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + if(endpoint_ref->address) + { + AXIS2_FREE(env->allocator, endpoint_ref->address); + } + + endpoint_ref->address = axutil_strdup(env, address); + return AXIS2_SUCCESS; +} + +const axutil_qname_t *AXIS2_CALL +axis2_endpoint_ref_get_interface_qname( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env) +{ + return endpoint_ref->interface_qname; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + endpoint_ref->interface_qname = axutil_qname_clone((axutil_qname_t *)interface_qname, env); + return AXIS2_SUCCESS; +} + +axis2_svc_name_t *AXIS2_CALL +axis2_endpoint_ref_get_svc_name( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env) +{ + return endpoint_ref->svc_name; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + endpoint_ref->svc_name = svc_name; + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_endpoint_ref_free_void_arg( + void *endpoint_ref, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *endpoint_ref_l = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + endpoint_ref_l = (axis2_endpoint_ref_t *)endpoint_ref; + axis2_endpoint_ref_free(endpoint_ref_l, env); + return; +} + +void AXIS2_CALL +axis2_endpoint_ref_free( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(endpoint_ref->address) + { + AXIS2_FREE(env->allocator, endpoint_ref->address); + } + + if(endpoint_ref->ref_param_list) + { + axutil_array_list_free(endpoint_ref->ref_param_list, env); + } + + if(endpoint_ref->metadata_list) + { + axutil_array_list_free(endpoint_ref->metadata_list, env); + } + + if(endpoint_ref->ref_attribute_list) + { + axutil_array_list_free(endpoint_ref->ref_attribute_list, env); + } + + if(endpoint_ref->meta_attribute_list) + { + axutil_array_list_free(endpoint_ref->meta_attribute_list, env); + } + + if(endpoint_ref->extension_list) + { + axutil_array_list_free(endpoint_ref->extension_list, env); + } + + AXIS2_FREE(env->allocator, endpoint_ref); + + return; +} + +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) +{ + return endpoint_ref->ref_param_list; +} + +axutil_array_list_t *AXIS2_CALL +axis2_endpoint_ref_get_metadata_list( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env) +{ + return endpoint_ref->metadata_list; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(!(endpoint_ref->ref_param_list)) + { + endpoint_ref->ref_param_list = axutil_array_list_create(env, 0); + if(!(endpoint_ref->ref_param_list)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + if(endpoint_ref->ref_param_list && ref_param_node) + { + return axutil_array_list_add(endpoint_ref->ref_param_list, env, ref_param_node); + } + + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +axis2_endpoint_ref_add_metadata( + axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env, + axiom_node_t * meta_data_node) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(!(endpoint_ref->metadata_list)) + { + endpoint_ref->metadata_list = axutil_array_list_create(env, 0); + if(!(endpoint_ref->metadata_list)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + if(endpoint_ref->metadata_list && meta_data_node) + { + return axutil_array_list_add(endpoint_ref->metadata_list, env, meta_data_node); + } + + return AXIS2_FAILURE; +} + +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) +{ + return endpoint_ref->ref_attribute_list; +} + +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) +{ + return endpoint_ref->meta_attribute_list; +} + +axutil_array_list_t *AXIS2_CALL +axis2_endpoint_ref_get_extension_list( + const axis2_endpoint_ref_t * endpoint_ref, + const axutil_env_t * env) +{ + return endpoint_ref->extension_list; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(!(endpoint_ref->ref_attribute_list)) + { + endpoint_ref->ref_attribute_list = axutil_array_list_create(env, 0); + if(!(endpoint_ref->ref_attribute_list)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + if(endpoint_ref->ref_attribute_list && attr) + { + return axutil_array_list_add(endpoint_ref->ref_attribute_list, env, attr); + } + + return AXIS2_FAILURE; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(!(endpoint_ref->meta_attribute_list)) + { + endpoint_ref->meta_attribute_list = axutil_array_list_create(env, 0); + if(!(endpoint_ref->meta_attribute_list)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + if(endpoint_ref->meta_attribute_list && attr) + { + return axutil_array_list_add(endpoint_ref->meta_attribute_list, env, attr); + } + + return AXIS2_FAILURE; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(!(endpoint_ref->extension_list)) + { + endpoint_ref->extension_list = axutil_array_list_create(env, 0); + if(!(endpoint_ref->extension_list)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + if(endpoint_ref->extension_list && extension_node) + { + return axutil_array_list_add(endpoint_ref->extension_list, env, extension_node); + } + + return AXIS2_FAILURE; +} diff --git a/src/core/addr/msg_info_headers.c b/src/core/addr/msg_info_headers.c new file mode 100644 index 0000000..8d61c5b --- /dev/null +++ b/src/core/addr/msg_info_headers.c @@ -0,0 +1,448 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_msg_info_headers +{ + + /** The address of the intended receiver of the message. This is mandatory */ + axis2_endpoint_ref_t *to; + + /** Reference of the endpoint where the message originated from */ + axis2_endpoint_ref_t *from; + + /** Pair of values that indicate how this message relate to another message */ + axis2_relates_to_t *relates_to; + + /** Identifies the intended receiver for replies to the message, + if this is set, none and anonymous settings are ignored */ + axis2_endpoint_ref_t *reply_to; + + /** reply to should be none */ + axis2_bool_t reply_to_none; + + /** reply to should be anonymous, this is overridden by none*/ + axis2_bool_t reply_to_anonymous; + + /** identifies the intended receiver for faults related to the message + if this is set, none and anonymous settings are ignored */ + axis2_endpoint_ref_t *fault_to; + + /** fault to should be none */ + axis2_bool_t fault_to_none; + + /** fault to should be anonymous, this is overridden by none*/ + axis2_bool_t fault_to_anonymous; + + /** action */ + axis2_char_t *action; + + /** message Id */ + axis2_char_t *message_id; + + /** reference parameters */ + axutil_array_list_t *ref_params; +}; + +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) +{ + axis2_msg_info_headers_t *msg_info_headers = NULL; + + msg_info_headers = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_info_headers_t)); + + if(!msg_info_headers) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + msg_info_headers->to = NULL; + msg_info_headers->from = NULL; + msg_info_headers->relates_to = NULL; + msg_info_headers->reply_to_none = AXIS2_FALSE; + msg_info_headers->reply_to_anonymous = AXIS2_FALSE; + msg_info_headers->reply_to = NULL; + msg_info_headers->fault_to_none = AXIS2_FALSE; + msg_info_headers->fault_to_anonymous = AXIS2_FALSE; + msg_info_headers->fault_to = NULL; + msg_info_headers->action = NULL; + msg_info_headers->message_id = NULL; + msg_info_headers->ref_params = NULL; + + if(to) + { + msg_info_headers->to = to; + } + + if(action) + { + msg_info_headers->action = axutil_strdup(env, action); + if(!(msg_info_headers->action)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_msg_info_headers_free(msg_info_headers, env); + return NULL; + } + } + + return msg_info_headers; +} + +/** + * Method getTo + * + * @return + */ +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) +{ + return msg_info_headers->to; +} + +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) +{ + if(msg_info_headers->to && to) /* if the incoming to is NULL, + we consider that to be a reset, + so don't free */ + { + axis2_endpoint_ref_free(msg_info_headers->to, env); + msg_info_headers->to = NULL; + } + msg_info_headers->to = to; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->from; +} + +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) +{ + msg_info_headers->from = from; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->reply_to; +} + +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) +{ + msg_info_headers->reply_to = reply_to; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->fault_to; +} + +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) +{ + msg_info_headers->fault_to = fault_to; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->action; +} + +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) +{ + if(msg_info_headers->action) + { + AXIS2_FREE(env->allocator, msg_info_headers->action); + msg_info_headers->action = NULL; + } + if(action) + { + msg_info_headers->action = axutil_strdup(env, action); + } + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->message_id; +} + +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) +{ + if(msg_info_headers->message_id) + { + AXIS2_FREE(env->allocator, msg_info_headers->message_id); + msg_info_headers->message_id = NULL; + } + + if(message_id) + { + msg_info_headers->message_id = axutil_stracat(env, AXIS2_MESSAGE_ID_PREFIX, message_id); + if(!(msg_info_headers->message_id)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(msg_info_headers->message_id) + { + AXIS2_FREE(env->allocator, msg_info_headers->message_id); + msg_info_headers->message_id = NULL; + } + + if(message_id) + { + msg_info_headers->message_id = axutil_strdup(env, message_id); + + if(!(msg_info_headers->message_id)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->relates_to; +} + +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) +{ + if(msg_info_headers->relates_to) + { + axis2_relates_to_free(msg_info_headers->relates_to, env); + } + msg_info_headers->relates_to = relates_to; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->ref_params; +} + +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) +{ + if(!(msg_info_headers->ref_params)) + { + msg_info_headers->ref_params = axutil_array_list_create(env, 10); + if(!(msg_info_headers->ref_params)) + return AXIS2_FAILURE; + } + + if(ref_param) + { + return axutil_array_list_add(msg_info_headers->ref_params, env, ref_param); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_msg_info_headers_free( + struct axis2_msg_info_headers *msg_info_headers, + const axutil_env_t * env) +{ + if(msg_info_headers->to) + { + axis2_endpoint_ref_free(msg_info_headers->to, env); + } + if(msg_info_headers->from) + { + axis2_endpoint_ref_free(msg_info_headers->from, env); + } + if(msg_info_headers->reply_to) + { + axis2_endpoint_ref_free(msg_info_headers->reply_to, env); + } + if(msg_info_headers->relates_to) + { + axis2_relates_to_free(msg_info_headers->relates_to, env); + } + + if(msg_info_headers->fault_to) + { + axis2_endpoint_ref_free(msg_info_headers->fault_to, env); + } + + if(msg_info_headers->ref_params) + { + axutil_array_list_free(msg_info_headers->ref_params, env); + } + if(msg_info_headers->action) + { + AXIS2_FREE(env->allocator, msg_info_headers->action); + } + if(msg_info_headers->message_id) + { + AXIS2_FREE(env->allocator, msg_info_headers->message_id); + } + + AXIS2_FREE(env->allocator, msg_info_headers); + + return; +} + +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) +{ + msg_info_headers->reply_to_none = none; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->reply_to_none; +} + +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) +{ + msg_info_headers->reply_to_anonymous = anonymous; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->reply_to_anonymous; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + msg_info_headers->fault_to_none = none; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->fault_to_none; +} + +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) +{ + msg_info_headers->fault_to_anonymous = anonymous; + return AXIS2_SUCCESS; +} + +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) +{ + return msg_info_headers->fault_to_anonymous; +} + diff --git a/src/core/addr/relates_to.c b/src/core/addr/relates_to.c new file mode 100644 index 0000000..e28df54 --- /dev/null +++ b/src/core/addr/relates_to.c @@ -0,0 +1,164 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_relates_to +{ + + /** value string */ + axis2_char_t *value; + + /** relationship type string */ + axis2_char_t *relationship_type; +}; + +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) +{ + axis2_relates_to_t *relates_to = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + relates_to = AXIS2_MALLOC(env->allocator, sizeof(axis2_relates_to_t)); + if(!relates_to) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + relates_to->value = NULL; + relates_to->relationship_type = NULL; + + if(value) + { + relates_to->value = axutil_strdup(env, value); + if(!(relates_to->value)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_relates_to_free(relates_to, env); + return NULL; + } + } + + if(relationship_type) + { + relates_to->relationship_type = axutil_strdup(env, relationship_type); + if(!(relates_to->relationship_type)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_relates_to_free(relates_to, env); + return NULL; + } + } + + return relates_to; +} + +const axis2_char_t *AXIS2_CALL +axis2_relates_to_get_value( + const axis2_relates_to_t * relates_to, + const axutil_env_t * env) +{ + return relates_to->value; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(relates_to->value) + { + AXIS2_FREE(env->allocator, relates_to->value); + } + + if(value) + { + relates_to->value = (axis2_char_t *)axutil_strdup(env, value); + if(!(relates_to->value)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_relates_to_get_relationship_type( + const axis2_relates_to_t * relates_to, + const axutil_env_t * env) +{ + return relates_to->relationship_type; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(relates_to->relationship_type) + { + AXIS2_FREE(env->allocator, relates_to->relationship_type); + } + + if(relationship_type) + { + relates_to->relationship_type = (axis2_char_t *)axutil_strdup(env, relationship_type); + if(!(relates_to->relationship_type)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_relates_to_free( + struct axis2_relates_to *relates_to, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(relates_to->value) + { + AXIS2_FREE(env->allocator, relates_to->value); + } + + if(relates_to->relationship_type) + { + AXIS2_FREE(env->allocator, relates_to->relationship_type); + } + + AXIS2_FREE(env->allocator, relates_to); + + return; +} diff --git a/src/core/addr/svc_name.c b/src/core/addr/svc_name.c new file mode 100644 index 0000000..0aa34ab --- /dev/null +++ b/src/core/addr/svc_name.c @@ -0,0 +1,151 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_svc_name +{ + + /** service QName */ + axutil_qname_t *qname; + + /** service endpoint name */ + axis2_char_t *endpoint_name; +}; + +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) +{ + axis2_svc_name_t *svc_name = NULL; + + svc_name = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_name_t)); + if(!svc_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svc_name->qname = NULL; + svc_name->endpoint_name = NULL; + + if(qname) + { + svc_name->qname = axutil_qname_clone((axutil_qname_t *)qname, env); + if(!(svc_name->qname)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_svc_name_free(svc_name, env); + return NULL; + } + } + + if(endpoint_name) + { + svc_name->endpoint_name = axutil_strdup(env, endpoint_name); + if(!(svc_name->endpoint_name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_svc_name_free(svc_name, env); + return NULL; + } + } + + return svc_name; +} + +const axutil_qname_t *AXIS2_CALL +axis2_svc_name_get_qname( + const axis2_svc_name_t * svc_name, + const axutil_env_t * env) +{ + return svc_name->qname; +} + +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) +{ + if(svc_name->qname) + { + axutil_qname_free(svc_name->qname, env); + } + + if(qname) + { + svc_name->qname = axutil_qname_clone((axutil_qname_t *)qname, env); + if(!(svc_name->qname)) + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_svc_name_get_endpoint_name( + const axis2_svc_name_t * svc_name, + const axutil_env_t * env) +{ + return svc_name->endpoint_name; +} + +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) +{ + if(svc_name->endpoint_name) + { + AXIS2_FREE(env->allocator, svc_name->endpoint_name); + } + + if(endpoint_name) + { + svc_name->endpoint_name = axutil_strdup(env, endpoint_name); + if(!(svc_name->endpoint_name)) + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_svc_name_free( + struct axis2_svc_name *svc_name, + const axutil_env_t * env) +{ + if(svc_name->qname) + { + axutil_qname_free(svc_name->qname, env); + } + + if(svc_name->endpoint_name) + { + AXIS2_FREE(env->allocator, svc_name->endpoint_name); + } + + AXIS2_FREE(env->allocator, svc_name); + + return; +} + diff --git a/src/core/clientapi/Makefile.am b/src/core/clientapi/Makefile.am new file mode 100644 index 0000000..8dead6f --- /dev/null +++ b/src/core/clientapi/Makefile.am @@ -0,0 +1,17 @@ +noinst_LTLIBRARIES = libaxis2_clientapi.la +libaxis2_clientapi_la_SOURCES = async_result.c \ + callback.c \ + listener_manager.c \ + callback_recv.c \ + stub.c \ + options.c \ + op_client.c \ + svc_client.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/util/include/platforms \ + -I$(top_builddir)/axiom/include \ + -I$(top_builddir)/neethi/include diff --git a/src/core/clientapi/async_result.c b/src/core/clientapi/async_result.c new file mode 100644 index 0000000..693e283 --- /dev/null +++ b/src/core/clientapi/async_result.c @@ -0,0 +1,83 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_async_result +{ + + /** result message context */ + axis2_msg_ctx_t *result; +}; + +AXIS2_EXTERN axis2_async_result_t *AXIS2_CALL +axis2_async_result_create( + const axutil_env_t * env, + axis2_msg_ctx_t * result) +{ + axis2_async_result_t *async_result = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + async_result = AXIS2_MALLOC(env->allocator, sizeof(axis2_async_result_t)); + if(!async_result) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create asynchronous result."); + return NULL; + } + + async_result->result = NULL; + + if(result) + { + async_result->result = result; /* shallow copy */ + } + + return async_result; +} + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_async_result_get_envelope( + axis2_async_result_t * async_result, + const axutil_env_t * env) +{ + if(async_result->result) + { + return axis2_msg_ctx_get_soap_envelope(async_result->result, env); + } + + return NULL; +} + +AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL +axis2_async_result_get_result( + axis2_async_result_t * async_result, + const axutil_env_t * env) +{ + return async_result->result; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_async_result_free( + axis2_async_result_t * async_result, + const axutil_env_t * env) +{ + AXIS2_FREE(env->allocator, async_result); +} diff --git a/src/core/clientapi/callback.c b/src/core/clientapi/callback.c new file mode 100644 index 0000000..6f875df --- /dev/null +++ b/src/core/clientapi/callback.c @@ -0,0 +1,272 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_callback +{ + + /** callback complete? */ + axis2_bool_t complete; + + /** envelope corresponding to the result */ + axiom_soap_envelope_t *envelope; + + /** message context corresponding to the result */ + axis2_msg_ctx_t *msg_ctx; + + /** error code */ + int error; + + /** to store callback specific data */ + void *data; + axutil_thread_mutex_t *mutex; + + /** + * This function is called by invoke_on_complete. + * Users could provide this method so that they can define what to be + * done when the callback returns on completion. + * @param callback pointer to callback struct + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + axis2_status_t + ( + AXIS2_CALL * on_complete) + ( + axis2_callback_t * callback, + const axutil_env_t * env); + + /** + * This function is called by report_error. + * Users could provide this method so that they can define what to be done + * when the callback returns an error. + * @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_status_t + ( + AXIS2_CALL * on_error) +( axis2_callback_t * callback, +const axutil_env_t * env, +const int exception); +}; + +static axis2_status_t AXIS2_CALL axis2_callback_on_complete( + axis2_callback_t * callback, + const axutil_env_t * env); + +static axis2_status_t AXIS2_CALL axis2_callback_on_error( + axis2_callback_t * callback, + const axutil_env_t * env, + int exception); + +AXIS2_EXTERN axis2_callback_t *AXIS2_CALL +axis2_callback_create( + const axutil_env_t * env) +{ + axis2_callback_t *callback = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + callback = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_t)); + if(!callback) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create callback."); + return NULL; + } + + callback->complete = AXIS2_FALSE; + callback->envelope = NULL; + callback->msg_ctx = NULL; + callback->error = AXIS2_ERROR_NONE; + callback->data = NULL; + callback->mutex = NULL; + callback->on_complete = axis2_callback_on_complete; + callback->on_error = axis2_callback_on_error; + + callback->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); + return callback; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + + callback->envelope = axis2_async_result_get_envelope(result, env); + callback->msg_ctx = axis2_async_result_get_result(result, env); + axis2_msg_ctx_increment_ref(callback->msg_ctx, env); /* this will be set in opclient's msgctx + map and will be deleted from there */ + + status = callback->on_complete(callback, env); + + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_callback_report_error( + axis2_callback_t * callback, + const axutil_env_t * env, + const int exception) +{ + axis2_callback_set_error(callback, env, exception); + return callback->on_error(callback, env, exception); +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_callback_get_complete( + const axis2_callback_t * callback, + const axutil_env_t * env) +{ + return callback->complete; +} + +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) +{ + callback->complete = complete; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_callback_get_envelope( + const axis2_callback_t * callback, + const axutil_env_t * env) +{ + return callback->envelope; +} + +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) +{ + callback->envelope = envelope; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL +axis2_callback_get_msg_ctx( + const axis2_callback_t * callback, + const axutil_env_t * env) +{ + return callback->msg_ctx; +} + +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) +{ + callback->msg_ctx = msg_ctx; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_callback_get_error( + const axis2_callback_t * callback, + const axutil_env_t * env) +{ + return callback->error; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_callback_set_error( + axis2_callback_t * callback, + const axutil_env_t * env, + const int error) +{ + callback->error = error; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_callback_free( + axis2_callback_t * callback, + const axutil_env_t * env) +{ + if(callback->mutex) + { + axutil_thread_mutex_destroy(callback->mutex); + } + + AXIS2_FREE(env->allocator, callback); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_callback_set_data( + axis2_callback_t * callback, + void *data) +{ + callback->data = (void *)data; + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_callback_get_data( + const axis2_callback_t * callback) +{ + return callback->data; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_callback_set_on_complete( + axis2_callback_t * callback, + axis2_on_complete_func_ptr func) +{ + callback->on_complete = func; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_callback_set_on_error( + axis2_callback_t * callback, + axis2_on_error_func_ptr func) +{ + callback->on_error = func; +} + +static axis2_status_t AXIS2_CALL +axis2_callback_on_complete( + axis2_callback_t * callback, + const axutil_env_t * env) +{ + return AXIS2_SUCCESS; +} + +static axis2_status_t AXIS2_CALL +axis2_callback_on_error( + axis2_callback_t * callback, + const axutil_env_t * env, + int exception) +{ + return AXIS2_SUCCESS; +} diff --git a/src/core/clientapi/callback_recv.c b/src/core/clientapi/callback_recv.c new file mode 100644 index 0000000..f45ed87 --- /dev/null +++ b/src/core/clientapi/callback_recv.c @@ -0,0 +1,199 @@ +/* + * 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. + */ + +#include "axis2_callback_recv.h" +#include +#include + +struct axis2_callback_recv +{ + /** base context struct */ + axis2_msg_recv_t *base; + axis2_bool_t base_deep_copy; + + /** callback map */ + axutil_hash_t *callback_map; + axutil_thread_mutex_t *mutex; +}; + +static axis2_status_t AXIS2_CALL axis2_callback_recv_receive( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + void *callback_recv_param); + +AXIS2_EXTERN axis2_callback_recv_t *AXIS2_CALL +axis2_callback_recv_create( + const axutil_env_t * env) +{ + axis2_callback_recv_t *callback_recv = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + callback_recv = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_recv_t)); + + if(!callback_recv) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create callback receive."); + return NULL; + } + + callback_recv->base = NULL; + callback_recv->base_deep_copy = AXIS2_TRUE; + callback_recv->callback_map = NULL; + callback_recv->mutex = NULL; + + callback_recv->base = axis2_msg_recv_create(env); + if(!callback_recv->base) + { + axis2_callback_recv_free(callback_recv, env); + return NULL; + } + axis2_msg_recv_set_derived(callback_recv->base, env, callback_recv); + axis2_msg_recv_set_receive(callback_recv->base, env, axis2_callback_recv_receive); + + callback_recv->callback_map = axutil_hash_make(env); + if(!callback_recv->callback_map) + { + axis2_callback_recv_free(callback_recv, env); + return NULL; + } + + callback_recv->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); + return callback_recv; +} + +AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL +axis2_callback_recv_get_base( + axis2_callback_recv_t * callback_recv, + const axutil_env_t * env) +{ + callback_recv->base_deep_copy = AXIS2_FALSE; + return callback_recv->base; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_callback_recv_free( + axis2_callback_recv_t * callback_recv, + const axutil_env_t * env) +{ + if(callback_recv->mutex) + { + axutil_thread_mutex_destroy(callback_recv->mutex); + } + + if(callback_recv->callback_map) + { + axutil_hash_index_t *hi = NULL; + const void *key = NULL; + void *val = NULL; + for(hi = axutil_hash_first(callback_recv->callback_map, env); hi; hi = axutil_hash_next( + env, hi)) + { + axutil_hash_this(hi, &key, NULL, &val); + if(key) + { + AXIS2_FREE(env->allocator, (char *)key); + } + if(val) + { + axis2_callback_t *callback = (axis2_callback_t *) val; + axis2_callback_free(callback, env); + } + + } + + axutil_hash_free(callback_recv->callback_map, env); + } + + if(callback_recv->base && callback_recv->base_deep_copy) + { + axis2_msg_recv_free(callback_recv->base, env); + } + + if(callback_recv) + { + AXIS2_FREE(env->allocator, callback_recv); + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_callback_recv_add_callback( + axis2_callback_recv_t * callback_recv, + const axutil_env_t * env, + const axis2_char_t * msg_id, + axis2_callback_t * callback) +{ + if(msg_id) + { + axis2_char_t *mid = axutil_strdup(env, msg_id); + axutil_hash_set(callback_recv->callback_map, mid, AXIS2_HASH_KEY_STRING, callback); + } + return AXIS2_SUCCESS; +} + +/* In the dual channel invocations client set a callback function to be invoked when a resonse + * is received from the server. When the response is received by the listening port of the + * listener manager, in the engine receive call the message is finally hit by callback receiver + * which is an implementation of the axis2 message receiver. This is the function that is called + * at that stage. The client set callback function is called from within here. + */ +static axis2_status_t AXIS2_CALL +axis2_callback_recv_receive( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + void *callback_recv_param) +{ + axis2_callback_recv_t *callback_recv = NULL; + axis2_relates_to_t *relates_to = NULL; + axis2_msg_info_headers_t *msg_info_headers = NULL; + + callback_recv = axis2_msg_recv_get_derived(msg_recv, env); + + msg_info_headers = axis2_msg_ctx_get_msg_info_headers(msg_ctx, env); + if(msg_info_headers) + { + relates_to = axis2_msg_info_headers_get_relates_to(msg_info_headers, env); + if(relates_to) + { + const axis2_char_t *msg_id = axis2_relates_to_get_value(relates_to, env); + if(msg_id) + { + axis2_async_result_t *result = NULL; + axis2_callback_t *callback = (axis2_callback_t *)axutil_hash_get( + callback_recv->callback_map, msg_id, AXIS2_HASH_KEY_STRING); + + result = axis2_async_result_create(env, msg_ctx); + if(callback && result) + { + axis2_callback_invoke_on_complete(callback, env, result); + axis2_callback_set_complete(callback, env, AXIS2_TRUE); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, NULL); + } + + axis2_async_result_free(result, env); + if(callback && result) + return AXIS2_SUCCESS; + } + } + } + + return AXIS2_FAILURE; +} + diff --git a/src/core/clientapi/listener_manager.c b/src/core/clientapi/listener_manager.c new file mode 100644 index 0000000..1e3e3f2 --- /dev/null +++ b/src/core/clientapi/listener_manager.c @@ -0,0 +1,302 @@ +/* + * 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. + */ + +#include +#include +#include +#include + +/** + * keep information about the listener for a given transport + */ +typedef struct axis2_transport_listener_state +{ + int waiting_calls; + + axis2_transport_receiver_t *listener; + +} axis2_transport_listener_state_t; + +struct axis2_listener_manager +{ + + /** hash map of listeners */ + axis2_transport_listener_state_t *listener_map[AXIS2_TRANSPORT_ENUM_MAX]; + axutil_thread_t *listener_thread[AXIS2_TRANSPORT_ENUM_MAX]; + + /** configuration context */ + axis2_conf_ctx_t *conf_ctx; +}; + +typedef struct axis2_listener_manager_worker_func_args +{ + const axutil_env_t *env; + axis2_listener_manager_t *listner_manager; + axis2_transport_receiver_t *listener; +} axis2_listener_manager_worker_func_args_t; + +void *AXIS2_THREAD_FUNC axis2_listener_manager_worker_func( + axutil_thread_t * thd, + void *data); + +AXIS2_EXTERN axis2_listener_manager_t *AXIS2_CALL +axis2_listener_manager_create( + const axutil_env_t * env) +{ + axis2_listener_manager_t *listener_manager = NULL; + int i = 0; + + AXIS2_ENV_CHECK(env, NULL); + + listener_manager = AXIS2_MALLOC(env->allocator, sizeof(axis2_listener_manager_t)); + + if(!listener_manager) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create listener manager."); + return NULL; + } + + listener_manager->conf_ctx = NULL; + + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + listener_manager->listener_map[i] = NULL; + listener_manager->listener_thread[i] = NULL; + } + + return listener_manager; +} + +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) +{ + axis2_transport_listener_state_t *tl_state = NULL; + + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + + if(listener_manager->conf_ctx) + { + if(conf_ctx != listener_manager->conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CLIENT_SIDE_SUPPORT_ONLY_ONE_CONF_CTX, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Only one configuration context is supported at client side."); + return AXIS2_FAILURE; + } + } + else + { + listener_manager->conf_ctx = conf_ctx; + } + + tl_state = listener_manager->listener_map[transport]; + + if(!tl_state) + { + /*means this transport not yet started, start the transport */ + axis2_transport_in_desc_t *transport_in = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_receiver_t *listener = NULL; + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + transport_in = axis2_conf_get_transport_in(conf, env, transport); + if(transport_in) + { + listener = axis2_transport_in_desc_get_recv(transport_in, env); + if(listener) + { + axutil_thread_t *worker_thread = NULL; + axis2_listener_manager_worker_func_args_t *arg_list = NULL; + arg_list = AXIS2_MALLOC(env->allocator, + sizeof(axis2_listener_manager_worker_func_args_t)); + if(!arg_list) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create listener manager worker function arguments."); + return AXIS2_FAILURE; + } + arg_list->env = env; + arg_list->listner_manager = listener_manager; + arg_list->listener = listener; +#ifdef AXIS2_SVR_MULTI_THREADED + if (env->thread_pool) + { + worker_thread = + axutil_thread_pool_get_thread(env->thread_pool, + axis2_listener_manager_worker_func, + (void *) arg_list); + if (!worker_thread) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Thread creation failed" + "Invoke non blocking failed"); + } + else + { + /*axutil_thread_pool_thread_detach(env->thread_pool, + worker_thread);*/ + /* we should not detach this, because, in the dual channel case + we should be able to terminate the thread before deleting the listener */ + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Thread pool not set in environment." + " Cannot invoke call non blocking"); + } +#else + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Threading not enabled." + " Cannot start separate listener"); + return AXIS2_FAILURE; +#endif + + tl_state = AXIS2_MALLOC(env->allocator, + sizeof(axis2_transport_listener_state_t)); + + if(!tl_state) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create transport listener state."); + } + else + { + tl_state->listener = listener; + tl_state->waiting_calls = 0; + listener_manager->listener_map[transport] = tl_state; + listener_manager->listener_thread[transport] = worker_thread; + } + } + } + } + } + + if(tl_state) + { + tl_state->waiting_calls++; + return AXIS2_SUCCESS; + } + else + return 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) +{ + axis2_transport_listener_state_t *tl_state = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_thread_t *listener_thread = NULL; + + tl_state = listener_manager->listener_map[transport]; + listener_thread = listener_manager->listener_thread[transport]; + + if(tl_state) + { + tl_state->waiting_calls--; + if(tl_state->waiting_calls == 0) + { + status = axis2_transport_receiver_stop(tl_state->listener, env); + if(status == AXIS2_SUCCESS) + listener_manager->listener_map[transport] = NULL; + } + } + + if(listener_thread) + { + axutil_thread_pool_exit_thread(env->thread_pool, listener_thread); + listener_manager->listener_thread[transport] = NULL; + } + + return status; +} + +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) +{ + axis2_transport_listener_state_t *tl_state = NULL; + + tl_state = listener_manager->listener_map[transport]; + if(tl_state) + { + return axis2_transport_receiver_get_reply_to_epr(tl_state->listener, env, svc_name); + } + return NULL; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_listener_manager_free( + axis2_listener_manager_t * listener_manager, + const axutil_env_t * env) +{ + int i = 0; + + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + if(listener_manager->listener_map[i]) + AXIS2_FREE(env->allocator, listener_manager->listener_map[i]); + } + + AXIS2_FREE(env->allocator, listener_manager); +} + +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) +{ + return listener_manager->conf_ctx; +} + +void *AXIS2_THREAD_FUNC +axis2_listener_manager_worker_func( + axutil_thread_t * thd, + void *data) +{ + axis2_listener_manager_worker_func_args_t *args_list = NULL; + const axutil_env_t *th_env = NULL; + + args_list = (axis2_listener_manager_worker_func_args_t *)data; + if(!args_list) + return NULL; + + th_env = axutil_init_thread_env(args_list->env); + /* Start the protocol server. For examlle if protocol is http axis2_http_server_start function + * of the axis2_http_receiver is called. + */ + if(args_list->listener) + { + axis2_transport_receiver_start(args_list->listener, th_env); + } + return NULL; +} diff --git a/src/core/clientapi/op_client.c b/src/core/clientapi/op_client.c new file mode 100644 index 0000000..3ccb776 --- /dev/null +++ b/src/core/clientapi/op_client.c @@ -0,0 +1,1439 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include "axis2_callback_recv.h" +#include +#include +#include +#include +#include +#include +#include + +struct axis2_op_client +{ + axis2_svc_ctx_t *svc_ctx; + + axis2_options_t *options; + + axis2_op_ctx_t *op_ctx; + + axis2_callback_t *callback; + + axis2_bool_t completed; + + /* to hold the locally created async result */ + axis2_async_result_t *async_result; + + axis2_callback_recv_t *callback_recv; + + /** message exchange pattern */ + axis2_char_t *mep; + + axis2_char_t *soap_version_uri; + axutil_string_t *soap_action; + axis2_char_t *wsa_action; + axis2_bool_t reuse; + +}; + +typedef struct axis2_op_client_worker_func_args +{ + const axutil_env_t *env; + axis2_op_client_t *op_client; + axis2_callback_t *callback; + axis2_op_t *op; + axis2_msg_ctx_t *msg_ctx; +} axis2_op_client_worker_func_args_t; + +void *AXIS2_THREAD_FUNC axis2_op_client_worker_func( + axutil_thread_t * thd, + void *data); + +static axis2_char_t *AXIS2_CALL axis2_op_client_get_transport_from_url( + const axis2_char_t * url, + const axutil_env_t * env); + +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) +{ + axis2_op_client_t *op_client = NULL; + const axis2_char_t *mep_uri = NULL; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, op, NULL); + AXIS2_PARAM_CHECK(env->error, svc_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, options, NULL); + + op_client = AXIS2_MALLOC(env->allocator, sizeof(axis2_op_client_t)); + if(!op_client) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create op client."); + return NULL; + } + + /** initialize data */ + op_client->callback = NULL; + op_client->completed = AXIS2_FALSE; + op_client->reuse = AXIS2_FALSE; + op_client->async_result = NULL; + op_client->callback_recv = NULL; + + op_client->options = options; + op_client->svc_ctx = svc_ctx; + + op_client->mep = NULL; + op_client->soap_version_uri = NULL; + op_client->soap_action = NULL; + op_client->wsa_action = NULL; + + op_client->op_ctx = axis2_op_ctx_create(env, op, op_client->svc_ctx); + if(!(op_client->op_ctx)) + { + axis2_op_client_free(op_client, env); + return NULL; + } + + mep_uri = axis2_op_get_msg_exchange_pattern(op, env); + + if(!mep_uri) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MEP_CANNOT_DETERMINE_MEP, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot find message exchange pattern uri."); + axis2_op_client_free(op_client, env); + return NULL; + } + + op_client->mep = axutil_strdup(env, mep_uri); + + op_client->soap_version_uri = axutil_strdup(env, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + if(!(op_client->soap_version_uri)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create soap version uri."); + axis2_op_client_free(op_client, env); + return NULL; + } + + /** initialize parser for thread safety */ + axiom_xml_reader_init(); + return op_client; +} + +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) +{ + if(op_client->options) + { + axis2_options_free(op_client->options, env); + } + op_client->options = (axis2_options_t *)options; + + return AXIS2_SUCCESS; +} + +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) +{ + return op_client->options; +} + +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 * mc) +{ + axis2_msg_ctx_t *out_msg_ctx = NULL, *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + /* Don't use AXIS2_PARAM_CHECK to verify op_client, as it clobbers + env->error->status_code on no error destroying the information + therein that an error has already occurred. */ + if(!op_client) + { + if(axutil_error_get_status_code(env->error) == AXIS2_SUCCESS) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + } + return AXIS2_FAILURE; + } + /* mc message context pointer may be NULL, e.g., when no response message + is received */ + + if(op_client->op_ctx) + { + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_client->op_ctx, env); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "op_ctx is NULL, unable to continue"); + return AXIS2_FAILURE; + } + + if(msg_ctx_map) + { + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "msg_ctx_map is NULL, unable to continue"); + return AXIS2_FAILURE; + } + + if(op_client->reuse) + { + /* This is the second invocation using the same service client, + so reset */ + if(out_msg_ctx) + { + axis2_msg_ctx_free(out_msg_ctx, env); + out_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL; + } + + if(in_msg_ctx) + { + axis2_msg_ctx_free(in_msg_ctx, env); + in_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = NULL; + } + + axis2_op_ctx_set_complete(op_client->op_ctx, env, AXIS2_FALSE); + op_client->reuse = AXIS2_FALSE; + } + + if(out_msg_ctx && in_msg_ctx) + { + /* may be this is the second invocation using the same service clinet, + so reset */ + axis2_msg_ctx_free(out_msg_ctx, env); + out_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL; + axis2_msg_ctx_free(in_msg_ctx, env); + in_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = NULL; + axis2_op_ctx_set_complete(op_client->op_ctx, env, AXIS2_FALSE); + } + + if(!out_msg_ctx) + { + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = mc; + } + else + { + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = mc; + axis2_op_ctx_set_complete(op_client->op_ctx, env, AXIS2_TRUE); + } + + if(out_msg_ctx && !mc) + { + axutil_property_t *dump_property; + axis2_char_t *dump_value = NULL; + if(!axis2_msg_ctx_get_doing_rest(out_msg_ctx, env)) + { + dump_property = axis2_msg_ctx_get_property(out_msg_ctx, env, AXIS2_DUMP_INPUT_MSG_TRUE); + if(dump_property) + { + dump_value = (axis2_char_t *)axutil_property_get_value(dump_property, env); + } + } + + if(axutil_strcmp(dump_value, AXIS2_VALUE_TRUE)) + { + axis2_msg_ctx_free(out_msg_ctx, env); + out_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL; + } + } + return AXIS2_SUCCESS; +} + +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 * mc) +{ + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_client->op_ctx, env); + + if(msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]) + { + axis2_msg_ctx_free(msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT], env); + } + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = mc; + + return AXIS2_SUCCESS; +} + +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 * mc) +{ + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_client->op_ctx, env); + + if(msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]) + { + axis2_msg_ctx_free(msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN], env); + } + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = mc; + + return AXIS2_SUCCESS; +} + +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) +{ + return axis2_op_ctx_get_msg_ctx(op_client->op_ctx, env, message_label); +} + +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) +{ + if(op_client->callback) + { + axis2_callback_free(op_client->callback, env); + } + + op_client->callback = callback; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_callback_t *AXIS2_CALL +axis2_op_client_get_callback( + axis2_op_client_t * op_client, + const axutil_env_t * env) +{ + return op_client->callback; +} + +/* This function is called from service client irrespective of the message exchange pattern + * and whether one/two way channel used. + */ +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) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_msg_ctx_t *msg_ctx = NULL; + + axis2_transport_out_desc_t *transport_out = NULL; + axis2_transport_in_desc_t *transport_in = NULL; + + axis2_status_t status = AXIS2_FAILURE; + axis2_op_t *op = NULL; + axis2_char_t *msg_id = NULL; + + if(op_client->completed) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Op client execute failed. Already completed."); + return AXIS2_FAILURE; + } + + conf_ctx = axis2_svc_ctx_get_conf_ctx(op_client->svc_ctx, env); + + msg_ctx = (axis2_msg_ctx_t *)axis2_op_client_get_msg_ctx(op_client, env, + AXIS2_WSDL_MESSAGE_LABEL_OUT); + + if(!msg_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Op client execute failed. Message context is not valid."); + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_options(msg_ctx, env, op_client->options); + + /** + if the transport to use for sending is not specified, try to find it + from the URL or the client option. + */ + transport_out = axis2_options_get_transport_out(op_client->options, env); + if(!transport_out) + { + axis2_endpoint_ref_t *to_epr = NULL; + axutil_property_t *property = NULL; + property = axis2_options_get_property(op_client->options, env, AXIS2_TARGET_EPR); + if(property) + { + to_epr = axutil_property_get_value(property, env); + } + + if(!to_epr) + { + to_epr = axis2_options_get_to(op_client->options, env); + } + + if(!to_epr) + { + to_epr = axis2_msg_ctx_get_to(msg_ctx, env); + } + + transport_out = axis2_op_client_infer_transport(op_client, env, to_epr); + } + + if(!transport_out) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Op client execute failed. Cannot find transport out."); + return AXIS2_FAILURE; + } + + if(!(axis2_msg_ctx_get_transport_out_desc(msg_ctx, env))) + { + axis2_msg_ctx_set_transport_out_desc(msg_ctx, env, transport_out); + } + + transport_in = axis2_options_get_transport_in(op_client->options, env); + if(!transport_in) + { + axis2_conf_ctx_t *conf_ctx = axis2_svc_ctx_get_conf_ctx(op_client->svc_ctx, env); + + if(conf_ctx) + { + axis2_conf_t *conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + transport_in = axis2_conf_get_transport_in(conf, env, + axis2_transport_out_desc_get_enum(transport_out, env)); + } + } + } + if(!transport_in) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Op client execute failed. Cannot find transport in."); + return AXIS2_FAILURE; + } + + if(!(axis2_msg_ctx_get_transport_in_desc(msg_ctx, env))) + { + axis2_msg_ctx_set_transport_in_desc(msg_ctx, env, transport_in); + } + + op = axis2_op_ctx_get_op(op_client->op_ctx, env); + + if(!op) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Op client execute failed. Cannot find operation."); + return AXIS2_FAILURE; + } + status = axis2_op_client_prepare_invocation(op_client, env, op, msg_ctx); + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Op client execute failed. Preparing for invocation failed."); + return AXIS2_FAILURE; + } + msg_id = (axis2_char_t *)axutil_uuid_gen(env); + axis2_msg_ctx_set_message_id(msg_ctx, env, msg_id); + if(msg_id) + { + AXIS2_FREE(env->allocator, msg_id); + msg_id = NULL; + } + + /* If dual channel. */ + if(axis2_options_get_use_separate_listener(op_client->options, env)) + { + axis2_engine_t *engine = NULL; + + if(op_client->callback) + { + AXIS2_CALLBACK_RECV_ADD_CALLBACK(op_client->callback_recv, env, + axis2_msg_ctx_get_msg_id(msg_ctx, env), op_client->callback); + } + + axis2_msg_ctx_set_op_ctx(msg_ctx, env, axis2_op_find_op_ctx(op, env, msg_ctx, + op_client-> svc_ctx)); + axis2_msg_ctx_set_svc_ctx(msg_ctx, env, op_client->svc_ctx); + + /* send the message */ + engine = axis2_engine_create(env, conf_ctx); + if(!engine) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Op client execute failed due to engine creation failure."); + return AXIS2_FAILURE; + } + axis2_engine_send(engine, env, msg_ctx); + axis2_engine_free(engine, env); + } + else /* Same channel will be used irrespective of message exchange pattern. */ + { + if(block) + { + axis2_msg_ctx_t *response_mc = NULL; + + axis2_msg_ctx_set_svc_ctx(msg_ctx, env, op_client->svc_ctx); + axis2_msg_ctx_set_conf_ctx(msg_ctx, env, axis2_svc_ctx_get_conf_ctx( + op_client-> svc_ctx, env)); + axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_client->op_ctx); + + /*Send the SOAP Message and receive a response */ + response_mc = axis2_op_client_two_way_send(env, msg_ctx); + if(!response_mc) + { + const axis2_char_t *mep = axis2_op_get_msg_exchange_pattern(op, env); + if(!(axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY)) || !(axutil_strcmp(mep, + AXIS2_MEP_URI_ROBUST_OUT_ONLY))) + { + if(env->error) + { + return env->error->status_code; + } + else + { + return AXIS2_FAILURE; + } + } + else + { + return AXIS2_FAILURE; + } + } + axis2_op_client_add_msg_ctx(op_client, env, response_mc); + } + else + { + axis2_op_client_worker_func_args_t *arg_list = NULL; + arg_list = AXIS2_MALLOC(env->allocator, sizeof(axis2_op_client_worker_func_args_t)); + if(!arg_list) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create op client worker function argument list."); + return AXIS2_FAILURE; + } + arg_list->env = env; + arg_list->op_client = op_client; + arg_list->callback = op_client->callback; + arg_list->op = op; + arg_list->msg_ctx = msg_ctx; +#ifdef AXIS2_SVR_MULTI_THREADED + if (env->thread_pool) + { + axutil_thread_t *worker_thread = NULL; + worker_thread = axutil_thread_pool_get_thread(env->thread_pool, + axis2_op_client_worker_func, + (void *) + arg_list); + if (!worker_thread) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Thread creation failed call invoke non blocking"); + } + else + { + axutil_thread_pool_thread_detach(env->thread_pool, + worker_thread); + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Thread pool not set in environment" + "Cannot invoke call non blocking"); + } +#else + axis2_op_client_worker_func(NULL, (void *)arg_list); +#endif + + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_client_reset( + axis2_op_client_t * op_client, + const axutil_env_t * env) +{ + if(!op_client->completed) + return AXIS2_FAILURE; + + op_client->completed = AXIS2_FALSE; + + op_client->op_ctx = NULL; + + return AXIS2_SUCCESS; +} + +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 * mc) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_listener_manager_t *listener_manager = NULL; + AXIS2_TRANSPORT_ENUMS transport = AXIS2_TRANSPORT_ENUM_HTTP; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(mc, env); + + if(!conf_ctx) + return AXIS2_FAILURE; + + if(!listener_manager) + return AXIS2_FAILURE; + + return axis2_listener_manager_stop(listener_manager, env, transport); +} + +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) +{ + return op_client->op_ctx; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_op_client_free( + axis2_op_client_t * op_client, + const axutil_env_t * env) +{ + if(!op_client) + return; + + /*if(op_client->callback) + { + axis2_callback_free(op_client->callback, env); + }*/ + + if(op_client->op_ctx) + { + axis2_op_ctx_free(op_client->op_ctx, env); + op_client->op_ctx = NULL; + } + + if(op_client->soap_version_uri) + { + AXIS2_FREE(env->allocator, op_client->soap_version_uri); + } + + if(op_client->mep) + { + AXIS2_FREE(env->allocator, op_client->mep); + } + + if(axis2_options_get_xml_parser_reset(op_client->options, env)) + { + axiom_xml_reader_cleanup(); + } + + AXIS2_FREE(env->allocator, op_client); +} + +/* This function is the thread worker function for the single channel non blocking case. Here + * being non-blocking implies that message is two way. */ +void *AXIS2_THREAD_FUNC +axis2_op_client_worker_func( + axutil_thread_t * thd, + void *data) +{ + axis2_op_client_worker_func_args_t *args_list = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_msg_ctx_t *response = NULL; + axutil_env_t *th_env = NULL; + axutil_thread_pool_t *th_pool = NULL; + + args_list = (axis2_op_client_worker_func_args_t *)data; + if(!args_list) + { + return NULL; + } + + th_env = axutil_init_thread_env(args_list->env); + + op_ctx = axis2_op_ctx_create(th_env, args_list->op, args_list->op_client->svc_ctx); + if(!op_ctx) + { + return NULL; + } + axis2_msg_ctx_set_op_ctx(args_list->msg_ctx, th_env, op_ctx); + axis2_msg_ctx_set_svc_ctx(args_list->msg_ctx, th_env, args_list->op_client->svc_ctx); + + /* send the request and wait for response */ + response = axis2_op_client_two_way_send(th_env, args_list->msg_ctx); + + /* We do not need to handle the NULL response here because this thread function is called only + * in the single channel non blocking case which, imply this is two way message by design. + */ + + /* Here after the code is a subset of what callback receiver do in dual channel case.*/ + axis2_op_client_add_msg_ctx(args_list->op_client, th_env, response); + args_list->op_client->async_result = axis2_async_result_create(th_env, response); + + if(args_list->callback) + { + axis2_callback_invoke_on_complete(args_list->callback, th_env, + args_list->op_client->async_result); + + axis2_callback_set_complete(args_list->callback, th_env, AXIS2_TRUE); + } + + /* Clean up memory */ + axis2_async_result_free(args_list->op_client->async_result, th_env); + + axis2_op_ctx_free(op_ctx, th_env); + + th_pool = th_env->thread_pool; + + AXIS2_FREE(th_env->allocator, args_list); + + if(th_env) + { + axutil_free_thread_env(th_env); + th_env = NULL; + } + axutil_thread_pool_exit_thread(th_pool, thd); + return NULL; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_client_set_callback_recv( + axis2_op_client_t * op_client, + const axutil_env_t * env, + axis2_callback_recv_t * callback_recv) +{ + op_client->callback_recv = callback_recv; + return AXIS2_SUCCESS; +} + +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) +{ + return op_client->soap_action; +} + +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) +{ + axis2_svc_t *svc = NULL; + + AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + /* make sure operation's MEP is the same as given MEP */ + if(op_client->mep) + { + if(axutil_strcmp(op_client->mep, axis2_op_get_msg_exchange_pattern(op, env))) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MEP_MISMATCH_IN_MEP_CLIENT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Message exchange pattern of op client and operation are different."); + return AXIS2_FAILURE; + } + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MEP_CANNOT_BE_NULL_IN_MEP_CLIENT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Message exchange pattern of op client is not valid."); + return AXIS2_FAILURE; + } + /* If operation has a parent service get it */ + svc = axis2_op_get_parent(op, env); + if(svc) + { + axis2_svc_ctx_set_svc(op_client->svc_ctx, env, svc); + } + else + { + svc = axis2_svc_ctx_get_svc(op_client->svc_ctx, env); + if(svc) + { + axis2_op_t *temp_op = NULL; + const axutil_qname_t *op_qname = axis2_op_get_qname(op, env); + temp_op = axis2_svc_get_op_with_qname(svc, env, op_qname); + if(!temp_op) + { + axis2_svc_add_op(svc, env, op); + } + } + } + + if(op_client->wsa_action) + { + axis2_msg_ctx_set_wsa_action(msg_ctx, env, op_client->wsa_action); + } + + if(op_client->soap_action) + { + axis2_msg_ctx_set_soap_action(msg_ctx, env, op_client->soap_action); + } + + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_ctx_t *msg_ctx = NULL; + axiom_soap_envelope_t *envelope = NULL; + int soap_version = AXIOM_SOAP12; + + if(op_client->svc_ctx) + { + msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(op_client-> svc_ctx, env), + NULL, NULL); + } + + if(!msg_ctx) + { + return NULL; + } + + if(op_client->soap_version_uri) + { + if(!(axutil_strcmp(op_client->soap_version_uri, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI))) + soap_version = AXIOM_SOAP11; + else + soap_version = AXIOM_SOAP12; + } + + envelope = axiom_soap_envelope_create_default_soap_envelope(env, soap_version); + if(!envelope) + { + return NULL; + } + + if(to_send) + { + axiom_soap_body_t *soap_body = NULL; + soap_body = axiom_soap_envelope_get_body(envelope, env); + if(soap_body) + { + axiom_node_t *node = NULL; + node = axiom_soap_body_get_base_node(soap_body, env); + if(node) + { + axiom_node_add_child(node, env, to_send); + } + } + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, envelope); + + return msg_ctx; +} + +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) +{ + axis2_char_t *transport = NULL; + axis2_transport_out_desc_t *transport_out_desc = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_MAX; + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Start:axis2_op_client_infer_transport"); + + /* We first try the client option */ + transport_enum = axis2_options_get_sender_transport_protocol(op_client->options, env); + if(transport_enum == AXIS2_TRANSPORT_ENUM_MAX) + { + /* If we couldn't find the transport we default to HTTP */ + transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + /* We try to infer transport from the url */ + if(epr) + { + const axis2_char_t *to_url = axis2_endpoint_ref_get_address(epr, env); + + transport = axis2_op_client_get_transport_from_url(to_url, env); + } + + if(transport) + { + if(!axutil_strcmp(transport, AXIS2_TRANSPORT_HTTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + } + else if(!axutil_strcmp(transport, AXIS2_TRANSPORT_HTTPS)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTPS; + } + else if(!axutil_strcmp(transport, AXIS2_TRANSPORT_XMPP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_XMPP; + } + else if(!axutil_strcmp(transport, AXIS2_TRANSPORT_TCP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_TCP; + } + else if(!axutil_strcmp(transport, AXIS2_TRANSPORT_AMQP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_AMQP; + } + else if(!axutil_strcmp(transport, AXIS2_TRANSPORT_UDP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_UDP; + } + + AXIS2_FREE(env->allocator, transport); + transport = NULL; + } + } + conf_ctx = axis2_svc_ctx_get_conf_ctx(op_client->svc_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + transport_out_desc = axis2_conf_get_transport_out(conf, env, transport_enum); + } + } + if(!transport_out_desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot infer transport"); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CANNOT_INFER_TRANSPORT, AXIS2_FAILURE); + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "End:axis2_op_client_infer_transport"); + return transport_out_desc; +} + +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) +{ + axiom_soap_envelope_t *envelope = NULL; + + if(!(axutil_strcmp(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, op_client->soap_version_uri))) + { + envelope = axiom_soap_envelope_create_with_soap_version_prefix(env, AXIOM_SOAP12, NULL); + } + + if(!(axutil_strcmp(AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, op_client->soap_version_uri))) + { + envelope = axiom_soap_envelope_create_with_soap_version_prefix(env, AXIOM_SOAP11, NULL); + } + return envelope; +} + +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) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + + if(op_client->svc_ctx) + { + conf_ctx = axis2_svc_ctx_get_conf_ctx(op_client->svc_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + /*if it is already engaged do not engage it again */ + if(!(axis2_conf_is_engaged(conf, env, qname))) + { + return axis2_conf_engage_module(conf, env, qname); + } + } + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(op_client->soap_version_uri) + { + AXIS2_FREE(env->allocator, op_client->soap_version_uri); + op_client->soap_version_uri = NULL; + } + + if(soap_version_uri) + { + op_client->soap_version_uri = axutil_strdup(env, soap_version_uri); + if(!(op_client->soap_version_uri)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create soap version uri."); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(op_client->soap_action) + { + axutil_string_free(op_client->soap_action, env); + op_client->soap_action = NULL; + } + + if(soap_action) + { + op_client->soap_action = axutil_string_clone(soap_action, env); + if(!(op_client->soap_action)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create soap action."); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(op_client->wsa_action) + { + AXIS2_FREE(env->allocator, op_client->wsa_action); + op_client->wsa_action = NULL; + } + + if(wsa_action) + { + op_client->wsa_action = axutil_strdup(env, wsa_action); + if(!(op_client->wsa_action)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create wsa action."); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +static axis2_char_t *AXIS2_CALL +axis2_op_client_get_transport_from_url( + const axis2_char_t * url, + const axutil_env_t * env) +{ + axis2_char_t *transport = NULL; + const axis2_char_t *start = NULL; + const axis2_char_t *end = NULL; + AXIS2_PARAM_CHECK(env->error, url, NULL); + start = url; + end = url; + while((*end) && (*end) != ':') + end++; + + if((*end) == ':') + { + const axis2_char_t *c = NULL; + transport = AXIS2_MALLOC(env->allocator, (end - start + 1) * sizeof(char)); + if(!transport) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create transport protocol identifier."); + return NULL; + } + + for(c = start; c < end; c++) + transport[c - start] = *c; + transport[c - start] = '\0'; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "URL is malformed or does not contain a transport protocol"); + } + return transport; +} + +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) +{ + return op_client->svc_ctx; +} + +/* This function is called only for single channel invocations */ +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) +{ + axis2_engine_t *engine = NULL; + axis2_status_t status = AXIS2_SUCCESS; + axis2_msg_ctx_t *response = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_op_t *op = NULL; + axiom_soap_envelope_t *response_envelope = NULL; + axutil_property_t *property = NULL; + long index = -1; + axis2_bool_t wait_indefinitely = AXIS2_FALSE; + axis2_char_t *mep = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + engine = axis2_engine_create(env, conf_ctx); + if(!engine) + return NULL; + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_TIMEOUT_IN_SECONDS); + if(property) + { + axis2_char_t *value = axutil_property_get_value(property, env); + if(value) + index = AXIS2_ATOI(value); + if(index == -1) + { + wait_indefinitely = AXIS2_TRUE; + index = 1; + } + } + + status = axis2_engine_send(engine, env, msg_ctx); + + axis2_engine_free(engine, env); + engine = NULL; + + if(status != AXIS2_SUCCESS) + { + if(AXIS2_ERROR_GET_STATUS_CODE(env->error) == AXIS2_SUCCESS) + { + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE); + } + return NULL; + } + + op = axis2_msg_ctx_get_op(msg_ctx, env); + if(op) + { + mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op, env); + } + + if(!mep) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MEP_CANNOT_DETERMINE_MEP, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot determine message exchange pattern."); + return NULL; + } + + /* handle one way non robust case */ + if(!(axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY))) + { + return NULL; + } + + /* create the response */ + response = axis2_msg_ctx_create(env, conf_ctx, + axis2_msg_ctx_get_transport_in_desc(msg_ctx, env), axis2_msg_ctx_get_transport_out_desc( + msg_ctx, env)); + if(!response) + return NULL; + + axis2_msg_ctx_set_server_side(response, env, AXIS2_FALSE); + axis2_msg_ctx_set_conf_ctx(response, env, axis2_msg_ctx_get_conf_ctx(msg_ctx, env)); + axis2_msg_ctx_set_svc_grp_ctx(response, env, axis2_msg_ctx_get_svc_grp_ctx(msg_ctx, env)); + + /* If request is REST we assume the response is REST, so set the variable */ + axis2_msg_ctx_set_doing_rest(response, env, axis2_msg_ctx_get_doing_rest(msg_ctx, env)); + axis2_msg_ctx_set_status_code(response, env, axis2_msg_ctx_get_status_code(msg_ctx, env)); + + if(op) + { + axis2_op_register_op_ctx(op, env, response, axis2_msg_ctx_get_op_ctx(msg_ctx, env)); + } + + /* set response envelope */ + if(engine) + { + axis2_engine_free(engine, env); + engine = NULL; + } + response_envelope = axis2_msg_ctx_get_response_soap_envelope(msg_ctx, env); + if(response_envelope) + { + axis2_msg_ctx_set_soap_envelope(response, env, response_envelope); + engine = axis2_engine_create(env, conf_ctx); + if(engine) + { + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HANDLER_ALREADY_VISITED); + if(property) + { + axis2_char_t *value = axutil_property_get_value(property, env); + if(!axutil_strcmp(AXIS2_VALUE_TRUE, value)) + { + if(engine) + { + axis2_engine_free(engine, env); + } + return response; + } + } + status = axis2_engine_receive(engine, env, response); + } + } + else + { + while(!response_envelope && index > 0) + { + /*wait till the response arrives */ + AXIS2_SLEEP(1); + if(!wait_indefinitely) + index--; + response_envelope = axis2_msg_ctx_get_response_soap_envelope(msg_ctx, env); + } + /* if it is a two way message, then the status should be in error, + else it is a one way message */ + if(response_envelope) + { + axis2_msg_ctx_set_soap_envelope(response, env, response_envelope); + /* There could be a scenariao where the message has already passed + * through the incoming phases. eg. Reliable Messaging 1.0 two + * way single channel + */ + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HANDLER_ALREADY_VISITED); + if(property) + { + axis2_char_t *value = axutil_property_get_value(property, env); + if(!axutil_strcmp(AXIS2_VALUE_TRUE, value)) + { + return response; + } + } + engine = axis2_engine_create(env, conf_ctx); + if(engine) + { + status = axis2_engine_receive(engine, env, response); + if(status != AXIS2_SUCCESS) + return NULL; + } + } + else + { + if(AXIS2_ERROR_GET_STATUS_CODE(env->error) != AXIS2_SUCCESS) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BLOCKING_INVOCATION_EXPECTS_RESPONSE, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Response is not valid. Blocking invocation expects response."); + if(engine) + { + axis2_engine_free(engine, env); + engine = NULL; + } + axis2_msg_ctx_free(response, env); + return NULL; + } + } + } + + /*following is no longer valid. Just keeping for others view*/ + + /* property is NULL, and we set null for AXIS2_TRANSPORT_IN in msg_ctx to + avoid double free of this property */ + /*axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, property);*/ + + if(engine) + { + axis2_engine_free(engine, env); + engine = NULL; + } + if(!(axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_OUT_ONLY)) && response) + { + if(axis2_msg_ctx_get_doing_rest(response, env) && axis2_msg_ctx_get_status_code(response, + env) >= 400) + { + /* All HTTP 4xx and 5xx status codes are treated as errors */ + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "HTTP client transport error."); + return NULL; + } + switch(axis2_msg_ctx_get_status_code(response, env)) + { + /* In a SOAP request HTTP status code 500 is used for errors */ + case 500: + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "HTTP client transport error."); + break; + case 0: + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BLOCKING_INVOCATION_EXPECTS_RESPONSE, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Response is not valid. Blocking invocation expects response."); + break; + case -1: + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BLOCKING_INVOCATION_EXPECTS_RESPONSE, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Response is not valid. Blocking invocation expects response."); + break; + } + + if(response) + { + axis2_msg_ctx_free(response, env); + } + + return NULL; + } + return response; +} + +AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL +axis2_op_client_receive( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_engine_t *engine = NULL; + axis2_status_t status = AXIS2_SUCCESS; + axis2_msg_ctx_t *response = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_op_t *op = NULL; + axiom_soap_envelope_t *response_envelope = NULL; + axutil_property_t *property = NULL; + + /* create the response */ + response = axis2_msg_ctx_create(env, conf_ctx, + axis2_msg_ctx_get_transport_in_desc(msg_ctx, env), axis2_msg_ctx_get_transport_out_desc( + msg_ctx, env)); + if(!response) + return NULL; + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_TRANSPORT_IN); + if(property) + { + axis2_msg_ctx_set_property(response, env, AXIS2_TRANSPORT_IN, property); + property = NULL; + } + + op = axis2_msg_ctx_get_op(msg_ctx, env); + if(op) + { + axis2_op_register_op_ctx(op, env, response, axis2_msg_ctx_get_op_ctx(msg_ctx, env)); + } + axis2_msg_ctx_set_server_side(response, env, AXIS2_FALSE); + axis2_msg_ctx_set_conf_ctx(response, env, axis2_msg_ctx_get_conf_ctx(msg_ctx, env)); + axis2_msg_ctx_set_svc_grp_ctx(response, env, axis2_msg_ctx_get_svc_grp_ctx(msg_ctx, env)); + + /* If request is REST we assume the response is REST, so set the variable */ + axis2_msg_ctx_set_doing_rest(response, env, axis2_msg_ctx_get_doing_rest(msg_ctx, env)); + + response_envelope = axis2_msg_ctx_get_response_soap_envelope(msg_ctx, env); + if(response_envelope) + { + axis2_msg_ctx_set_soap_envelope(response, env, response_envelope); + if(engine) + { + axis2_engine_free(engine, env); + engine = NULL; + } + + engine = axis2_engine_create(env, conf_ctx); + if(engine) + { + status = axis2_engine_receive(engine, env, response); + if(status != AXIS2_SUCCESS) + { + return NULL; + } + } + + } + else + { + /* if it is a two way message, then the status should be in error, + else it is a one way message */ + if(AXIS2_ERROR_GET_STATUS_CODE(env->error) != AXIS2_SUCCESS) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BLOCKING_INVOCATION_EXPECTS_RESPONSE, + AXIS2_FAILURE); + return NULL; + } + } + + /* property is NULL, and we set null for AXIS2_TRANSPORT_IN in msg_ctx to + avoid double free of this property */ + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, property); + + if(engine) + { + axis2_engine_free(engine, env); + engine = NULL; + } + return response; +} + +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) +{ + op_client->reuse = reuse; +} diff --git a/src/core/clientapi/options.c b/src/core/clientapi/options.c new file mode 100644 index 0000000..26c5d33 --- /dev/null +++ b/src/core/clientapi/options.c @@ -0,0 +1,1068 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +struct axis2_options +{ + + /** parent options */ + axis2_options_t *parent; + + axutil_hash_t *properties; + + axis2_char_t *soap_version_uri; + + int soap_version; + + long timeout_in_milli_seconds; + + axis2_bool_t use_separate_listener; + + /** addressing specific properties */ + axis2_msg_info_headers_t *msg_info_headers; + + axis2_transport_receiver_t *receiver; + + axis2_transport_in_desc_t *transport_in; + + AXIS2_TRANSPORT_ENUMS transport_in_protocol; + + /** for sending and receiving messages */ + axis2_transport_out_desc_t *transport_out; + AXIS2_TRANSPORT_ENUMS sender_transport_protocol; + + axis2_bool_t manage_session; + axis2_bool_t enable_mtom; + axutil_string_t *soap_action; + axis2_bool_t xml_parser_reset; +}; + +AXIS2_EXTERN axis2_options_t *AXIS2_CALL +axis2_options_create( + const axutil_env_t * env) +{ + axis2_options_t *options = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + options = AXIS2_MALLOC(env->allocator, sizeof(axis2_options_t)); + if(!options) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create options."); + return NULL; + } + + options->parent = NULL; + options->properties = NULL; + options->soap_version_uri = NULL; + options->timeout_in_milli_seconds = -1; + options->use_separate_listener = -1; + options->receiver = NULL; + options->transport_in = NULL; + options->transport_in_protocol = AXIS2_TRANSPORT_ENUM_MAX; + options->transport_out = NULL; + options->sender_transport_protocol = AXIS2_TRANSPORT_ENUM_MAX; + options->manage_session = -1; + options->soap_version = AXIOM_SOAP12; + options->enable_mtom = AXIS2_FALSE; + options->soap_action = NULL; + options->xml_parser_reset = AXIS2_TRUE; + + options->msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL); + if(!options->msg_info_headers) + { + axis2_options_free(options, env); + return NULL; + } + + options->properties = axutil_hash_make(env); + if(!options->properties) + { + axis2_options_free(options, env); + return NULL; + } + + return options; +} + +AXIS2_EXTERN axis2_options_t *AXIS2_CALL +axis2_options_create_with_parent( + const axutil_env_t * env, + axis2_options_t * parent) +{ + + axis2_options_t *options = NULL; + + options = axis2_options_create(env); + + if(options) + { + options->parent = parent; + } + return options; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_options_get_action( + const axis2_options_t * options, + const axutil_env_t * env) +{ + const axis2_char_t *action = NULL; + action = axis2_msg_info_headers_get_action(options->msg_info_headers, env); + + if(!action && options->parent) + { + return axis2_options_get_action(options->parent, env); + } + + return action; +} + +AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL +axis2_options_get_fault_to( + const axis2_options_t * options, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *fault_to = NULL; + + fault_to = axis2_msg_info_headers_get_fault_to(options->msg_info_headers, env); + + if(!fault_to && options->parent) + { + return axis2_options_get_fault_to(options->parent, env); + } + + return fault_to; +} + +AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL +axis2_options_get_from( + const axis2_options_t * options, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *from = NULL; + + from = axis2_msg_info_headers_get_from(options->msg_info_headers, env); + + if(!from && options->parent) + { + return axis2_options_get_from(options->parent, env); + } + + return from; +} + +AXIS2_EXTERN axis2_transport_receiver_t *AXIS2_CALL +axis2_options_get_transport_receiver( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(!options->receiver && options->parent) + { + return axis2_options_get_transport_receiver(options->parent, env); + } + + return options->receiver; +} + +AXIS2_EXTERN axis2_transport_in_desc_t *AXIS2_CALL +axis2_options_get_transport_in( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(!options->transport_in && options->parent) + { + return axis2_options_get_transport_in(options->parent, env); + } + + return options->transport_in; +} + +AXIS2_EXTERN AXIS2_TRANSPORT_ENUMS AXIS2_CALL +axis2_options_get_transport_in_protocol( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(options->parent) + { + return axis2_options_get_transport_in_protocol(options->parent, env); + } + + return options->transport_in_protocol; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_options_get_message_id( + const axis2_options_t * options, + const axutil_env_t * env) +{ + const axis2_char_t *message_id = NULL; + + message_id = axis2_msg_info_headers_get_message_id(options->msg_info_headers, env); + + if(!message_id && options->parent) + { + return axis2_options_get_message_id(options->parent, env); + } + + return message_id; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_options_get_properties( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(!axutil_hash_count(options->properties) && options->parent) + { + return axis2_options_get_properties(options->parent, env); + } + + return options->properties; +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_options_get_property( + const axis2_options_t * options, + const axutil_env_t * env, + const axis2_char_t * key) +{ + void *property = NULL; + + property = axutil_hash_get(options->properties, key, AXIS2_HASH_KEY_STRING); + + if(!property && options->parent) + { + return axis2_options_get_property(options->parent, env, key); + } + + return property; +} + +AXIS2_EXTERN axis2_relates_to_t *AXIS2_CALL +axis2_options_get_relates_to( + const axis2_options_t * options, + const axutil_env_t * env) +{ + axis2_relates_to_t *relates_to = NULL; + + relates_to = axis2_msg_info_headers_get_relates_to(options->msg_info_headers, env); + + if(!relates_to && options->parent) + { + return axis2_options_get_relates_to(options->parent, env); + } + + return relates_to; +} + +AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL +axis2_options_get_reply_to( + const axis2_options_t * options, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *reply_to = NULL; + + reply_to = axis2_msg_info_headers_get_reply_to(options->msg_info_headers, env); + + if(!reply_to && options->parent) + { + return axis2_options_get_reply_to(options->parent, env); + } + + return reply_to; +} + +AXIS2_EXTERN axis2_transport_out_desc_t *AXIS2_CALL +axis2_options_get_transport_out( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(!options->transport_out && options->parent) + { + return axis2_options_get_transport_out(options->parent, env); + } + + return options->transport_out; +} + +AXIS2_EXTERN AXIS2_TRANSPORT_ENUMS AXIS2_CALL +axis2_options_get_sender_transport_protocol( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(options->parent) + { + return axis2_options_get_sender_transport_protocol(options->parent, env); + } + + return options->sender_transport_protocol; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_options_get_soap_version_uri( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(!options->soap_version_uri && options->parent) + { + return axis2_options_get_soap_version_uri(options->parent, env); + } + + if(options->soap_version_uri) + { + return options->soap_version_uri; + } + return AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; + +} + +AXIS2_EXTERN long AXIS2_CALL +axis2_options_get_timeout_in_milli_seconds( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(options->timeout_in_milli_seconds == -1) + { + if(options->parent) + { + return axis2_options_get_timeout_in_milli_seconds(options->parent, env); + } + else + { + return AXIS2_DEFAULT_TIMEOUT_MILLISECONDS; + } + } + + return options->timeout_in_milli_seconds; +} + +AXIS2_EXTERN axis2_endpoint_ref_t *AXIS2_CALL +axis2_options_get_to( + const axis2_options_t * options, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *to = NULL; + + to = axis2_msg_info_headers_get_to(options->msg_info_headers, env); + + if(!to && options->parent) + { + return axis2_options_get_to(options->parent, env); + } + + return to; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_options_get_use_separate_listener( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(options->use_separate_listener == -1) + { + if(options->parent) + { + return axis2_options_get_use_separate_listener(options->parent, env); + } + else + { + return AXIS2_FALSE; + } + } + + return options->use_separate_listener; +} + +AXIS2_EXTERN axis2_options_t *AXIS2_CALL +axis2_options_get_parent( + const axis2_options_t * options, + const axutil_env_t * env) +{ + return options->parent; +} + +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) +{ + options->parent = (axis2_options_t *)parent; + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_set_action(options->msg_info_headers, env, action); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_set_fault_to(options->msg_info_headers, env, fault_to); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_set_from(options->msg_info_headers, env, from); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_set_to(options->msg_info_headers, env, to); + return AXIS2_SUCCESS; +} + +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) +{ + options->receiver = receiver; + return AXIS2_SUCCESS; +} + +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) +{ + options->transport_in = transport_in; + return AXIS2_SUCCESS; +} + +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) +{ + options->transport_in_protocol = transport_in_protocol; + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_set_message_id(options->msg_info_headers, env, message_id); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_options_set_properties( + axis2_options_t * options, + const axutil_env_t * env, + axutil_hash_t * properties) +{ + if(options->properties) + { + axutil_hash_free(options->properties, env); + } + options->properties = properties; + return AXIS2_SUCCESS; +} + +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) +{ + axutil_hash_set(options->properties, property_key, AXIS2_HASH_KEY_STRING, property); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_set_relates_to(options->msg_info_headers, env, relates_to); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_set_reply_to(options->msg_info_headers, env, reply_to); + return AXIS2_SUCCESS; +} + +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) +{ + options->transport_out = transport_out; + return AXIS2_SUCCESS; +} + +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) +{ + options->transport_out = axis2_conf_get_transport_out(conf, env, sender_transport); + + if(!options->transport_out) + { + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +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) +{ + if(options->soap_version_uri) + { + AXIS2_FREE(env->allocator, options->soap_version_uri); + options->soap_version_uri = NULL; + } + + if(soap_version_uri) + { + options->soap_version_uri = axutil_strdup(env, soap_version_uri); + } + + return AXIS2_SUCCESS; +} + +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) +{ + options->timeout_in_milli_seconds = timeout_in_milli_seconds; + /* set the property AXIS2_HTTP_CONNECTION_TIMEOUT, + * to be picked up by http_sender + */ + if(options->timeout_in_milli_seconds > 0) + { + axis2_char_t time_str[19]; /* supports 18 digit timeout */ + axutil_property_t *property = axutil_property_create(env); + sprintf(time_str, "%ld", options->timeout_in_milli_seconds); + if(property) + { + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value(property, env, axutil_strdup(env, time_str)); + axis2_options_set_property(options, env, AXIS2_HTTP_CONNECTION_TIMEOUT, property); + } + } + return AXIS2_SUCCESS; +} + +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) +{ + /* + here we check for the legal combination + */ + if(!use_separate_listener) + { + if(sender_transport != receiver_transport) + { + return AXIS2_FAILURE; + } + } + else + { + axis2_options_set_use_separate_listener(options, env, use_separate_listener); + } + axis2_options_set_transport_in_protocol(options, env, receiver_transport); + options->sender_transport_protocol = sender_transport; + + return AXIS2_SUCCESS; +} + +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) +{ + axutil_property_t *property = NULL; + + options->use_separate_listener = use_separate_listener; + + if(use_separate_listener) + { + property = axutil_property_create(env); + axutil_property_set_value(property, env, axutil_strdup(env, AXIS2_VALUE_TRUE)); + axis2_options_set_property(options, env, AXIS2_USE_SEPARATE_LISTENER, property); + } + else + { + property = axutil_property_create(env); + axutil_property_set_value(property, env, axutil_strdup(env, AXIS2_VALUE_FALSE)); + axis2_options_set_property(options, env, AXIS2_USE_SEPARATE_LISTENER, property); + } + + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_info_headers_add_ref_param(options->msg_info_headers, env, reference_parameter); + return AXIS2_SUCCESS; +} + +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) +{ + options->manage_session = manage_session; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_options_get_manage_session( + const axis2_options_t * options, + const axutil_env_t * env) +{ + if(options->manage_session == -1) + { + if(options->parent) + { + return axis2_options_get_manage_session(options->parent, env); + } + else + { + return AXIS2_FALSE; + } + } + + return options->manage_session; +} + +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) +{ + if(options->msg_info_headers) + { + axis2_msg_info_headers_free(options->msg_info_headers, env); + } + + options->msg_info_headers = msg_info_headers; + return AXIS2_SUCCESS; +} + +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) +{ + return options->msg_info_headers; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_options_free( + axis2_options_t * options, + const axutil_env_t * env) +{ + if(options->properties) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + for(hi = axutil_hash_first(options->properties, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_property_t *property = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + property = (axutil_property_t *)val; + + if(property) + { + axutil_property_free(property, env); + } + } + axutil_hash_free(options->properties, env); + } + + if(options->soap_version_uri) + { + AXIS2_FREE(env->allocator, options->soap_version_uri); + } + + if(options->msg_info_headers) + { + axis2_msg_info_headers_free(options->msg_info_headers, env); + } + + if(options->soap_action) + { + axutil_string_free(options->soap_action, env); + } + + AXIS2_FREE(env->allocator, options); +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_options_get_soap_version( + const axis2_options_t * options, + const axutil_env_t * env) +{ + return options->soap_version; + +} + +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) +{ + if(soap_version == AXIOM_SOAP11) + { + options->soap_version = soap_version; + axis2_options_set_soap_version_uri(options, env, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI); + } + else + { + options->soap_version = AXIOM_SOAP12; + axis2_options_set_soap_version_uri(options, env, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + } + return AXIS2_SUCCESS; +} + +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) +{ + options->enable_mtom = enable_mtom; + + if(enable_mtom) + { + axutil_property_t *property = axutil_property_create(env); + if(property) + { + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value(property, env, axutil_strdup(env, AXIS2_VALUE_TRUE)); + axis2_options_set_property(options, env, AXIS2_ENABLE_MTOM, property); + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_options_get_enable_mtom( + const axis2_options_t * options, + const axutil_env_t * env) +{ + return options->enable_mtom; +} + +AXIS2_EXTERN axutil_string_t *AXIS2_CALL +axis2_options_get_soap_action( + const axis2_options_t * options, + const axutil_env_t * env) +{ + return options->soap_action; +} + +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) +{ + if(options->soap_action) + { + axutil_string_free(options->soap_action, env); + options->soap_action = NULL; + } + + if(soap_action) + { + options->soap_action = axutil_string_clone(soap_action, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_options_get_xml_parser_reset( + const axis2_options_t * options, + const axutil_env_t * env) +{ + return options->xml_parser_reset; +} + +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 xml_parser_reset) +{ + options->xml_parser_reset = xml_parser_reset; + return AXIS2_SUCCESS; +} + +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) +{ + axutil_property_t *rest_property = NULL; + + if(enable_rest) + { + rest_property = axutil_property_create(env); + axutil_property_set_value(rest_property, env, axutil_strdup(env, AXIS2_VALUE_TRUE)); + axis2_options_set_property(options, env, AXIS2_ENABLE_REST, rest_property); + } + else + { + rest_property = axutil_property_create(env); + axutil_property_set_value(rest_property, env, axutil_strdup(env, AXIS2_VALUE_FALSE)); + axis2_options_set_property(options, env, AXIS2_ENABLE_REST, rest_property); + } + return AXIS2_SUCCESS; +} + +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) +{ + axutil_property_t *test_auth_property = NULL; + + if(test_http_auth) + { + test_auth_property = axutil_property_create(env); + axutil_property_set_value(test_auth_property, env, axutil_strdup(env, AXIS2_VALUE_TRUE)); + axis2_options_set_property(options, env, AXIS2_TEST_HTTP_AUTH, test_auth_property); + } + else + { + test_auth_property = axutil_property_create(env); + axutil_property_set_value(test_auth_property, env, axutil_strdup(env, AXIS2_VALUE_FALSE)); + axis2_options_set_property(options, env, AXIS2_TEST_HTTP_AUTH, test_auth_property); + } + return AXIS2_SUCCESS; +} + +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) +{ + axutil_property_t *test_auth_property = NULL; + + if(test_proxy_auth) + { + test_auth_property = axutil_property_create(env); + axutil_property_set_value(test_auth_property, env, axutil_strdup(env, AXIS2_VALUE_TRUE)); + axis2_options_set_property(options, env, AXIS2_TEST_PROXY_AUTH, test_auth_property); + } + else + { + test_auth_property = axutil_property_create(env); + axutil_property_set_value(test_auth_property, env, axutil_strdup(env, AXIS2_VALUE_FALSE)); + axis2_options_set_property(options, env, AXIS2_TEST_PROXY_AUTH, test_auth_property); + } + return AXIS2_SUCCESS; +} + +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) +{ + axutil_property_t *method_property = NULL; + + method_property = axutil_property_create(env); + axutil_property_set_value(method_property, env, axutil_strdup(env, http_method)); + axis2_options_set_property(options, env, AXIS2_HTTP_METHOD, method_property); + return AXIS2_SUCCESS; +} + +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) +{ + axutil_property_t *headers_property = NULL; + + headers_property = axutil_property_create(env); + axutil_property_set_value(headers_property, env, http_header_list); + axis2_options_set_property(options, env, AXIS2_TRANSPORT_HEADER_PROPERTY, headers_property); + axutil_property_set_free_func(headers_property, env, axutil_array_list_free_void_arg); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_bool_t force_proxy_auth = AXIS2_FALSE; + axutil_property_t *prop_pw = NULL; + axutil_property_t *prop_un = NULL; + + prop_un = axutil_property_create(env); + axutil_property_set_value(prop_un, env, axutil_strdup(env, username)); + axis2_options_set_property(options, env, AXIS2_PROXY_AUTH_UNAME, prop_un); + + prop_pw = axutil_property_create(env); + axutil_property_set_value(prop_pw, env, axutil_strdup(env, password)); + axis2_options_set_property(options, env, AXIS2_PROXY_AUTH_PASSWD, prop_pw); + + if(auth_type) + { + if((axutil_strcasecmp(auth_type, AXIS2_PROXY_AUTH_TYPE_BASIC) == 0) || (axutil_strcasecmp( + auth_type, AXIS2_PROXY_AUTH_TYPE_DIGEST) == 0)) + { + force_proxy_auth = AXIS2_TRUE; + } + } + if(force_proxy_auth) + { + axutil_property_t *proxy_auth_property = axutil_property_create(env); + axutil_property_t *proxy_auth_type_property = axutil_property_create(env); + + axutil_property_set_value(proxy_auth_property, env, axutil_strdup(env, AXIS2_VALUE_TRUE)); + axis2_options_set_property(options, env, AXIS2_FORCE_PROXY_AUTH, proxy_auth_property); + + axutil_property_set_value(proxy_auth_type_property, env, axutil_strdup(env, auth_type)); + axis2_options_set_property(options, env, AXIS2_PROXY_AUTH_TYPE, proxy_auth_type_property); + } + else + { + axutil_property_t *proxy_auth_property = axutil_property_create(env); + axutil_property_set_value(proxy_auth_property, env, axutil_strdup(env, AXIS2_VALUE_FALSE)); + axis2_options_set_property(options, env, AXIS2_FORCE_PROXY_AUTH, proxy_auth_property); + } + return AXIS2_SUCCESS; +} + +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) +{ + axis2_bool_t force_http_auth = AXIS2_FALSE; + axutil_property_t *prop_un = NULL; + axutil_property_t *prop_pw = NULL; + + prop_un = axutil_property_create(env); + axutil_property_set_value(prop_un, env, axutil_strdup(env, username)); + axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_UNAME, prop_un); + + prop_pw = axutil_property_create(env); + axutil_property_set_value(prop_pw, env, axutil_strdup(env, password)); + axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_PASSWD, prop_pw); + + if(auth_type) + { + if((axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_BASIC) == 0) || (axutil_strcasecmp( + auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) == 0)) + { + force_http_auth = AXIS2_TRUE; + } + } + if(force_http_auth) + { + axutil_property_t *http_auth_property = axutil_property_create(env); + axutil_property_t *http_auth_type_property = axutil_property_create(env); + + axutil_property_set_value(http_auth_property, env, axutil_strdup(env, AXIS2_VALUE_TRUE)); + axis2_options_set_property(options, env, AXIS2_FORCE_HTTP_AUTH, http_auth_property); + + axutil_property_set_value(http_auth_type_property, env, axutil_strdup(env, auth_type)); + axis2_options_set_property(options, env, AXIS2_HTTP_AUTH_TYPE, http_auth_type_property); + } + else + { + axutil_property_t *http_auth_property = axutil_property_create(env); + axutil_property_set_value(http_auth_property, env, axutil_strdup(env, AXIS2_VALUE_FALSE)); + axis2_options_set_property(options, env, AXIS2_FORCE_HTTP_AUTH, http_auth_property); + } + return AXIS2_SUCCESS; +} + diff --git a/src/core/clientapi/stub.c b/src/core/clientapi/stub.c new file mode 100644 index 0000000..2b27274 --- /dev/null +++ b/src/core/clientapi/stub.c @@ -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. + */ + +#include + +struct axis2_stub +{ + axis2_svc_client_t *svc_client; + axis2_options_t *options; +}; + +AXIS2_EXTERN axis2_stub_t *AXIS2_CALL +axis2_stub_create( + const axutil_env_t * env) +{ + axis2_stub_t *stub = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + stub = (axis2_stub_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_stub_t)); + + if(!stub) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create stub."); + return NULL; + } + stub->svc_client = NULL; + stub->options = NULL; + + return stub; +} + +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) +{ + axis2_stub_t *stub = NULL; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, endpoint_ref, NULL); + + stub = (axis2_stub_t *)axis2_stub_create(env); + + if(!stub) + { + return NULL; + } + + stub->svc_client = axis2_svc_client_create(env, client_home); + + if(!stub->svc_client) + { + axis2_stub_free(stub, env); + return NULL; + } + + stub->options = axis2_options_create(env); + if(!stub->options) + { + axis2_stub_free(stub, env); + return NULL; + } + + axis2_svc_client_set_options(stub->svc_client, env, stub->options); + + axis2_options_set_to(stub->options, env, endpoint_ref); + + return stub; +} + +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) +{ + axis2_stub_t *stub = NULL; + axis2_endpoint_ref_t *endpoint_ref = NULL; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, endpoint_uri, NULL); + + endpoint_ref = axis2_endpoint_ref_create(env, endpoint_uri); + if(!endpoint_ref) + { + return NULL; + } + stub = (axis2_stub_t *)axis2_stub_create_with_endpoint_ref_and_client_home(env, endpoint_ref, + client_home); + + if(!stub) + { + return NULL; + } + + return stub; +} + +void AXIS2_CALL +axis2_stub_free( + axis2_stub_t * stub, + const axutil_env_t * env) +{ + if(stub) + { + if(stub->svc_client) + { + axis2_svc_client_free(stub->svc_client, env); + } + + AXIS2_FREE(env->allocator, stub); + } +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, endpoint_ref, AXIS2_FAILURE); + axis2_options_set_to(stub->options, env, endpoint_ref); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_endpoint_ref_t *endpoint_ref = NULL; + + AXIS2_PARAM_CHECK(env->error, endpoint_uri, AXIS2_FAILURE); + + endpoint_ref = axis2_endpoint_ref_create(env, endpoint_uri); + if(!endpoint_ref) + { + return AXIS2_FAILURE; + } + axis2_options_set_to(stub->options, env, endpoint_ref); + + return AXIS2_SUCCESS; +} + +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) +{ + return axis2_options_set_use_separate_listener(stub->options, env, use_separate_listener); +} + +axis2_status_t AXIS2_CALL +axis2_stub_engage_module( + axis2_stub_t * stub, + const axutil_env_t * env, + const axis2_char_t * module_name) +{ + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + + return axis2_svc_client_engage_module(stub->svc_client, env, module_name); +} + +axis2_status_t AXIS2_CALL +axis2_stub_set_soap_version( + axis2_stub_t * stub, + const axutil_env_t * env, + const int soap_version) +{ + if(!stub->options) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Cannot set soap version. Stub option is not valid."); + return AXIS2_FAILURE; + } + return axis2_options_set_soap_version(stub->options, env, soap_version); +} + +const axis2_char_t *AXIS2_CALL +axis2_stub_get_svc_ctx_id( + const axis2_stub_t * stub, + const axutil_env_t * env) +{ + const axis2_svc_ctx_t *svc_ctx = NULL; + const axis2_char_t *svc_ctx_id = NULL; + + AXIS2_PARAM_CHECK(env->error, stub, NULL); + + svc_ctx = axis2_svc_client_get_svc_ctx(stub->svc_client, env); + svc_ctx_id = axis2_svc_ctx_get_svc_id(svc_ctx, env); + return svc_ctx_id; +} + +axis2_svc_client_t *AXIS2_CALL +axis2_stub_get_svc_client( + const axis2_stub_t * stub, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, stub, NULL); + return stub->svc_client; +} + +axis2_options_t *AXIS2_CALL +axis2_stub_get_options( + const axis2_stub_t * stub, + const axutil_env_t * env) +{ + return stub->options; +} diff --git a/src/core/clientapi/svc_client.c b/src/core/clientapi/svc_client.c new file mode 100644 index 0000000..d25f340 --- /dev/null +++ b/src/core/clientapi/svc_client.c @@ -0,0 +1,1624 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include "axis2_callback_recv.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_svc_client +{ + axis2_svc_t *svc; + + axis2_conf_t *conf; + + axis2_conf_ctx_t *conf_ctx; + + axis2_svc_ctx_t *svc_ctx; + + axis2_options_t *options; + + axis2_options_t *override_options; + + /* SOAP Headers */ + axutil_array_list_t *headers; + + /* for receiving the async messages */ + axis2_callback_recv_t *callback_recv; + + axis2_listener_manager_t *listener_manager; + + axis2_op_client_t *op_client; + + axiom_soap_envelope_t *last_response_soap_envelope; + + axis2_bool_t last_response_has_fault; + + axis2_bool_t reuse; + + axis2_bool_t auth_failed; + + axis2_bool_t required_auth_is_http; + + axis2_char_t *auth_type; + + axutil_array_list_t *http_headers; + + int http_status_code; + + axis2_bool_t keep_externally_passed_ctx_and_svc; + +}; + +static void +axis2_svc_client_set_http_info( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +static axis2_svc_t * +axis2_svc_client_create_annonymous_svc( + axis2_svc_client_t * svc_client, + const axutil_env_t * env); + +static axis2_bool_t +axis2_svc_client_init_transports_from_conf_ctx( + const axutil_env_t * env, + axis2_svc_client_t * svc_client, + axis2_conf_ctx_t * conf_ctx, + const axis2_char_t * client_home); + +static axis2_bool_t +axis2_svc_client_init_data( + const axutil_env_t * env, + axis2_svc_client_t * svc_client); + +static axis2_bool_t +axis2_svc_client_fill_soap_envelope( + const axutil_env_t * env, + axis2_svc_client_t * svc_client, + axis2_msg_ctx_t * msg_ctx, + const axiom_node_t * payload); + +AXIS2_EXTERN axis2_svc_client_t *AXIS2_CALL +axis2_svc_client_create( + const axutil_env_t * env, + const axis2_char_t * client_home) +{ + axis2_svc_client_t *svc_client = NULL; + + AXIS2_ENV_CHECK(env, NULL); + svc_client = axis2_svc_client_create_with_conf_ctx_and_svc(env, client_home, NULL, NULL); + + return svc_client; +} + +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) +{ + axis2_svc_client_t *svc_client = NULL; + axis2_svc_grp_t *svc_grp = NULL; + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + const axis2_char_t *svc_grp_name = NULL; + + svc_client = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_client_t)); + if(!svc_client) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create service client."); + return NULL; + } + + svc_client->svc = NULL; + svc_client->conf = NULL; + svc_client->conf_ctx = NULL; + svc_client->svc_ctx = NULL; + svc_client->options = NULL; + svc_client->override_options = NULL; + svc_client->headers = NULL; + svc_client->callback_recv = NULL; + svc_client->listener_manager = NULL; + svc_client->op_client = NULL; + svc_client->last_response_soap_envelope = NULL; + svc_client->last_response_has_fault = AXIS2_FALSE; + svc_client->reuse = AXIS2_FALSE; + svc_client->auth_failed = AXIS2_FALSE; + svc_client->required_auth_is_http = AXIS2_FALSE; + svc_client->auth_type = NULL; + svc_client->http_headers = NULL; + svc_client->keep_externally_passed_ctx_and_svc = AXIS2_FALSE; + + if(!axis2_svc_client_init_data(env, svc_client)) + { + axis2_svc_client_free(svc_client, env); + return NULL; + } + + /*create the default conf_ctx if it is NULL */ + if(!axis2_svc_client_init_transports_from_conf_ctx(env, svc_client, conf_ctx, client_home)) + { + axis2_svc_client_free(svc_client, env); + return NULL; + } + + svc_client->conf = axis2_conf_ctx_get_conf(svc_client->conf_ctx, env); + + if(svc) + { + svc_client->keep_externally_passed_ctx_and_svc = AXIS2_TRUE; + svc_client->svc = svc; + } + else + { + svc_client->svc = axis2_svc_client_create_annonymous_svc(svc_client, env); + if(!svc_client->svc) + { + axis2_svc_client_free(svc_client, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create annonymous service."); + return NULL; + } + } + + /** add the service to the config context if it isn't in there already */ + if(!axis2_conf_get_svc(svc_client->conf, env, axis2_svc_get_name(svc_client->svc, env))) + { + axis2_conf_add_svc(svc_client->conf, env, svc_client->svc); + } + + /** create a service context for myself: create a new service group + context and then get the service context for myself as I'll need that + later for stuff that I gotta do */ + svc_grp = axis2_svc_get_parent(svc_client->svc, env); + if(!svc_grp) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot access service group of service client."); + return NULL; + } + + svc_grp_ctx = axis2_svc_grp_get_svc_grp_ctx(svc_grp, env, svc_client->conf_ctx); + if(!svc_grp_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Cannot access service group context of service client."); + return NULL; + } + + svc_grp_name = axis2_svc_grp_get_name(svc_grp, env); + if(!svc_grp_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Cannot access service group name of service client."); + return NULL; /* service group name is mandatory */ + } + + axis2_conf_ctx_register_svc_grp_ctx(svc_client->conf_ctx, env, svc_grp_name, svc_grp_ctx); + + svc_client->svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, axis2_svc_get_name( + svc_client->svc, env)); + + return svc_client; +} + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_svc_client_get_svc( + const axis2_svc_client_t * svc_client, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + return svc_client->svc; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + return svc_client->conf_ctx; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + if(svc_client->options) + { + axis2_options_free(svc_client->options, env); + } + svc_client->options = (axis2_options_t *)options; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + return svc_client->options; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + if(svc_client->override_options) + { + axis2_options_free(svc_client->override_options, env); + } + + svc_client->override_options = (axis2_options_t *)override_options; + + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + return svc_client->override_options; +} + +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) +{ + axis2_module_desc_t *module = NULL; + axutil_qname_t *mod_qname = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + + mod_qname = axutil_qname_create(env, module_name, NULL, NULL); + + if(!mod_qname) + { + return AXIS2_FAILURE; + } + + module = axis2_conf_get_module(svc_client->conf, env, mod_qname); + + axutil_qname_free(mod_qname, env); + mod_qname = NULL; + + if(module) + { + return axis2_svc_engage_module(svc_client->svc, env, module, svc_client->conf); + } + return 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) +{ + axis2_module_desc_t *module = NULL; + axutil_qname_t *mod_qname = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + + mod_qname = axutil_qname_create(env, module_name, NULL, NULL); + if(!mod_qname) + { + return AXIS2_FAILURE; + } + + module = axis2_conf_get_module(svc_client->conf, env, mod_qname); + axutil_qname_free(mod_qname, env); + mod_qname = NULL; + + if(module) + { + return axis2_svc_disengage_module(svc_client->svc, env, module, svc_client->conf); + } + return 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) +{ + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + if(!svc_client->headers) + { + svc_client->headers = axutil_array_list_create(env, 0); + if(!svc_client->headers) + { + return AXIS2_FAILURE; + } + } + axutil_array_list_add(svc_client->headers, env, header); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_client_remove_all_headers( + axis2_svc_client_t * svc_client, + const axutil_env_t * env) +{ + int i = 0; + int size = 0; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + + if(!svc_client->headers) + { + return AXIS2_SUCCESS; + } + + size = axutil_array_list_size(svc_client->headers, env); + + for(i = size - 1; i > -1; i--) + { + axutil_array_list_remove(svc_client->headers, env, i); + } + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_ctx_t *msg_ctx = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_bool_t qname_free_flag = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + + if(!op_qname) + { + op_qname = axutil_qname_create(env, AXIS2_ANON_ROBUST_OUT_ONLY_OP, NULL, NULL); + if(!op_qname) + { + return AXIS2_FAILURE; + } + qname_free_flag = AXIS2_TRUE; + } + else + { + axis2_op_t *op = NULL; + axis2_char_t *mep = NULL; + axis2_svc_t *svc = NULL; + svc = axis2_svc_client_get_svc(svc_client, env); + if(!svc) + { + return AXIS2_FAILURE; + } + op = axis2_svc_get_op_with_qname(svc, env, op_qname); + if(!op) + { + return AXIS2_FAILURE; + } + mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op, env); + if(!mep || axutil_strcmp(AXIS2_MEP_URI_OUT_ONLY, mep) != 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s%s", + "To use this method opeation uri should be", AXIS2_MEP_URI_OUT_ONLY); + return AXIS2_FAILURE; + } + } + + svc_client->auth_failed = AXIS2_FALSE; + svc_client->required_auth_is_http = AXIS2_FALSE; + if(svc_client->auth_type) + { + AXIS2_FREE(env->allocator, svc_client->auth_type); + } + svc_client->auth_type = NULL; + + msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(svc_client->svc_ctx, env), NULL, + NULL); + if(!axis2_svc_client_fill_soap_envelope(env, svc_client, msg_ctx, payload)) + { + return AXIS2_FAILURE; + } + + if(!axis2_svc_client_create_op_client(svc_client, env, op_qname)) + { + return AXIS2_FAILURE; + } + + axis2_op_client_add_out_msg_ctx(svc_client->op_client, env, msg_ctx); + status = axis2_op_client_execute(svc_client->op_client, env, AXIS2_TRUE); + axis2_svc_client_set_http_info(svc_client, env, msg_ctx); + svc_client->auth_failed = axis2_msg_ctx_get_auth_failed(msg_ctx, env); + svc_client->required_auth_is_http = axis2_msg_ctx_get_required_auth_is_http(msg_ctx, env); + if(axis2_msg_ctx_get_auth_type(msg_ctx, env)) + { + svc_client->auth_type = axutil_strdup(env, axis2_msg_ctx_get_auth_type(msg_ctx, env)); + } + + if(qname_free_flag) + { + axutil_qname_free((axutil_qname_t *)op_qname, env); + } + + return status; +} + +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) +{ + return axis2_svc_client_send_robust_with_op_qname(svc_client, env, NULL, payload); +} + +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) +{ + axis2_msg_ctx_t *msg_ctx = NULL; + axis2_bool_t qname_free_flag = AXIS2_FALSE; + + AXIS2_PARAM_CHECK_VOID(env->error, svc_client); + + if(!op_qname) + { + op_qname = axutil_qname_create(env, AXIS2_ANON_OUT_ONLY_OP, NULL, NULL); + if(!op_qname) + { + return; + } + qname_free_flag = AXIS2_TRUE; + } + + svc_client->auth_failed = AXIS2_FALSE; + svc_client->required_auth_is_http = AXIS2_FALSE; + if(svc_client->auth_type) + { + AXIS2_FREE(env->allocator, svc_client->auth_type); + } + svc_client->auth_type = NULL; + + msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(svc_client->svc_ctx, env), NULL, + NULL); + if(!axis2_svc_client_fill_soap_envelope(env, svc_client, msg_ctx, payload)) + { + return; + } + + if(!axis2_svc_client_create_op_client(svc_client, env, op_qname)) + { + return; + } + + axis2_op_client_add_out_msg_ctx(svc_client->op_client, env, msg_ctx); + axis2_op_client_execute(svc_client->op_client, env, AXIS2_TRUE); + axis2_svc_client_set_http_info(svc_client, env, msg_ctx); + svc_client->auth_failed = axis2_msg_ctx_get_auth_failed(msg_ctx, env); + svc_client->required_auth_is_http = axis2_msg_ctx_get_required_auth_is_http(msg_ctx, env); + if(axis2_msg_ctx_get_auth_type(msg_ctx, env)) + { + svc_client->auth_type = axutil_strdup(env, axis2_msg_ctx_get_auth_type(msg_ctx, env)); + } + + if(qname_free_flag) + { + axutil_qname_free((axutil_qname_t *)op_qname, env); + } +} + +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) +{ + axis2_svc_client_fire_and_forget_with_op_qname(svc_client, env, NULL, payload); +} + +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) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_body_t *soap_body = NULL; + axiom_node_t *soap_node = NULL; + axis2_op_t *op = NULL; + axutil_param_t *param = NULL; + axutil_uri_t *action_uri = NULL; + axis2_char_t *action_str = NULL; + axis2_bool_t qname_free_flag = AXIS2_FALSE; + + axis2_msg_ctx_t *res_msg_ctx = NULL; + axis2_msg_ctx_t *msg_ctx = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + + svc_client->last_response_soap_envelope = NULL; + svc_client->last_response_has_fault = AXIS2_FALSE; + svc_client->auth_failed = AXIS2_FALSE; + svc_client->required_auth_is_http = AXIS2_FALSE; + if(svc_client->auth_type) + { + AXIS2_FREE(env->allocator, svc_client->auth_type); + } + svc_client->auth_type = NULL; + + op = axis2_svc_get_op_with_qname(svc_client->svc, env, op_qname); + if(op) + { + param = axis2_op_get_param(op, env, AXIS2_SOAP_ACTION); + if(param) + { + action_uri = (axutil_uri_t *)axutil_param_get_value(param, env); + action_str = axutil_uri_to_string(action_uri, env, AXIS2_URI_UNP_OMITUSERINFO); + axis2_options_set_action(svc_client->options, env, action_str); + } + } + + if(!op_qname) + { + op_qname = axutil_qname_create(env, AXIS2_ANON_OUT_IN_OP, NULL, NULL); + if(!op_qname) + return NULL; + + qname_free_flag = AXIS2_TRUE; + } + + /* If dual channel blocking. We come to this block if the client indicate to use + * a separate listener but don't provide a callback function to acted upon when + * response is received in the listener thread. What we do here is we create a callback + * and call axis2_svc_client_send_receive_non_blocking_with_op_qname with it. */ + if(axis2_options_get_use_separate_listener(svc_client->options, env)) + { + axis2_callback_t *callback = NULL; + axis2_msg_ctx_t *msg_ctx = NULL; + long index = 0; + + /* This means doing a Request-Response invocation using two channels. + If the transport is a two way transport (e.g. http), only one channel is used + (e.g. in http cases 202 OK is sent to say no response available). + Axis2 gets blocked and return when the response is available. */ + + callback = axis2_callback_create(env); + if(!callback) + { + return NULL; + } + + /* Call two channel non blocking invoke to do the work and wait on the callback. We don't + * set a callback function for the callback. That functionality is handled here. + */ + axis2_svc_client_send_receive_non_blocking_with_op_qname(svc_client, env, op_qname, + payload, callback); + + index = axis2_options_get_timeout_in_milli_seconds(svc_client->options, env) / 10; + + while(!axis2_callback_get_complete(callback, env)) + { + if(index-- >= 0) + { + AXIS2_USLEEP(10000); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RESPONSE_TIMED_OUT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Response time out."); + return NULL; + } + } + + soap_envelope = axis2_callback_get_envelope(callback, env); + msg_ctx = axis2_callback_get_msg_ctx(callback, env); + axis2_op_client_add_in_msg_ctx(svc_client->op_client, env, msg_ctx); + + /* start of hack to get rid of memory leak */ + /*msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(svc_client-> svc_ctx, env), + NULL, NULL); + if(!msg_ctx) + return NULL; + + axis2_op_client_add_in_msg_ctx(svc_client->op_client, env, msg_ctx); + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope);*/ + /* end of hack to get rid of memory leak */ + + /* process the result of the invocation */ + if(!soap_envelope) + { + if(axis2_callback_get_error(callback, env) != AXIS2_ERROR_NONE) + { + AXIS2_ERROR_SET(env->error, axis2_callback_get_error(callback, env), AXIS2_FAILURE); + return NULL; + } + } + } + else + { + msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(svc_client->svc_ctx, env), + NULL, NULL); + if(!msg_ctx) + return NULL; + + if(!axis2_svc_client_fill_soap_envelope(env, svc_client, msg_ctx, payload)) + { + return NULL; + } + + if(!axis2_svc_client_create_op_client(svc_client, env, op_qname)) + { + return NULL; + } + + axis2_op_client_add_msg_ctx(svc_client->op_client, env, msg_ctx); + axis2_op_client_execute(svc_client->op_client, env, AXIS2_TRUE); + axis2_svc_client_set_http_info(svc_client, env, msg_ctx); + svc_client->auth_failed = axis2_msg_ctx_get_auth_failed(msg_ctx, env); + svc_client->required_auth_is_http = axis2_msg_ctx_get_required_auth_is_http(msg_ctx, env); + if(axis2_msg_ctx_get_auth_type(msg_ctx, env)) + { + svc_client->auth_type = axutil_strdup(env, axis2_msg_ctx_get_auth_type(msg_ctx, env)); + } + res_msg_ctx = (axis2_msg_ctx_t *)axis2_op_client_get_msg_ctx(svc_client-> op_client, env, + AXIS2_WSDL_MESSAGE_LABEL_IN); + + if(res_msg_ctx) + { + soap_envelope = axis2_msg_ctx_get_soap_envelope(res_msg_ctx, env); + } + else + { + axis2_op_client_add_msg_ctx(svc_client->op_client, env, res_msg_ctx); + /* set in msg_ctx to be NULL to reset */ + } + } + + if(qname_free_flag) + { + axutil_qname_free((axutil_qname_t *)op_qname, env); + } + + if(!soap_envelope) + { + return NULL; + } + svc_client->last_response_soap_envelope = soap_envelope; + + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(!soap_body) + { + axiom_node_t *node = axiom_soap_envelope_get_base_node(soap_envelope, env); + if(node) + { + axiom_element_t *envelope_element = (axiom_element_t *)axiom_node_get_data_element( + node, env); + axiom_util_get_first_child_element_with_localname(envelope_element, env, node, + AXIOM_SOAP_BODY_LOCAL_NAME, &soap_node); + if(soap_node) + { + return axiom_node_get_first_element(soap_node, env); + } + } + return NULL; + } + + if(axis2_msg_ctx_get_doing_rest(res_msg_ctx, env)) + { + /* All HTTP 4xx and 5xx status codes are treated as errors */ + if(axis2_msg_ctx_get_status_code(res_msg_ctx, env) >= 400) + { + svc_client->last_response_has_fault = AXIS2_TRUE; + } + else + { + svc_client->last_response_has_fault = AXIS2_FALSE; + } + } + else + { + svc_client->last_response_has_fault = axiom_soap_body_has_fault(soap_body, env); + } + + if(AXIOM_SOAP11 == axiom_soap_envelope_get_soap_version(soap_envelope, env)) + { + axiom_soap_body_convert_fault_to_soap11(soap_body, env); + } + + soap_node = axiom_soap_body_get_base_node(soap_body, env); + if(!soap_node) + { + return NULL; + } + return axiom_node_get_first_element(soap_node, env); +} + +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) +{ + return axis2_svc_client_send_receive_with_op_qname(svc_client, env, NULL, payload); +} + +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) +{ + axis2_msg_ctx_t *msg_ctx = NULL; + AXIS2_TRANSPORT_ENUMS transport_in_protocol; + axis2_bool_t qname_free_flag = AXIS2_FALSE; + + AXIS2_PARAM_CHECK_VOID(env->error, svc_client); + + if(!op_qname) + { + op_qname = axutil_qname_create(env, AXIS2_ANON_OUT_IN_OP, NULL, NULL); + if(!op_qname) + return; + qname_free_flag = AXIS2_TRUE; + } + + svc_client->auth_failed = AXIS2_FALSE; + svc_client->required_auth_is_http = AXIS2_FALSE; + if(svc_client->auth_type) + { + AXIS2_FREE(env->allocator, svc_client->auth_type); + } + svc_client->auth_type = NULL; + + msg_ctx = axis2_msg_ctx_create(env, axis2_svc_ctx_get_conf_ctx(svc_client-> svc_ctx, env), + NULL, NULL); + if(!msg_ctx) + return; + + if(!axis2_svc_client_fill_soap_envelope(env, svc_client, msg_ctx, payload)) + { + return; + } + + if(!axis2_svc_client_create_op_client(svc_client, env, op_qname)) + { + return; + } + + axis2_op_client_set_callback(svc_client->op_client, env, callback); + axis2_op_client_add_out_msg_ctx(svc_client->op_client, env, msg_ctx); + + /* If dual channel */ + if(axis2_options_get_use_separate_listener(svc_client->options, env)) + { + axis2_op_t *op = NULL; + + transport_in_protocol = axis2_options_get_transport_in_protocol(svc_client->options, env); + if(transport_in_protocol == AXIS2_TRANSPORT_ENUM_MAX) + { + axis2_options_set_transport_in_protocol(svc_client->options, env, + AXIS2_TRANSPORT_ENUM_HTTP); + transport_in_protocol = AXIS2_TRANSPORT_ENUM_HTTP; + } + axis2_listener_manager_make_sure_started(svc_client->listener_manager, env, + transport_in_protocol, svc_client->conf_ctx); + /* Following sleep is required to ensure the listener is ready to receive response. + If it is missing, the response gets lost. - Samisa */ + AXIS2_USLEEP(1); + + op = axis2_svc_get_op_with_qname(svc_client->svc, env, op_qname); + /* At the end of the incoming flow this message receiver will be hit */ + axis2_op_set_msg_recv(op, env, + AXIS2_CALLBACK_RECV_GET_BASE(svc_client-> callback_recv, env)); + axis2_op_client_set_callback_recv(svc_client->op_client, env, svc_client->callback_recv); + } + + axis2_op_client_execute(svc_client->op_client, env, AXIS2_FALSE); + axis2_svc_client_set_http_info(svc_client, env, msg_ctx); + svc_client->auth_failed = axis2_msg_ctx_get_auth_failed(msg_ctx, env); + svc_client->required_auth_is_http = axis2_msg_ctx_get_required_auth_is_http(msg_ctx, env); + if(axis2_msg_ctx_get_auth_type(msg_ctx, env)) + { + svc_client->auth_type = axutil_strdup(env, axis2_msg_ctx_get_auth_type(msg_ctx, env)); + } + + if(qname_free_flag) + { + axutil_qname_free((axutil_qname_t *)op_qname, env); + op_qname = NULL; + } +} + +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) +{ + axis2_svc_client_send_receive_non_blocking_with_op_qname(svc_client, env, NULL, payload, + callback); +} + +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) +{ + axis2_op_t *op = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + + op = axis2_svc_get_op_with_qname(svc_client->svc, env, op_qname); + + if(!op) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot find operation to create op client."); + return NULL; + } + + if(!(svc_client->op_client) || svc_client->reuse) + { + if((svc_client->reuse) && (svc_client->op_client)) + axis2_op_client_free(svc_client->op_client, env); + svc_client->op_client = axis2_op_client_create(env, op, svc_client->svc_ctx, + svc_client->options); + } + + /** + If override options have been set, that means we need to make sure + those options override the options of even the operation client. So, + what we do is switch the parents around to make that work. + */ + if(svc_client->override_options) + { + axis2_options_set_parent(svc_client->override_options, env, axis2_op_client_get_options( + svc_client-> op_client, env)); + axis2_op_client_set_options(svc_client->op_client, env, svc_client->override_options); + } + svc_client->reuse = AXIS2_TRUE; + axis2_op_client_set_reuse(svc_client->op_client, env, svc_client->reuse); + return svc_client->op_client; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_client_finalize_invoke( + axis2_svc_client_t * svc_client, + const axutil_env_t * env) +{ + AXIS2_TRANSPORT_ENUMS transport_in_protocol; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + + transport_in_protocol = axis2_options_get_transport_in_protocol(svc_client->options, env); + + if(svc_client->listener_manager) + { + return axis2_listener_manager_stop(svc_client->listener_manager, env, transport_in_protocol); + } + + return AXIS2_SUCCESS; +} + +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) +{ + return NULL; +} + +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) +{ + return NULL; +} + +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_endpoint_ref) +{ + return AXIS2_FAILURE; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + return svc_client->svc_ctx; +} + +static axis2_bool_t +axis2_svc_client_init_transports_from_conf_ctx( + const axutil_env_t * env, + axis2_svc_client_t * svc_client, + axis2_conf_ctx_t * conf_ctx, + const axis2_char_t * client_home) +{ + svc_client->conf_ctx = conf_ctx; + if(!svc_client->conf_ctx) + { + svc_client->conf_ctx = axis2_build_client_conf_ctx(env, client_home); + if(!svc_client->conf_ctx) + { + return AXIS2_FALSE; + } + } + else + { + svc_client->keep_externally_passed_ctx_and_svc = AXIS2_TRUE; + } + + if(!svc_client->listener_manager) + { + svc_client->listener_manager = axis2_listener_manager_create(env); + if(!svc_client->listener_manager) + { + return AXIS2_FALSE; + } + } + + return AXIS2_TRUE; +} + +static axis2_bool_t +axis2_svc_client_init_data( + const axutil_env_t * env, + axis2_svc_client_t * svc_client) +{ + svc_client->svc = NULL; + svc_client->conf_ctx = NULL; + svc_client->svc_ctx = NULL; + + svc_client->options = axis2_options_create(env); + if(!svc_client->options) + { + return AXIS2_FALSE; + } + + svc_client->override_options = NULL; + svc_client->headers = NULL; + + if(svc_client->callback_recv) + { + AXIS2_CALLBACK_RECV_FREE(svc_client->callback_recv, env); + svc_client->callback_recv = NULL; + } + + svc_client->callback_recv = axis2_callback_recv_create(env); + if(!svc_client->callback_recv) + { + return AXIS2_FALSE; + } + + return AXIS2_TRUE; +} + +static axis2_svc_t * +axis2_svc_client_create_annonymous_svc( + axis2_svc_client_t * svc_client, + const axutil_env_t * env) +{ + + /** + now add anonymous operations to the axis2 service for use with the + shortcut client API. NOTE: We only add the ones we know we'll use + later in the convenience API; if you use + this constructor then you can't expect any magic! + */ + axutil_qname_t *tmp_qname; + axis2_svc_t *svc; + axis2_op_t *op_out_in, *op_out_only, *op_robust_out_only; + axis2_phases_info_t *info = NULL; + + tmp_qname = axutil_qname_create(env, AXIS2_ANON_SERVICE, NULL, NULL); + if(!tmp_qname) + { + return NULL; + } + + svc = axis2_svc_create_with_qname(env, tmp_qname); + axutil_qname_free(tmp_qname, env); + if(!svc) + { + return NULL; + } + + tmp_qname = axutil_qname_create(env, AXIS2_ANON_OUT_IN_OP, NULL, NULL); + if(!tmp_qname) + { + return NULL; + } + op_out_in = axis2_op_create_with_qname(env, tmp_qname); + axutil_qname_free(tmp_qname, env); + + tmp_qname = axutil_qname_create(env, AXIS2_ANON_OUT_ONLY_OP, NULL, NULL); + if(!tmp_qname) + { + return NULL; + } + op_out_only = axis2_op_create_with_qname(env, tmp_qname); + axutil_qname_free(tmp_qname, env); + + tmp_qname = axutil_qname_create(env, AXIS2_ANON_ROBUST_OUT_ONLY_OP, NULL, NULL); + if(!tmp_qname) + { + return NULL; + } + op_robust_out_only = axis2_op_create_with_qname(env, tmp_qname); + axutil_qname_free(tmp_qname, env); + + if(!op_out_in || !op_out_only || !op_robust_out_only) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + if(op_out_in) + { + axis2_op_free(op_out_in, env); + } + if(op_out_only) + { + axis2_op_free(op_out_only, env); + } + if(op_robust_out_only) + { + axis2_op_free(op_robust_out_only, env); + } + + return NULL; + } + + axis2_op_set_msg_exchange_pattern(op_out_in, env, AXIS2_MEP_URI_OUT_IN); + axis2_op_set_msg_exchange_pattern(op_out_only, env, AXIS2_MEP_URI_OUT_ONLY); + axis2_op_set_msg_exchange_pattern(op_robust_out_only, env, AXIS2_MEP_URI_ROBUST_OUT_ONLY); + + /* Setting operation phase */ + info = axis2_conf_get_phases_info(svc_client->conf, env); + axis2_phases_info_set_op_phases(info, env, op_out_in); + axis2_phases_info_set_op_phases(info, env, op_out_only); + axis2_phases_info_set_op_phases(info, env, op_robust_out_only); + axis2_svc_add_op(svc, env, op_out_in); + axis2_svc_add_op(svc, env, op_out_only); + axis2_svc_add_op(svc, env, op_robust_out_only); + return svc; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_client_free( + axis2_svc_client_t * svc_client, + const axutil_env_t * env) +{ + if(!svc_client) + { + return; + } + + if(svc_client->headers) + { + axis2_svc_client_remove_all_headers(svc_client, env); + axutil_array_list_free(svc_client->headers, env); + svc_client->headers = NULL; + } + + if(svc_client->svc && !svc_client->keep_externally_passed_ctx_and_svc) + { + axis2_svc_free(svc_client->svc, env); + } + + if(svc_client->callback_recv) + { + AXIS2_CALLBACK_RECV_FREE(svc_client->callback_recv, env); + } + + if(svc_client->op_client) + { + axis2_op_client_free(svc_client->op_client, env); + svc_client->op_client = NULL; + } + + if(svc_client->options) + { + axis2_options_free(svc_client->options, env); + } + + if(svc_client->listener_manager) + { + axis2_listener_manager_free(svc_client->listener_manager, env); + } + + if(svc_client->conf_ctx && !svc_client->keep_externally_passed_ctx_and_svc) + { + axis2_conf_ctx_free(svc_client->conf_ctx, env); + } + + if(svc_client->auth_type) + { + AXIS2_FREE(env->allocator, svc_client->auth_type); + } + + if(svc_client->http_headers) + { + axis2_svc_client_set_http_info(svc_client, env, NULL); + } + + AXIS2_FREE(env->allocator, svc_client); + + return; +} + +static axis2_bool_t +axis2_svc_client_fill_soap_envelope( + const axutil_env_t * env, + axis2_svc_client_t * svc_client, + axis2_msg_ctx_t * msg_ctx, + const axiom_node_t * payload) +{ + const axis2_char_t *soap_version_uri; + int soap_version; + axiom_soap_envelope_t *envelope = NULL; + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + + soap_version_uri = axis2_options_get_soap_version_uri(svc_client->options, env); + + if(!soap_version_uri) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot find soap version uri."); + return AXIS2_FALSE; + } + + if(axutil_strcmp(soap_version_uri, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) == 0) + { + soap_version = AXIOM_SOAP11; + } + else + { + soap_version = AXIOM_SOAP12; + } + + envelope = axiom_soap_envelope_create_default_soap_envelope(env, soap_version); + if(!envelope) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create default soap envelope."); + return AXIS2_FALSE; + } + + if(svc_client->headers) + { + axiom_soap_header_t *soap_header = NULL; + soap_header = axiom_soap_envelope_get_header(envelope, env); + + if(soap_header) + { + axiom_node_t *header_node = NULL; + header_node = axiom_soap_header_get_base_node(soap_header, env); + + if(header_node) + { + int size = 0; + int i = 0; + size = axutil_array_list_size(svc_client->headers, env); + while(i < size) + { + axiom_node_t *node = NULL; + node = axutil_array_list_remove(svc_client->headers, env, 0); + /* This removes and retrieves data. The order of the + * removal is chosen such that the headers are appended + * in the order they were added. + */ + size--; + if(node) + { + axiom_node_add_child(header_node, env, node); + } + } + } + } + } + + if(payload) + { + axiom_soap_body_t *soap_body = NULL; + soap_body = axiom_soap_envelope_get_body(envelope, env); + if(soap_body) + { + axiom_node_t *node = NULL; + node = axiom_soap_body_get_base_node(soap_body, env); + if(node) + { + axiom_node_add_child(node, env, (axiom_node_t *)payload); + } + } + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, envelope); + + return AXIS2_TRUE; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + return svc_client->op_client; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, NULL); + return svc_client->last_response_soap_envelope; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FALSE); + return svc_client->last_response_has_fault; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FALSE); + if(svc_client->auth_failed && svc_client->required_auth_is_http) + { + return AXIS2_TRUE; + } + return 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) +{ + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FALSE); + if(svc_client->auth_failed && !svc_client->required_auth_is_http) + { + return AXIS2_TRUE; + } + return 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) +{ + return svc_client->auth_type; +} + +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) +{ + axis2_transport_out_desc_t *trans_desc = NULL; + axis2_conf_t *conf = NULL; + axutil_param_container_t *param_container; + axutil_param_t *param; + axis2_char_t *proxy = AXIS2_HTTP_PROXY_API; + axutil_hash_t *attribute; + axutil_generic_obj_t *host_obj = NULL; + axutil_generic_obj_t *port_obj = NULL; + axutil_generic_obj_t *username_obj = NULL; + axutil_generic_obj_t *password_obj = NULL; + axiom_attribute_t *host_attr = NULL; + axiom_attribute_t *port_attr = NULL; + axiom_attribute_t *username_attr = NULL; + axiom_attribute_t *password_attr = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, proxy_host, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, proxy_port, AXIS2_FAILURE); + + if(svc_client->conf) + { + conf = svc_client->conf; + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + if(!trans_desc) + { + return AXIS2_FAILURE; + } + param_container = axis2_transport_out_desc_param_container(trans_desc, env); + param = axutil_param_create(env, proxy, (void *)NULL); + + if(!param) + { + return AXIS2_FAILURE; + } + + attribute = axutil_hash_make(env); + host_obj = axutil_generic_obj_create(env); + port_obj = axutil_generic_obj_create(env); + host_attr = axiom_attribute_create(env, AXIS2_HTTP_PROXY_HOST, proxy_host, NULL); + port_attr = axiom_attribute_create(env, AXIS2_HTTP_PROXY_PORT, proxy_port, NULL); + axutil_generic_obj_set_value(host_obj, env, host_attr); + axutil_generic_obj_set_free_func(host_obj, env, axiom_attribute_free_void_arg); + axutil_generic_obj_set_value(port_obj, env, port_attr); + axutil_generic_obj_set_free_func(port_obj, env, axiom_attribute_free_void_arg); + + axutil_hash_set(attribute, AXIS2_HTTP_PROXY_HOST, AXIS2_HASH_KEY_STRING, host_obj); + axutil_hash_set(attribute, AXIS2_HTTP_PROXY_PORT, AXIS2_HASH_KEY_STRING, port_obj); + if(username && password) + { + username_obj = axutil_generic_obj_create(env); + password_obj = axutil_generic_obj_create(env); + username_attr = axiom_attribute_create(env, AXIS2_HTTP_PROXY_USERNAME, username, NULL); + password_attr = axiom_attribute_create(env, AXIS2_HTTP_PROXY_PASSWORD, password, NULL); + axutil_generic_obj_set_value(username_obj, env, username_attr); + axutil_generic_obj_set_value(password_obj, env, password_attr); + axutil_generic_obj_set_free_func(username_obj, env, axiom_attribute_free_void_arg); + axutil_generic_obj_set_free_func(password_obj, env, axiom_attribute_free_void_arg); + axutil_hash_set(attribute, AXIS2_HTTP_PROXY_USERNAME, AXIS2_HASH_KEY_STRING, + username_obj); + axutil_hash_set(attribute, AXIS2_HTTP_PROXY_PASSWORD, AXIS2_HASH_KEY_STRING, + password_obj); + } + axutil_param_set_attributes(param, env, attribute); + axutil_param_container_add_param(param_container, env, param); + } + return AXIS2_SUCCESS; +} + +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) +{ + return axis2_svc_client_set_proxy_with_auth(svc_client, env, proxy_host, proxy_port, NULL, NULL); +} + +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) +{ + neethi_policy_t *neethi_policy = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + neethi_policy = neethi_util_create_policy_from_om(env, root_node); + + if(neethi_policy) + { + return axis2_svc_client_set_policy(svc_client, env, neethi_policy); + } + else + { + return AXIS2_FAILURE; + } +} + +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) +{ + + axis2_svc_t *svc = NULL; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, policy, AXIS2_FAILURE); + + svc = axis2_svc_client_get_svc(svc_client, env); + + if(!svc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Cannot find service of service client. Cannot set policy."); + return AXIS2_FAILURE; + } + + desc = axis2_svc_get_base(svc, env); + if(!desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Cannot find service description of service client. Cannot set policy."); + return AXIS2_FAILURE; + } + + policy_include = axis2_desc_get_policy_include(desc, env); + if(!policy_include) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot find policy include. Cannot set policy."); + return AXIS2_FAILURE; + } + + axis2_policy_include_add_policy_element(policy_include, env, AXIS2_SERVICE_POLICY, policy); + return AXIS2_SUCCESS; +} + +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) +{ + return svc_client->http_headers; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_svc_client_get_http_status_code( + axis2_svc_client_t * svc_client, + const axutil_env_t * env) +{ + return svc_client->http_status_code; +} + +void +axis2_svc_client_set_http_info( + axis2_svc_client_t * svc_client, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_transport_in_desc_t *transport_in = NULL; + axutil_param_t *expose_headers_param = NULL; + axis2_bool_t expose_headers = AXIS2_FALSE; + + if(msg_ctx) + { + transport_in = axis2_msg_ctx_get_transport_in_desc(msg_ctx, env); + if(transport_in) + { + expose_headers_param = axutil_param_container_get_param( + axis2_transport_in_desc_param_container(transport_in, env), env, + AXIS2_EXPOSE_HEADERS); + } + if(expose_headers_param) + { + axis2_char_t *expose_headers_value = NULL; + expose_headers_value = axutil_param_get_value(expose_headers_param, env); + if(expose_headers_value && 0 == axutil_strcasecmp(expose_headers_value, + AXIS2_VALUE_TRUE)) + { + expose_headers = AXIS2_TRUE; + } + } + } + if(expose_headers) + { + if(svc_client->http_headers == axis2_msg_ctx_get_http_output_headers(msg_ctx, env)) + { + svc_client->http_status_code = axis2_msg_ctx_get_status_code(msg_ctx, env); + return; + } + } + + if(svc_client->http_headers) + { + axis2_http_header_t *header = NULL; + while(axutil_array_list_size(svc_client->http_headers, env)) + { + header = (axis2_http_header_t *)axutil_array_list_remove(svc_client->http_headers, env, + 0); + if(header) + { + axis2_http_header_free(header, env); + } + } + axutil_array_list_free(svc_client->http_headers, env); + svc_client->http_headers = NULL; + } + svc_client->http_status_code = 0; + + if(msg_ctx) + { + if(expose_headers) + { + svc_client->http_headers = axis2_msg_ctx_extract_http_output_headers(msg_ctx, env); + } + svc_client->http_status_code = axis2_msg_ctx_get_status_code(msg_ctx, env); + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_client_close( + axis2_svc_client_t * svc_client, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_property_t *property = NULL; + axis2_endpoint_ref_t *replyto = NULL; + + property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); + axis2_options_set_property(svc_client->options, env, AXIS2_SVC_CLIENT_CLOSED, property); + replyto = axis2_options_get_reply_to(svc_client->options, env); + if(replyto) + { + axiom_node_t *reply = NULL; + + reply = axis2_svc_client_send_receive(svc_client, env, NULL); + if(reply) + { + status = AXIS2_SUCCESS; + } + } + else + { + status = axis2_svc_client_send_robust(svc_client, env, NULL); + } + + return status; +} + diff --git a/src/core/context/Makefile.am b/src/core/context/Makefile.am new file mode 100644 index 0000000..30184e0 --- /dev/null +++ b/src/core/context/Makefile.am @@ -0,0 +1,13 @@ +noinst_LTLIBRARIES = libaxis2_context.la + +libaxis2_context_la_SOURCES = ctx.c \ + msg_ctx.c \ + op_ctx.c \ + svc_ctx.c \ + svc_grp_ctx.c \ + conf_ctx.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/context/conf_ctx.c b/src/core/context/conf_ctx.c new file mode 100644 index 0000000..9922649 --- /dev/null +++ b/src/core/context/conf_ctx.c @@ -0,0 +1,599 @@ +/* + * 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. + */ + +#include +#include +#include +#include + + +struct axis2_conf_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** engine configuration */ + axis2_conf_t *conf; + + /** root directory */ + /* should be handled as a URL string ? */ + axis2_char_t *root_dir; + + /** + * axutil_hash_t *containing message ID to + * operation context mapping. + */ + axutil_hash_t *op_ctx_map; + + axutil_hash_t *svc_ctx_map; + + axutil_hash_t *svc_grp_ctx_map; + + /* Mutex to synchronize the read/write operations */ + axutil_thread_mutex_t *mutex; +}; + +AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL +axis2_conf_ctx_create( + const axutil_env_t * env, + axis2_conf_t * conf) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + + conf_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_conf_ctx_t)); + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + conf_ctx->base = NULL; + conf_ctx->conf = NULL; + conf_ctx->root_dir = NULL; + conf_ctx->op_ctx_map = NULL; + conf_ctx->svc_ctx_map = NULL; + conf_ctx->svc_grp_ctx_map = NULL; + conf_ctx->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); + if(!conf_ctx->mutex) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create thread mutex"); + return NULL; + } + + if(conf) + conf_ctx->conf = conf; + + conf_ctx->base = axis2_ctx_create(env); + if(!(conf_ctx->base)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create base context"); + return NULL; + } + + conf_ctx->op_ctx_map = axutil_hash_make(env); + if(!(conf_ctx->op_ctx_map)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create operation context map"); + return NULL; + } + + conf_ctx->svc_ctx_map = axutil_hash_make(env); + if(!(conf_ctx->svc_ctx_map)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service context map"); + return NULL; + } + + conf_ctx->svc_grp_ctx_map = axutil_hash_make(env); + if(!(conf_ctx->svc_grp_ctx_map)) + { + axis2_conf_ctx_free(conf_ctx, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create service group context map"); + return NULL; + } + + return conf_ctx; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_ctx_set_conf( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env, + axis2_conf_t * conf) +{ + conf_ctx->conf = conf; /* We just maintain a shallow copy here */ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL +axis2_conf_ctx_get_base( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + return conf_ctx->base; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_conf_ctx_get_conf( + const axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + return conf_ctx->conf; +} + +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) +{ + return conf_ctx->op_ctx_map; +} + +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) +{ + return conf_ctx->svc_ctx_map; +} + +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) +{ + return conf_ctx->svc_grp_ctx_map; +} + +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) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->op_ctx_map) + { + axutil_hash_set(conf_ctx->op_ctx_map, message_id, AXIS2_HASH_KEY_STRING, op_ctx); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_op_ctx_t *rv = NULL; + + AXIS2_PARAM_CHECK(env->error, message_id, NULL); + + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->op_ctx_map) + { + rv = (axis2_op_ctx_t *)axutil_hash_get(conf_ctx->op_ctx_map, message_id, + AXIS2_HASH_KEY_STRING); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +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) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_ctx_map) + { + axutil_hash_set(conf_ctx->svc_ctx_map, svc_id, AXIS2_HASH_KEY_STRING, svc_ctx); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_ctx_t *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) +{ + axis2_svc_ctx_t *rv = NULL; + + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_ctx_map) + { + rv = (axis2_svc_ctx_t *)axutil_hash_get(conf_ctx->svc_ctx_map, svc_id, + AXIS2_HASH_KEY_STRING); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +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) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_grp_ctx_map) + { + axutil_hash_set(conf_ctx->svc_grp_ctx_map, svc_grp_id, AXIS2_HASH_KEY_STRING, svc_grp_ctx); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_svc_grp_ctx_t *rv = NULL; + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->svc_grp_ctx_map) + { + rv = (axis2_svc_grp_ctx_t *)axutil_hash_get(conf_ctx->svc_grp_ctx_map, svc_grp_id, + AXIS2_HASH_KEY_STRING); + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +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) +{ + axis2_char_t *rv = NULL; + /* Do we need to lock here? - damitha */ + axutil_thread_mutex_lock(conf_ctx->mutex); + rv = conf_ctx->root_dir; + axutil_thread_mutex_unlock(conf_ctx->mutex); + return rv; +} + +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) +{ + axutil_thread_mutex_lock(conf_ctx->mutex); + if(conf_ctx->root_dir) + { + AXIS2_FREE(env->allocator, conf_ctx->root_dir); + conf_ctx->root_dir = NULL; + } + + if(path) + { + conf_ctx->root_dir = axutil_strdup(env, path); + if(!(conf_ctx->root_dir)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axutil_thread_mutex_unlock(conf_ctx->mutex); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +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) +{ + axutil_hash_index_t *hi = NULL; + void *ctx = NULL; + + axutil_thread_mutex_lock(conf_ctx->mutex); + conf_ctx->conf = conf; + + for(hi = axutil_hash_first(conf_ctx->op_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &ctx); + if(ctx) + { + axis2_op_ctx_t *op_ctx = (axis2_op_ctx_t *)ctx; + axis2_op_ctx_init(op_ctx, env, conf); + } + } + + for(hi = axutil_hash_first(conf_ctx->svc_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &ctx); + if(ctx) + { + axis2_svc_ctx_t *svc_ctx = (axis2_svc_ctx_t *)ctx; + axis2_svc_ctx_init(svc_ctx, env, conf); + } + } + + for(hi = axutil_hash_first(conf_ctx->svc_grp_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &ctx); + if(ctx) + { + axis2_svc_grp_ctx_t *svc_grp_ctx = (axis2_svc_grp_ctx_t *)ctx; + axis2_svc_grp_ctx_init(svc_grp_ctx, env, conf); + } + } + axutil_thread_mutex_unlock(conf_ctx->mutex); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_conf_ctx_free( + axis2_conf_ctx_t * conf_ctx, + const axutil_env_t * env) +{ + if(conf_ctx->base) + { + axis2_ctx_free(conf_ctx->base, env); + } + + if(conf_ctx->op_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf_ctx->op_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_op_ctx_t *op_ctx = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + op_ctx = (axis2_op_ctx_t *)val; + if(op_ctx) + axis2_op_ctx_free(op_ctx, env); + val = NULL; + op_ctx = NULL; + + } + axutil_hash_free(conf_ctx->op_ctx_map, env); + } + + if(conf_ctx->svc_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf_ctx->svc_ctx_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_svc_ctx_t *svc_ctx = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + svc_ctx = (axis2_svc_ctx_t *)val; + if(svc_ctx) + axis2_svc_ctx_free(svc_ctx, env); + + val = NULL; + svc_ctx = NULL; + + } + axutil_hash_free(conf_ctx->svc_ctx_map, env); + } + + if(conf_ctx->svc_grp_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf_ctx->svc_grp_ctx_map, env); hi; hi = axutil_hash_next(env, + hi)) + { + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + svc_grp_ctx = (axis2_svc_grp_ctx_t *)val; + if(svc_grp_ctx) + axis2_svc_grp_ctx_free(svc_grp_ctx, env); + + val = NULL; + svc_grp_ctx = NULL; + + } + axutil_hash_free(conf_ctx->svc_grp_ctx_map, env); + } + if(conf_ctx->conf) + { + axis2_conf_free(conf_ctx->conf, env); + } + if(conf_ctx->mutex) + { + axutil_thread_mutex_destroy(conf_ctx->mutex); + } + + if(conf_ctx->root_dir) + { + AXIS2_FREE(env->allocator, conf_ctx->root_dir); + } + + AXIS2_FREE(env->allocator, conf_ctx); +} + +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) +{ + axis2_char_t *svc_grp_ctx_id = NULL; + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_svc_t *svc = NULL; + axis2_svc_grp_t *svc_grp = NULL; + const axutil_qname_t *qname = NULL; + axis2_char_t *svc_id = NULL; + axis2_op_ctx_t *op_ctx = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + svc = axis2_msg_ctx_get_svc(msg_ctx, env); + if(!svc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SERVICE_NOT_YET_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Service not yet found in message context. Cannot proceed"); + + return NULL; + } + + qname = axis2_svc_get_qname(svc, env); + if(!qname) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); + return NULL; + } + + svc_id = axutil_qname_get_localpart(qname, env); + if(!svc_id) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); + return NULL; + } + + svc_grp = axis2_svc_get_parent(svc, env); + if(svc_grp) + { + svc_grp_ctx_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); + } + + if(!svc_grp_ctx_id) + { + svc_grp_ctx_id = (axis2_char_t *)axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id( + msg_ctx, env), env); + } + + /* By this time service group context id must have a value, either from transport or from + * addressing + */ + if(svc_grp_ctx_id) + { + svc_grp_ctx = (axis2_svc_grp_ctx_t *)axutil_hash_get(conf_ctx->svc_grp_ctx_map, + svc_grp_ctx_id, AXIS2_HASH_KEY_STRING); + + if(svc_grp_ctx) + { + svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); + if(!svc_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Service group context has no servie context set for service %s", svc_id); + + return NULL; + } + } + } + + if(!svc_grp_ctx_id) + { + svc_grp_ctx_id = axutil_uuid_gen(env); + if(svc_grp_ctx_id) + { + axutil_string_t *svc_grp_ctx_id_str = axutil_string_create_assume_ownership(env, + &svc_grp_ctx_id); + + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); + axutil_string_free(svc_grp_ctx_id_str, env); + } + } + + if(!svc_grp_ctx) + { + axis2_svc_grp_t *svc_grp = NULL; + svc_grp = axis2_svc_get_parent(svc, env); + svc_grp_ctx = axis2_svc_grp_get_svc_grp_ctx(svc_grp, env, conf_ctx); + svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); + if(!svc_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Service group context has no servie context set for service %s", svc_id); + + return NULL; + } + + axis2_svc_grp_ctx_set_id(svc_grp_ctx, env, svc_grp_ctx_id); + axis2_conf_ctx_register_svc_grp_ctx(conf_ctx, env, svc_grp_ctx_id, svc_grp_ctx); + } + + /* When you come here operation context MUST have already been assigned + to the message context */ + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(!op_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MSG_CTX, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation context not set for message context"); + return NULL; + } + + axis2_op_ctx_set_parent(op_ctx, env, svc_ctx); + axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx); + axis2_msg_ctx_set_svc_grp_ctx(msg_ctx, env, svc_grp_ctx); + return svc_grp_ctx; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, key, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); + + axutil_thread_mutex_lock(conf_ctx->mutex); + status = axis2_ctx_set_property(conf_ctx->base, env, key, value); + axutil_thread_mutex_unlock(conf_ctx->mutex); + + return status; +} + +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) +{ + axutil_property_t* property = NULL; + AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, key, NULL); + + axutil_thread_mutex_lock(conf_ctx->mutex); + property = axis2_ctx_get_property(conf_ctx->base, env, key); + axutil_thread_mutex_unlock(conf_ctx->mutex); + + return property; +} diff --git a/src/core/context/ctx.c b/src/core/context/ctx.c new file mode 100644 index 0000000..df39a9b --- /dev/null +++ b/src/core/context/ctx.c @@ -0,0 +1,197 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_ctx +{ + + /** non persistent map */ + axutil_hash_t *property_map; + + /** non persistent map is a deep copy */ + axis2_bool_t property_map_deep_copy; +}; + +AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL +axis2_ctx_create( + const axutil_env_t * env) +{ + axis2_ctx_t *ctx = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_ctx_t)); + if(!ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ctx->property_map = NULL; + + ctx->property_map = axutil_hash_make(env); + ctx->property_map_deep_copy = AXIS2_TRUE; + if(!(ctx->property_map)) + { + axis2_ctx_free(ctx, env); + return NULL; + } + + return ctx; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(value) + { + /* handle the case where we are setting a new value with the + same key, we would have to free the existing value */ + axutil_property_t *temp_value = axutil_hash_get(ctx->property_map, key, + AXIS2_HASH_KEY_STRING); + if(temp_value) + { + void *temp_value_value = axutil_property_get_value(temp_value, env); + void *value_value = axutil_property_get_value(value, env); + if(temp_value_value != value_value) + { + axutil_property_free(temp_value, env); + } + } + } + if(ctx->property_map) + { + axutil_hash_set(ctx->property_map, key, AXIS2_HASH_KEY_STRING, value); + } + + return AXIS2_SUCCESS; +} + +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) +{ + axutil_property_t *ret = NULL; + + if(ctx->property_map) + { + ret = axutil_hash_get(ctx->property_map, key, AXIS2_HASH_KEY_STRING); + } + + /** it is the responsibility of the caller to look-up parent if key is not found here + Note that in C implementation it is the responsibility of the deriving struct to + handle the parent as we do not have the inheritance facility. In case of + context it is not worth trying to mimic inheritance. */ + + return ret; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_ctx_get_all_properties( + const axis2_ctx_t * ctx, + const axutil_env_t * env) +{ + return ctx->property_map; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_ctx_get_property_map( + const axis2_ctx_t * ctx, + const axutil_env_t * env) +{ + return ctx->property_map; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_ctx_free( + struct axis2_ctx *ctx, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(ctx->property_map && ctx->property_map_deep_copy) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + for(hi = axutil_hash_first(ctx->property_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_property_t *property = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + property = (axutil_property_t *)val; + + if(property) + { + axutil_property_free(property, env); + } + } + axutil_hash_free(ctx->property_map, env); + } + + AXIS2_FREE(env->allocator, ctx); + + return; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(ctx->property_map && ctx->property_map_deep_copy) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + for(hi = axutil_hash_first(ctx->property_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_property_t *property = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + property = (axutil_property_t *)val; + + if(property) + { + axutil_property_free(property, env); + } + } + if(ctx->property_map != map) /* handle repeated invocation case */ + { + axutil_hash_free(ctx->property_map, env); + } + } + + ctx->property_map = map; + ctx->property_map_deep_copy = AXIS2_FALSE; + + return AXIS2_SUCCESS; +} diff --git a/src/core/context/msg_ctx.c b/src/core/context/msg_ctx.c new file mode 100644 index 0000000..c2342c4 --- /dev/null +++ b/src/core/context/msg_ctx.c @@ -0,0 +1,2768 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +struct axis2_msg_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of message context is an op context instance */ + struct axis2_op_ctx *parent; + + /** process fault enabled? */ + axis2_bool_t process_fault; + + /** + * Addressing Information for Axis 2 + * Following Properties will be kept inside this, these fields will be initially filled by + * the transport. Then later an addressing handler will make relevant changes to this, if addressing + * information is present in the SOAP header. + */ + axis2_msg_info_headers_t *msg_info_headers; + axis2_bool_t msg_info_headers_deep_copy; + + struct axis2_op_ctx *op_ctx; + struct axis2_svc_ctx *svc_ctx; + struct axis2_svc_grp_ctx *svc_grp_ctx; + struct axis2_conf_ctx *conf_ctx; + + /** op */ + axis2_op_t *op; + + /** service */ + axis2_svc_t *svc; + + /** service group */ + axis2_svc_grp_t *svc_grp; + + axis2_transport_in_desc_t *transport_in_desc; + axis2_transport_out_desc_t *transport_out_desc; + + /** SOAP envelope */ + axiom_soap_envelope_t *soap_envelope; + + /** Response SOAP envelope */ + axiom_soap_envelope_t *response_soap_envelope; + + /** SOAP Fault envelope */ + axiom_soap_envelope_t *fault_soap_envelope; + + /** in fault flow? */ + axis2_bool_t in_fault_flow; + + /** is this server side? */ + axis2_bool_t server_side; + + /** message ID */ + axis2_char_t *message_id; + + /** new thread required? */ + axis2_bool_t new_thread_required; + + /** paused */ + axis2_bool_t paused; + axis2_bool_t keep_alive; + + /** output written? */ + axis2_bool_t output_written; + + /** service context ID */ + axis2_char_t *svc_ctx_id; + + /** paused phase name */ + axis2_char_t *paused_phase_name; + + /** paused handler name */ + axutil_string_t *paused_handler_name; + + /** SOAP action */ + axutil_string_t *soap_action; + + /** REST HTTP Method */ + axis2_char_t *rest_http_method; + + /** + * Supported REST HTTP Methods + * Made use of in a 405 Error Scenario + */ + axutil_array_list_t *supported_rest_http_methods; + + /** are we doing MTOM now? */ + axis2_bool_t doing_mtom; + + /** are we doing REST now? */ + axis2_bool_t doing_rest; + + /** Rest through HTTP POST? */ + axis2_bool_t do_rest_through_post; + + /** Session management enabled? */ + axis2_bool_t manage_session; + + /* http status code */ + int status_code; + + /** use SOAP 1.1? */ + axis2_bool_t is_soap_11; + + /** service group context id */ + axutil_string_t *svc_grp_ctx_id; + + /** qname of transport in */ + AXIS2_TRANSPORT_ENUMS transport_in_desc_enum; + + /** qname of transport out */ + AXIS2_TRANSPORT_ENUMS transport_out_desc_enum; + + /** service group id */ + axis2_char_t *svc_grp_id; + + /** service description qname */ + axutil_qname_t *svc_qname; + + /** op qname */ + axutil_qname_t *op_qname; + /* To keep track of the direction */ + int flow; + + /** The chain of Handlers/Phases for processing this message */ + axutil_array_list_t *execution_chain; + + /** Index into the execution chain of the currently executing handler */ + int current_handler_index; + + /** Index of the paused handler */ + int paused_handler_index; + + /** Index of the paused phase */ + int paused_phase_index; + + /** Index into the current Phase of the currently executing handler (if any)*/ + int current_phase_index; + + /* axis2 options container */ + + axis2_options_t *options; + + /** + * 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 + */ + struct axis2_svc * + ( + AXIS2_CALL * 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 + */ + struct axis2_op * + ( + AXIS2_CALL * find_op) + ( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + struct axis2_svc * svc); + + axutil_string_t *charset_encoding; + axutil_stream_t *transport_out_stream; + axis2_out_transport_info_t *out_transport_info; + axutil_hash_t *transport_headers; + axutil_array_list_t *output_headers; + axutil_array_list_t *accept_record_list; + axutil_array_list_t *accept_charset_record_list; + axutil_array_list_t *accept_language_record_list; + axis2_char_t *transfer_encoding; + axis2_char_t *content_language; + axis2_char_t *transport_url; + axis2_bool_t is_auth_failure; + axis2_bool_t required_auth_is_http; + axis2_char_t *auth_type; + axis2_bool_t no_content; + + axutil_array_list_t *mime_parts; + int ref; +}; + +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) +{ + axis2_msg_ctx_t *msg_ctx = NULL; + + msg_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_ctx_t)); + if(!msg_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)msg_ctx, 0, sizeof(axis2_msg_ctx_t)); + msg_ctx->base = NULL; + msg_ctx->process_fault = AXIS2_FALSE; + msg_ctx->msg_info_headers = NULL; + msg_ctx->op_ctx = NULL; + msg_ctx->svc_ctx = NULL; + msg_ctx->svc_grp_ctx = NULL; + msg_ctx->conf_ctx = NULL; + msg_ctx->op = NULL; + msg_ctx->svc = NULL; + msg_ctx->svc_grp = NULL; + msg_ctx->transport_in_desc = NULL; + msg_ctx->transport_out_desc = NULL; + msg_ctx->soap_envelope = NULL; + msg_ctx->fault_soap_envelope = NULL; + msg_ctx->in_fault_flow = AXIS2_FALSE; + msg_ctx->server_side = AXIS2_FALSE; + msg_ctx->message_id = NULL; + msg_ctx->new_thread_required = AXIS2_FALSE; + msg_ctx->paused = AXIS2_FALSE; + msg_ctx->keep_alive = AXIS2_FALSE; + msg_ctx->output_written = AXIS2_FALSE; + msg_ctx->svc_ctx_id = NULL; + msg_ctx->paused_phase_name = NULL; + msg_ctx->paused_handler_name = NULL; + msg_ctx->soap_action = NULL; + msg_ctx->rest_http_method = NULL; + msg_ctx->supported_rest_http_methods = NULL; + msg_ctx->doing_mtom = AXIS2_FALSE; + msg_ctx->doing_rest = AXIS2_FALSE; + msg_ctx->do_rest_through_post = AXIS2_FALSE; + msg_ctx->manage_session = AXIS2_FALSE; + msg_ctx->is_soap_11 = AXIS2_FALSE; + msg_ctx->svc_grp_ctx_id = NULL; + msg_ctx->transport_in_desc_enum = AXIS2_TRANSPORT_ENUM_MAX; + msg_ctx->transport_out_desc_enum = AXIS2_TRANSPORT_ENUM_MAX; + msg_ctx->svc_grp_id = NULL; + msg_ctx->svc_qname = NULL; + msg_ctx->op_qname = NULL; + msg_ctx->flow = AXIS2_IN_FLOW; + msg_ctx->execution_chain = NULL; + msg_ctx->current_handler_index = -1; + msg_ctx->paused_handler_index = -1; + msg_ctx->current_phase_index = 0; + msg_ctx->paused_phase_index = 0; + msg_ctx->charset_encoding = NULL; + msg_ctx->transport_out_stream = NULL; + msg_ctx->out_transport_info = NULL; + msg_ctx->transport_headers = NULL; + msg_ctx->accept_record_list = NULL; + msg_ctx->accept_charset_record_list = NULL; + msg_ctx->output_headers = NULL; + msg_ctx->accept_language_record_list = NULL; + msg_ctx->transfer_encoding = NULL; + msg_ctx->content_language = NULL; + msg_ctx->transport_url = NULL; + msg_ctx->response_soap_envelope = NULL; + msg_ctx->is_auth_failure = AXIS2_FALSE; + msg_ctx->required_auth_is_http = AXIS2_FALSE; + msg_ctx->auth_type = NULL; + msg_ctx->no_content = AXIS2_FALSE; + msg_ctx->status_code = 0; + msg_ctx->options = NULL; + msg_ctx->mime_parts = NULL; + + msg_ctx->base = axis2_ctx_create(env); + if(!(msg_ctx->base)) + { + axis2_msg_ctx_free(msg_ctx, env); + return NULL; + } + + if(transport_in_desc) + msg_ctx->transport_in_desc = transport_in_desc; + if(transport_out_desc) + msg_ctx->transport_out_desc = transport_out_desc; + if(conf_ctx) + msg_ctx->conf_ctx = conf_ctx; + + if(msg_ctx->transport_in_desc) + msg_ctx->transport_in_desc_enum = axis2_transport_in_desc_get_enum(transport_in_desc, env); + if(msg_ctx->transport_out_desc) + msg_ctx->transport_out_desc_enum = axis2_transport_out_desc_get_enum(transport_out_desc, + env); + + msg_ctx->msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL); + if(!(msg_ctx->msg_info_headers)) + { + axis2_msg_ctx_free(msg_ctx, env); + return NULL; + } + msg_ctx->msg_info_headers_deep_copy = AXIS2_TRUE; + msg_ctx->ref = 1; + + return msg_ctx; +} + +/******************************************************************************/ +struct axis2_ctx *AXIS2_CALL +axis2_msg_ctx_get_base( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + return msg_ctx->base; +} + +struct axis2_op_ctx *AXIS2_CALL +axis2_msg_ctx_get_parent( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->parent; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_parent( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_op_ctx * parent) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(parent) + { + msg_ctx->parent = parent; + } + + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_msg_ctx_free( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(--(msg_ctx->ref) > 0) + { + return; + } + + if(msg_ctx->keep_alive) + { + return; + } + + if(msg_ctx->base) + { + axis2_ctx_free(msg_ctx->base, env); + } + + if(msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy) + { + axis2_msg_info_headers_free(msg_ctx->msg_info_headers, env); + } + + if(msg_ctx->message_id) + { + AXIS2_FREE(env->allocator, msg_ctx->message_id); + } + + if(msg_ctx->svc_ctx_id) + { + AXIS2_FREE(env->allocator, msg_ctx->svc_ctx_id); + } + + if(msg_ctx->soap_action) + { + axutil_string_free(msg_ctx->soap_action, env); + } + + if(msg_ctx->rest_http_method) + { + AXIS2_FREE(env->allocator, msg_ctx->rest_http_method); + } + + if(msg_ctx->svc_grp_ctx_id) + { + axutil_string_free(msg_ctx->svc_grp_ctx_id, env); + } + + if(msg_ctx->soap_envelope) + { + axiom_soap_envelope_free(msg_ctx->soap_envelope, env); + } + + if(msg_ctx->fault_soap_envelope) + { + axiom_soap_envelope_free(msg_ctx->fault_soap_envelope, env); + } + + if(msg_ctx->charset_encoding) + { + axutil_string_free(msg_ctx->charset_encoding, env); + } + + if(msg_ctx->transport_out_stream) + { + axutil_stream_free(msg_ctx->transport_out_stream, env); + } + + if(msg_ctx->out_transport_info) + { + AXIS2_OUT_TRANSPORT_INFO_FREE(msg_ctx->out_transport_info, env); + } + + if(msg_ctx->transport_headers) + { + axutil_hash_free(msg_ctx->transport_headers, env); + } + + if(msg_ctx->accept_charset_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_charset_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_charset_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_charset_record_list, env); + } + + if(msg_ctx->output_headers) + { + axis2_http_header_t *header = NULL; + while(axutil_array_list_size(msg_ctx->output_headers, env)) + { + header = (axis2_http_header_t *)axutil_array_list_remove(msg_ctx->output_headers, env, + 0); + if(header) + { + axis2_http_header_free(header, env); + } + } + axutil_array_list_free(msg_ctx->output_headers, env); + } + + if(msg_ctx->accept_language_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_language_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_language_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_language_record_list, env); + } + + if(msg_ctx->accept_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_record_list, env); + } + + if(msg_ctx->transfer_encoding) + { + AXIS2_FREE(env->allocator, msg_ctx->transfer_encoding); + } + + if(msg_ctx->content_language) + { + AXIS2_FREE(env->allocator, msg_ctx->content_language); + } + + if(msg_ctx->auth_type) + { + AXIS2_FREE(env->allocator, msg_ctx->auth_type); + } + + if(msg_ctx->supported_rest_http_methods) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(msg_ctx->supported_rest_http_methods, env); + for(i = 0; i < size; i++) + { + axis2_char_t *rest_http_method = NULL; + rest_http_method = axutil_array_list_get(msg_ctx->supported_rest_http_methods, env, i); + if(rest_http_method) + { + AXIS2_FREE(env->allocator, rest_http_method); + } + } + axutil_array_list_free(msg_ctx->supported_rest_http_methods, env); + } + + if(msg_ctx->options) + { + /* freeing only axis2_options_t allocated space, should not + * call axis2_options_free because it will free internal + * properties as well. */ + AXIS2_FREE(env->allocator, msg_ctx->options); + } + + AXIS2_FREE(env->allocator, msg_ctx); + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_ctx_increment_ref( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + msg_ctx->ref++; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_init( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_conf * conf) +{ + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + msg_ctx->transport_in_desc = axis2_conf_get_transport_in(conf, env, + msg_ctx-> transport_in_desc_enum); + + msg_ctx->transport_out_desc = axis2_conf_get_transport_out(conf, env, + msg_ctx-> transport_out_desc_enum); + + if(msg_ctx->svc_grp_id) + { + msg_ctx->svc_grp = axis2_conf_get_svc_grp(conf, env, msg_ctx->svc_grp_id); + } + + if(msg_ctx->svc_qname) + { + msg_ctx->svc = axis2_conf_get_svc(conf, env, axutil_qname_get_localpart( + msg_ctx-> svc_qname, env)); + } + + if(msg_ctx->op_qname) + { + if(msg_ctx->svc) + msg_ctx->op = axis2_svc_get_op_with_qname(msg_ctx->svc, env, msg_ctx->op_qname); + } + + return AXIS2_SUCCESS; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_fault_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_fault_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_from( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_from(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_in_fault_flow( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->in_fault_flow; +} + +axiom_soap_envelope_t *AXIS2_CALL +axis2_msg_ctx_get_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->soap_envelope; +} + +axiom_soap_envelope_t *AXIS2_CALL +axis2_msg_ctx_get_response_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->response_soap_envelope; +} + +axiom_soap_envelope_t *AXIS2_CALL +axis2_msg_ctx_get_fault_soap_envelope( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->fault_soap_envelope; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_msg_id( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_message_id(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_message_id(msg_ctx->msg_info_headers, env, msg_id); + } + + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_process_fault( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->process_fault; +} + +axis2_relates_to_t *AXIS2_CALL +axis2_msg_ctx_get_relates_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_relates_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_reply_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_reply_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_server_side( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->server_side; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_msg_ctx_get_to( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_to(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_fault_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_from( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_from(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_in_fault_flow( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t in_fault_flow) +{ + msg_ctx->in_fault_flow = in_fault_flow; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_soap_envelope( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axiom_soap_envelope_t * soap_envelope) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(soap_envelope) + { + int soap_v = AXIOM_SOAP12; + soap_v = axiom_soap_envelope_get_soap_version(soap_envelope, env); + msg_ctx->is_soap_11 = (soap_v == AXIOM_SOAP12) ? AXIS2_FALSE : AXIS2_TRUE; + msg_ctx->soap_envelope = soap_envelope; + } + else + { + msg_ctx->soap_envelope = NULL; + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_response_soap_envelope( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axiom_soap_envelope_t * soap_envelope) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(soap_envelope) + { + int soap_v = AXIOM_SOAP12; + soap_v = axiom_soap_envelope_get_soap_version(soap_envelope, env); + msg_ctx->response_soap_envelope = soap_envelope; + } + else + { + msg_ctx->response_soap_envelope = NULL; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_fault_soap_envelope( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axiom_soap_envelope_t * soap_envelope) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->fault_soap_envelope = soap_envelope; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_message_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_message_id(msg_ctx->msg_info_headers, env, message_id); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_process_fault( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t process_fault) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->process_fault = process_fault; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_relates_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_relates_to_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_relates_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_reply_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_reply_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_server_side( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t server_side) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->server_side = server_side; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_to( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_endpoint_ref_t * reference) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_to(msg_ctx->msg_info_headers, env, reference); + } + + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_new_thread_required( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + return msg_ctx->new_thread_required; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_new_thread_required( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t new_thread_required) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->new_thread_required = new_thread_required; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_wsa_action( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * action_uri) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_action(msg_ctx->msg_info_headers, env, action_uri); + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_wsa_action( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_action(msg_ctx->msg_info_headers, env); + } + + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_wsa_message_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * message_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_set_message_id(msg_ctx->msg_info_headers, env, message_id); + } + + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->msg_info_headers) + { + return axis2_msg_info_headers_get_message_id(msg_ctx->msg_info_headers, env); + } + + return NULL; + +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->msg_info_headers; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_paused( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->paused; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_paused( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t paused) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->paused = paused; + msg_ctx->paused_phase_index = msg_ctx->current_phase_index; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_keep_alive( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t keep_alive) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->keep_alive = keep_alive; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_is_keep_alive( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->keep_alive; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->transport_in_desc; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->transport_out_desc; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transport_in_desc( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_transport_in_desc * transport_in_desc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(transport_in_desc) + { + msg_ctx->transport_in_desc = transport_in_desc; + msg_ctx->transport_in_desc_enum = axis2_transport_in_desc_get_enum(transport_in_desc, env); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_transport_out_desc( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_transport_out_desc * transport_out_desc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(transport_out_desc) + { + msg_ctx->transport_out_desc = transport_out_desc; + msg_ctx->transport_out_desc_enum = axis2_transport_out_desc_get_enum(transport_out_desc, + env); + } + + return AXIS2_SUCCESS; +} + +struct axis2_op_ctx *AXIS2_CALL +axis2_msg_ctx_get_op_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->op_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_op_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_op_ctx * op_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(op_ctx) + { + msg_ctx->op_ctx = op_ctx; + + if(msg_ctx->svc_ctx) + { + if(!(axis2_op_ctx_get_parent(msg_ctx->op_ctx, env))) + { + axis2_op_ctx_set_parent(msg_ctx->op_ctx, env, msg_ctx->svc_ctx); + } + } + axis2_msg_ctx_set_parent(msg_ctx, env, op_ctx); + axis2_msg_ctx_set_op(msg_ctx, env, axis2_op_ctx_get_op(op_ctx, env)); + } + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_output_written( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->output_written; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_output_written( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t output_written) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->output_written = output_written; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->rest_http_method; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->rest_http_method) + { + AXIS2_FREE(env->allocator, msg_ctx->rest_http_method); + msg_ctx->rest_http_method = NULL; + } + + if(rest_http_method) + { + msg_ctx->rest_http_method = axutil_strdup(env, rest_http_method); + if(!(msg_ctx->rest_http_method)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_ctx_id; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_ctx_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * svc_ctx_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx->svc_ctx_id) + { + AXIS2_FREE(env->allocator, msg_ctx->svc_ctx_id); + msg_ctx->svc_ctx_id = NULL; + } + + if(svc_ctx_id) + { + msg_ctx->svc_ctx_id = axutil_strdup(env, svc_ctx_id); + if(!(msg_ctx->svc_ctx_id)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +struct axis2_conf_ctx *AXIS2_CALL +axis2_msg_ctx_get_conf_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->conf_ctx; +} + +struct axis2_svc_ctx *AXIS2_CALL +axis2_msg_ctx_get_svc_ctx( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_conf_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_conf_ctx * conf_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(conf_ctx) + { + msg_ctx->conf_ctx = conf_ctx; + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_svc_ctx * svc_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(svc_ctx) + { + msg_ctx->svc_ctx = svc_ctx; + + if(msg_ctx->op_ctx) + { + if(!axis2_op_ctx_get_parent(msg_ctx->op_ctx, env)) + axis2_op_ctx_set_parent(msg_ctx->op_ctx, env, svc_ctx); + } + axis2_msg_ctx_set_svc(msg_ctx, env, axis2_svc_ctx_get_svc(svc_ctx, env)); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_msg_info_headers( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_msg_info_headers_t * msg_info_headers) +{ + AXIS2_PARAM_CHECK(env->error, msg_info_headers, AXIS2_FAILURE); + + if(msg_info_headers) + { + if(msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy) + { + axis2_msg_info_headers_free(msg_ctx->msg_info_headers, env); + msg_ctx->msg_info_headers = NULL; + } + msg_ctx->msg_info_headers = msg_info_headers; + msg_ctx->msg_info_headers_deep_copy = AXIS2_FALSE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + axutil_param_t *param = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(msg_ctx->op) + { + param = axis2_op_get_param(msg_ctx->op, env, key); + if(param) + { + return param; + } + } + + if(msg_ctx->svc) + { + param = axis2_svc_get_param(msg_ctx->svc, env, key); + if(param) + { + return param; + } + } + + if(msg_ctx->svc_grp) + { + param = axis2_svc_grp_get_param(msg_ctx->svc_grp, env, key); + if(param) + { + return param; + } + } + + if(msg_ctx->conf_ctx) + { + axis2_conf_t *conf = axis2_conf_ctx_get_conf(msg_ctx->conf_ctx, env); + param = axis2_conf_get_param(conf, env, key); + } + + return param; +} + +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) +{ + axutil_property_t *property; + void *property_value = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + property = axis2_msg_ctx_get_property(msg_ctx, env, property_str); + + if(!property) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "%s not set in message context", property_str); + return NULL; + } + + property_value = axutil_property_get_value(property, env); + if(!property_value) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "%s properties not set in message context", + property_str); + return NULL; + } + + return property_value; +} + +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) +{ + void *obj = NULL; + axis2_ctx_t *ctx = NULL; + + /* Don't use AXIS2_PARAM_CHECK to verify msg_ctx, as it clobbers + env->error->status_code destroying the information therein that + an error has already occurred. */ + if(!msg_ctx) + { + if(axutil_error_get_status_code(env->error) == AXIS2_SUCCESS) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + } + return obj; + } + + /* search in message context */ + obj = axis2_ctx_get_property(msg_ctx->base, env, key); + if(obj) + { + return obj; + } + + if(msg_ctx->op_ctx) + { + ctx = axis2_op_ctx_get_base(msg_ctx->op_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + if(msg_ctx->svc_ctx) + { + ctx = axis2_svc_ctx_get_base(msg_ctx->svc_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + if(msg_ctx->svc_grp_ctx) + { + ctx = axis2_svc_grp_ctx_get_base(msg_ctx->svc_grp_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + if(msg_ctx->conf_ctx) + { + ctx = axis2_conf_ctx_get_base(msg_ctx->conf_ctx, env); + if(ctx) + { + obj = axis2_ctx_get_property(ctx, env, key); + if(obj) + { + return obj; + } + } + } + + return NULL; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_property( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * key, + axutil_property_t * value) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + return axis2_ctx_set_property(msg_ctx->base, env, key, value); +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->paused_handler_name; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->paused_phase_name; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_paused_phase_name( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_char_t * paused_phase_name) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + /* a shallow copy is sufficient as phase lives beyond message */ + msg_ctx->paused_phase_name = (axis2_char_t *)paused_phase_name; + return AXIS2_SUCCESS; +} + +axutil_string_t *AXIS2_CALL +axis2_msg_ctx_get_soap_action( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->soap_action; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_soap_action( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axutil_string_t * soap_action) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->soap_action) + { + axutil_string_free(msg_ctx->soap_action, env); + } + + if(soap_action) + { + msg_ctx->soap_action = axutil_string_clone(soap_action, env); + if(!(msg_ctx->soap_action)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_doing_mtom( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + + if(!(msg_ctx->doing_mtom) && msg_ctx->conf_ctx) + { + axis2_conf_t *conf = axis2_conf_ctx_get_conf(msg_ctx->conf_ctx, env); + msg_ctx->doing_mtom = axis2_conf_get_enable_mtom(conf, env); + } + + return msg_ctx->doing_mtom; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_doing_mtom( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t doing_mtom) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->doing_mtom = doing_mtom; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_doing_rest( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + /* Don't use AXIS2_PARAM_CHECK to verify msg_ctx, as it clobbers + env->error->status_code destroying the information therein that + an error has already occurred. */ + if(!msg_ctx) + { + if(axutil_error_get_status_code(env->error) == AXIS2_SUCCESS) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + } + return AXIS2_FALSE; + } + return msg_ctx->doing_rest; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_doing_rest( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t doing_rest) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->doing_rest = doing_rest; + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_do_rest_through_post( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t do_rest_through_post) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->do_rest_through_post = do_rest_through_post; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->do_rest_through_post; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_manage_session( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->manage_session; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_manage_session( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t manage_session) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->manage_session = manage_session; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_is_soap_11( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->is_soap_11; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_is_soap_11( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + const axis2_bool_t is_soap11) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->is_soap_11 = is_soap11; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_grp_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_grp_ctx( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + struct axis2_svc_grp_ctx * svc_grp_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(svc_grp_ctx) + { + msg_ctx->svc_grp_ctx = svc_grp_ctx; + } + + return AXIS2_SUCCESS; +} + +axis2_op_t *AXIS2_CALL +axis2_msg_ctx_get_op( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->op; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_op( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_op_t * op) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(op) + { + msg_ctx->op = op; + msg_ctx->op_qname = (axutil_qname_t *)axis2_op_get_qname(op, env); + } + + return AXIS2_SUCCESS; +} + +axis2_svc_t *AXIS2_CALL +axis2_msg_ctx_get_svc( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(svc) + { + axis2_svc_grp_t *svc_grp = NULL; + msg_ctx->svc = svc; + msg_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(svc, env); + + svc_grp = axis2_svc_get_parent(svc, env); + if(svc_grp) + { + msg_ctx->svc_grp = svc_grp; + msg_ctx->svc_grp_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); + } + } + + return AXIS2_SUCCESS; +} + +axis2_svc_grp_t *AXIS2_CALL +axis2_msg_ctx_get_svc_grp( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_grp; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_grp( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(svc_grp) + { + msg_ctx->svc_grp = svc_grp; + msg_ctx->svc_grp_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); + } + + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->svc_grp_ctx_id; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_svc_grp_ctx_id( + struct axis2_msg_ctx * msg_ctx, + const axutil_env_t * env, + axutil_string_t * svc_grp_ctx_id) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(msg_ctx->svc_grp_ctx_id) + { + axutil_string_free(msg_ctx->svc_grp_ctx_id, env); + msg_ctx->svc_grp_ctx_id = NULL; + } + + if(svc_grp_ctx_id) + { + msg_ctx->svc_grp_ctx_id = axutil_string_clone(svc_grp_ctx_id, env); + } + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_msg_ctx_is_paused( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->paused; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->find_svc = func; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->find_op = func; + return AXIS2_SUCCESS; +} + +axis2_options_t *AXIS2_CALL +axis2_msg_ctx_get_options( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axutil_hash_t *properties = NULL; + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + if(!msg_ctx->options) + { + msg_ctx->options = axis2_options_create(env); + + if(!msg_ctx->options) + { + return NULL; + } + } + + axis2_options_set_msg_info_headers(msg_ctx->options, env, msg_ctx->msg_info_headers); + properties = axis2_ctx_get_property_map(msg_ctx->base, env); + axis2_options_set_properties(msg_ctx->options, env, properties); + return msg_ctx->options; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_options( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_options_t * options) +{ + axutil_property_t *rest_val = NULL; + axis2_char_t *value; + axutil_string_t *soap_action = NULL; + ; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, options, AXIS2_FAILURE); + + if(msg_ctx->msg_info_headers && msg_ctx->msg_info_headers_deep_copy) + { + axis2_msg_info_headers_free(msg_ctx->msg_info_headers, env); + } + msg_ctx->msg_info_headers = axis2_options_get_msg_info_headers(options, env); + msg_ctx->msg_info_headers_deep_copy = AXIS2_FALSE; + + msg_ctx->doing_mtom = axis2_options_get_enable_mtom(options, env); + + msg_ctx->manage_session = axis2_options_get_manage_session(options, env); + + axis2_ctx_set_property_map(msg_ctx->base, env, axis2_options_get_properties(options, env)); + rest_val = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_ENABLE_REST); + if(rest_val) + { + value = (axis2_char_t *)axutil_property_get_value(rest_val, env); + if(value) + { + if(axutil_strcmp(value, AXIS2_VALUE_TRUE) == 0) + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + } + } + + if(msg_ctx->soap_action) + { + axutil_string_free(msg_ctx->soap_action, env); + } + + soap_action = axis2_options_get_soap_action(options, env); + if(soap_action) + { + msg_ctx->soap_action = axutil_string_clone(soap_action, env); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_msg_ctx_set_flow( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + int flow) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->flow = flow; + return AXIS2_SUCCESS; +} + +int AXIS2_CALL +axis2_msg_ctx_get_flow( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->flow; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->execution_chain = execution_chain; + msg_ctx->current_handler_index = -1; + msg_ctx->paused_handler_index = -1; + msg_ctx->current_phase_index = 0; + + return AXIS2_SUCCESS; +} + +axutil_array_list_t *AXIS2_CALL +axis2_msg_ctx_get_execution_chain( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->execution_chain; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->supported_rest_http_methods = supported_rest_http_methods; + + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->supported_rest_http_methods; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->current_handler_index = index; + if(msg_ctx->execution_chain) + { + axis2_handler_t *handler = (axis2_handler_t *)axutil_array_list_get( + msg_ctx->execution_chain, env, index); + if(handler) + { + msg_ctx->paused_handler_name = (axutil_string_t *)axis2_handler_get_name(handler, env); + } + } + return AXIS2_SUCCESS; +} + +int AXIS2_CALL +axis2_msg_ctx_get_current_handler_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->current_handler_index; +} + +int AXIS2_CALL +axis2_msg_ctx_get_paused_handler_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->paused_handler_index; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->current_phase_index = index; + return AXIS2_SUCCESS; + +} + +int AXIS2_CALL +axis2_msg_ctx_get_current_phase_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->current_phase_index; +} + +int AXIS2_CALL +axis2_msg_ctx_get_paused_phase_index( + const axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->paused_phase_index; +} + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_msg_ctx_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->find_svc(msg_ctx, env); +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_msg_ctx_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + return msg_ctx->find_op(msg_ctx, env, svc); +} + +AXIS2_EXTERN axutil_string_t *AXIS2_CALL +axis2_msg_ctx_get_charset_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx) + return msg_ctx->charset_encoding; + else + return NULL; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + if(msg_ctx->charset_encoding) + { + axutil_string_free(msg_ctx->charset_encoding, env); + msg_ctx->charset_encoding = NULL; + } + if(str) + { + msg_ctx->charset_encoding = axutil_string_clone(str, env); + } + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx) + { + return msg_ctx->transport_out_stream; + } + else + { + return NULL; + } +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + if(msg_ctx->transport_out_stream) + { + axutil_stream_free(msg_ctx->transport_out_stream, env); + } + + msg_ctx->transport_out_stream = stream; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + msg_ctx->transport_out_stream = NULL; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_out_transport_info_t *AXIS2_CALL +axis2_msg_ctx_get_out_transport_info( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + if(msg_ctx) + { + return msg_ctx->out_transport_info; + } + else + { + return NULL; + } +} + +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, + axis2_out_transport_info_t * out_transport_info) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + if(msg_ctx->out_transport_info) + { + AXIS2_OUT_TRANSPORT_INFO_FREE(msg_ctx->out_transport_info, env); + } + + msg_ctx->out_transport_info = out_transport_info; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + if(msg_ctx) + { + msg_ctx->out_transport_info = NULL; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_msg_ctx_get_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + { + return msg_ctx->transport_headers; + } + else + { + return NULL; + } +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_msg_ctx_extract_transport_headers( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axutil_hash_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->transport_headers; + msg_ctx->transport_headers = NULL; + return temp; + } + else + { + return NULL; + } +} + +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) +{ + if(msg_ctx) + { + if(msg_ctx->transport_headers) + { + axutil_hash_free(msg_ctx->transport_headers, env); + } + + msg_ctx->transport_headers = transport_headers; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(msg_ctx) + { + return msg_ctx->accept_record_list; + } + else + { + return NULL; + } +} + +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) +{ + axutil_array_list_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->accept_record_list; + msg_ctx->accept_record_list = NULL; + return temp; + } + else + { + return NULL; + } +} + +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) +{ + if(msg_ctx) + { + if(msg_ctx->accept_record_list && msg_ctx->accept_record_list != accept_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_record_list, env); + } + msg_ctx->accept_record_list = accept_record_list; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(msg_ctx) + { + return msg_ctx->accept_charset_record_list; + } + else + { + return NULL; + } +} + +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) +{ + axutil_array_list_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->accept_charset_record_list; + msg_ctx->accept_charset_record_list = NULL; + return temp; + } + else + { + return NULL; + } +} + +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) +{ + if(msg_ctx) + { + if(msg_ctx->accept_charset_record_list && msg_ctx->accept_charset_record_list + != accept_charset_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_charset_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_charset_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_charset_record_list, env); + } + msg_ctx->accept_charset_record_list = accept_charset_record_list; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(msg_ctx) + { + return msg_ctx->output_headers; + } + else + { + return NULL; + } +} + +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) +{ + if(msg_ctx) + { + axutil_array_list_t *temp = NULL; + temp = msg_ctx->output_headers; + msg_ctx->output_headers = NULL; + return temp; + } + else + { + return NULL; + } +} + +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) +{ + if(msg_ctx) + { + if(msg_ctx->output_headers && msg_ctx->output_headers != output_headers) + { + axis2_http_header_t *header = NULL; + while(axutil_array_list_size(msg_ctx->output_headers, env)) + { + header = (axis2_http_header_t *)axutil_array_list_remove(msg_ctx->output_headers, + env, 0); + if(header) + { + axis2_http_header_free(header, env); + } + } + axutil_array_list_free(msg_ctx->output_headers, env); + } + msg_ctx->output_headers = output_headers; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(msg_ctx) + { + return msg_ctx->accept_language_record_list; + } + else + { + return NULL; + } +} + +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) +{ + axutil_array_list_t *temp = NULL; + if(msg_ctx) + { + temp = msg_ctx->accept_language_record_list; + msg_ctx->accept_language_record_list = NULL; + return temp; + } + else + { + return NULL; + } +} + +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) +{ + if(msg_ctx) + { + if(msg_ctx->accept_language_record_list && msg_ctx->accept_language_record_list + != accept_language_record_list) + { + axis2_http_accept_record_t *rec = NULL; + while(axutil_array_list_size(msg_ctx->accept_language_record_list, env)) + { + rec = (axis2_http_accept_record_t *)axutil_array_list_remove( + msg_ctx->accept_language_record_list, env, 0); + if(rec) + { + axis2_http_accept_record_free(rec, env); + } + } + axutil_array_list_free(msg_ctx->accept_language_record_list, env); + } + msg_ctx->accept_language_record_list = accept_language_record_list; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_transfer_encoding( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + return msg_ctx->transfer_encoding; + else + return NULL; +} + +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) +{ + if(msg_ctx) + { + if(msg_ctx->transfer_encoding) + { + AXIS2_FREE(env->allocator, msg_ctx->transfer_encoding); + msg_ctx->transfer_encoding = NULL; + } + if(str) + { + msg_ctx->transfer_encoding = str; + } + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_content_language( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + return msg_ctx->content_language; + else + return NULL; +} + +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) +{ + if(msg_ctx) + { + if(msg_ctx->content_language) + { + AXIS2_FREE(env->allocator, msg_ctx->content_language); + msg_ctx->content_language = NULL; + } + if(str) + { + msg_ctx->content_language = str; + } + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_transport_url( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(msg_ctx) + return msg_ctx->transport_url; + else + return NULL; +} + +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) +{ + if(msg_ctx) + { + /* this is a shallow copy, no need to free */ + msg_ctx->transport_url = str; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_msg_ctx_get_status_code( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, 0); + return msg_ctx->status_code; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->status_code = status_code; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_auth_failed( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->is_auth_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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->is_auth_failure = status; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_msg_ctx_get_no_content( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->no_content; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->no_content = no_content; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + return msg_ctx->required_auth_is_http; +} + +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 status) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + msg_ctx->required_auth_is_http = status; + return AXIS2_SUCCESS; +} + +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) +{ + if(msg_ctx->auth_type) + { + AXIS2_FREE(env->allocator, msg_ctx->auth_type); + } + msg_ctx->auth_type = NULL; + if(auth_type) + { + msg_ctx->auth_type = axutil_strdup(env, auth_type); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_msg_ctx_get_auth_type( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + return msg_ctx->auth_type; +} + +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) +{ + return msg_ctx->mime_parts; +} + +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) +{ + if(msg_ctx->mime_parts) + { + axutil_array_list_free(mime_parts, env); + msg_ctx->mime_parts = NULL; + } + msg_ctx->mime_parts = mime_parts; +} diff --git a/src/core/context/op_ctx.c b/src/core/context/op_ctx.c new file mode 100644 index 0000000..30f0e3b --- /dev/null +++ b/src/core/context/op_ctx.c @@ -0,0 +1,420 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +struct axis2_op_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of operation context is a service context instance */ + struct axis2_svc_ctx *parent; + + /** message context map */ + axis2_msg_ctx_t *msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_MAX]; + + /** + * the operation of which this is a running instance. The MEP of this + * operation must be one of the 8 predefined ones in WSDL 2.0. + */ + axis2_op_t *op; + + /** operation Message Exchange Pattern (MEP) */ + int op_mep; + + /** is complete? */ + axis2_bool_t is_complete; + + /** the global message_id -> op_ctx map which is stored in + * the axis2_conf_ctx. We are caching it here for faster access. + */ + axutil_hash_t *op_ctx_map; + + /** op qname */ + axutil_qname_t *op_qname; + + /** service qname */ + axutil_qname_t *svc_qname; + /* mutex to synchronize the read/write operations */ + axutil_thread_mutex_t *mutex; + axis2_bool_t response_written; + axis2_bool_t is_in_use; + + int ref; +}; + +AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL +axis2_op_ctx_create( + const axutil_env_t * env, + axis2_op_t * op, + struct axis2_svc_ctx *svc_ctx) +{ + axis2_op_ctx_t *op_ctx = NULL; + int i = 0; + + op_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_op_ctx_t)); + if(!op_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + op_ctx->base = NULL; + op_ctx->parent = NULL; + op_ctx->op = NULL; + op_ctx->op_mep = 0; + op_ctx->is_complete = AXIS2_FALSE; + op_ctx->is_in_use = AXIS2_FALSE; + op_ctx->op_ctx_map = NULL; + op_ctx->op_qname = NULL; + op_ctx->svc_qname = NULL; + op_ctx->response_written = AXIS2_FALSE; + op_ctx->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); + + if(!op_ctx->mutex) + { + axis2_op_ctx_free(op_ctx, env); + return NULL; + } + + op_ctx->base = axis2_ctx_create(env); + if(!(op_ctx->base)) + { + axis2_op_ctx_free(op_ctx, env); + return NULL; + } + + if(op) + { + op_ctx->op = op; + } + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + op_ctx->msg_ctx_array[i] = NULL; + } + + if(op_ctx->op) + { + op_ctx->op_qname = (axutil_qname_t *)axis2_op_get_qname(op_ctx->op, env); + op_ctx->op_mep = axis2_op_get_axis_specific_mep_const(op_ctx->op, env); + } + + axis2_op_ctx_set_parent(op_ctx, env, svc_ctx); + op_ctx->ref = 1; + + return op_ctx; +} + +AXIS2_EXTERN axis2_ctx_t *AXIS2_CALL +axis2_op_ctx_get_base( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return op_ctx->base; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_op_ctx_free( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env) +{ + int i = 0; + if(--(op_ctx->ref) > 0) + { + return; + } + if(op_ctx->is_in_use) + { + return; + } + + if(op_ctx->base) + { + axis2_ctx_free(op_ctx->base, env); + } + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + if(op_ctx->msg_ctx_array[i]) + { + axis2_msg_ctx_free(op_ctx->msg_ctx_array[i], env); + op_ctx->msg_ctx_array[i] = NULL; + } + } + + if(op_ctx->mutex) + { + axutil_thread_mutex_destroy(op_ctx->mutex); + } + + AXIS2_FREE(env->allocator, op_ctx); + + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_op_ctx_destroy_mutex( + struct axis2_op_ctx *op_ctx, + const axutil_env_t * env) +{ + + if(op_ctx->mutex) + { + axutil_thread_mutex_destroy(op_ctx->mutex); + op_ctx->mutex = NULL; + } +} + +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) +{ + int i = 0; + + if(op_ctx->op_qname && op_ctx->svc_qname) + { + axis2_svc_t *svc = NULL; + axis2_char_t *svc_name = NULL; + + svc_name = axutil_qname_get_localpart(op_ctx->svc_qname, env); + + if(svc_name) + { + svc = axis2_conf_get_svc(conf, env, svc_name); + + if(svc) + { + op_ctx->op = axis2_svc_get_op_with_qname(svc, env, op_ctx->op_qname); + } + } + } + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + if(op_ctx->msg_ctx_array[i]) + { + axis2_msg_ctx_init(op_ctx->msg_ctx_array[i], env, conf); + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_op_ctx_get_op( + const axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + return op_ctx->op; +} + +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) +{ + return op_ctx->parent; +} + +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) +{ + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + + axutil_thread_mutex_lock(op_ctx->mutex); + + out_msg_ctx = op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_IN]; + + if(out_msg_ctx && in_msg_ctx) + { + axutil_thread_mutex_unlock(op_ctx->mutex); + return AXIS2_FAILURE; + } + + if(!out_msg_ctx) + { + op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx; + } + else + { + op_ctx->msg_ctx_array[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx; + } + + axutil_thread_mutex_unlock(op_ctx->mutex); + return AXIS2_SUCCESS; +} + +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) +{ + axutil_thread_mutex_lock(op_ctx->mutex); + if(op_ctx->msg_ctx_array) + { + axis2_msg_ctx_t *rv = NULL; + rv = op_ctx->msg_ctx_array[message_id]; + axutil_thread_mutex_unlock(op_ctx->mutex); + return rv; + } + axutil_thread_mutex_unlock(op_ctx->mutex); + return NULL; +} + +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) +{ + return op_ctx->is_complete; +} + +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) +{ + op_ctx->is_complete = is_complete; + return AXIS2_SUCCESS; +} + +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) +{ + return op_ctx->is_in_use; +} + +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) +{ + op_ctx->is_in_use = is_in_use; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_cleanup( + struct axis2_op_ctx * op_ctx, + const axutil_env_t * env) +{ + int i = 0; + + for(i = 0; i < AXIS2_WSDL_MESSAGE_LABEL_MAX; i++) + { + if(op_ctx->msg_ctx_array[i]) + { + axis2_msg_ctx_free(op_ctx->msg_ctx_array[i], env); + op_ctx->msg_ctx_array[i] = NULL; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + if(svc_ctx) + { + op_ctx->parent = svc_ctx; + } + + if(op_ctx->parent) /* that is if there is a service context associated */ + { + axis2_conf_ctx_t *conf_ctx = NULL; + conf_ctx = axis2_svc_ctx_get_conf_ctx(op_ctx->parent, env); + if(conf_ctx) + { + op_ctx->op_ctx_map = axis2_conf_ctx_get_op_ctx_map(conf_ctx, env); + } + op_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(axis2_svc_ctx_get_svc( + op_ctx->parent, env), env); + } + + return AXIS2_SUCCESS; +} + +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) +{ + return (axis2_msg_ctx_t **)(op_ctx->msg_ctx_array); +} + +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) +{ + if(op_ctx) + return op_ctx->response_written; + else + return AXIS2_FALSE; + +} + +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 written) +{ + if(op_ctx) + { + op_ctx->response_written = written; + } + else + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_ctx_increment_ref( + axis2_op_ctx_t * op_ctx, + const axutil_env_t * env) +{ + op_ctx->ref++; + return AXIS2_SUCCESS; +} + diff --git a/src/core/context/svc_ctx.c b/src/core/context/svc_ctx.c new file mode 100644 index 0000000..c9e19fe --- /dev/null +++ b/src/core/context/svc_ctx.c @@ -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. + */ + +#include +#include +#include +#include + +struct axis2_svc_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of op context is a service context instance */ + struct axis2_svc_grp_ctx *parent; + + /** service associated with this service context */ + axis2_svc_t *svc; + + /** id of the service associated with this context */ + axis2_char_t *svc_id; + + /** service qname */ + axutil_qname_t *svc_qname; +}; + +AXIS2_EXTERN axis2_svc_ctx_t *AXIS2_CALL +axis2_svc_ctx_create( + const axutil_env_t * env, + axis2_svc_t * svc, + struct axis2_svc_grp_ctx *svc_grp_ctx) +{ + axis2_svc_ctx_t *svc_ctx = NULL; + + svc_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_ctx_t)); + if(!svc_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svc_ctx->base = NULL; + svc_ctx->parent = NULL; + svc_ctx->svc = NULL; + svc_ctx->svc_id = NULL; + svc_ctx->svc_qname = NULL; + + svc_ctx->base = axis2_ctx_create(env); + if(!(svc_ctx->base)) + { + axis2_svc_ctx_free(svc_ctx, env); + return NULL; + } + + if(svc) + { + svc_ctx->svc = svc; + svc_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(svc, env); + if(svc_ctx->svc_qname) + { + svc_ctx->svc_id = axutil_qname_get_localpart(svc_ctx->svc_qname, env); + } + } + + if(svc_grp_ctx) + { + svc_ctx->parent = svc_grp_ctx; + } + + return svc_ctx; +} + +axis2_ctx_t *AXIS2_CALL +axis2_svc_ctx_get_base( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->base; +} + +struct axis2_svc_grp_ctx *AXIS2_CALL +axis2_svc_ctx_get_parent( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->parent; +} + +axis2_status_t AXIS2_CALL +axis2_svc_ctx_set_parent( + axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env, + axis2_svc_grp_ctx_t * parent) +{ + svc_ctx->parent = parent; + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_svc_ctx_free( + struct axis2_svc_ctx *svc_ctx, + const axutil_env_t * env) +{ + if(svc_ctx->base) + { + axis2_ctx_free(svc_ctx->base, env); + } + + AXIS2_FREE(env->allocator, svc_ctx); + return; +} + +axis2_status_t AXIS2_CALL +axis2_svc_ctx_init( + struct axis2_svc_ctx * svc_ctx, + const axutil_env_t * env, + axis2_conf_t * conf) +{ + if(svc_ctx->svc_qname) + { + axis2_char_t *svc_name = axutil_qname_get_localpart(svc_ctx->svc_qname, env); + svc_ctx->svc = axis2_conf_get_svc(conf, env, svc_name); + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_svc_ctx_get_svc_id( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->svc_id; +} + +axis2_svc_t *AXIS2_CALL +axis2_svc_ctx_get_svc( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return svc_ctx->svc; +} + +axis2_status_t AXIS2_CALL +axis2_svc_ctx_set_svc( + axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE); + + svc_ctx->svc = svc; + svc_ctx->svc_qname = (axutil_qname_t *)axis2_svc_get_qname(svc, env); + if(svc_ctx->svc_qname) + { + svc_ctx->svc_id = axutil_qname_get_localpart(svc_ctx->svc_qname, env); + } + return AXIS2_SUCCESS; +} + +struct axis2_conf_ctx *AXIS2_CALL +axis2_svc_ctx_get_conf_ctx( + const axis2_svc_ctx_t * svc_ctx, + const axutil_env_t * env) +{ + return axis2_svc_grp_ctx_get_parent(svc_ctx->parent, env); +} + +axis2_op_ctx_t *AXIS2_CALL +axis2_svc_ctx_create_op_ctx( + struct axis2_svc_ctx * svc_ctx, + const axutil_env_t * env, + const axutil_qname_t * qname) +{ + axis2_op_t *op = NULL; + + if(svc_ctx->svc) + { + op = axis2_svc_get_op_with_qname(svc_ctx->svc, env, qname); + return axis2_op_ctx_create(env, op, svc_ctx); + } + + return NULL; +} + diff --git a/src/core/context/svc_grp_ctx.c b/src/core/context/svc_grp_ctx.c new file mode 100644 index 0000000..449c01b --- /dev/null +++ b/src/core/context/svc_grp_ctx.c @@ -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. + */ + +#include +#include +#include +#include + +struct axis2_svc_grp_ctx +{ + + /** base context struct */ + axis2_ctx_t *base; + + /** parent of service group context is a configuration context instance */ + struct axis2_conf_ctx *parent; + + /** service group context ID */ + axis2_char_t *id; + + /** map of service contexts belonging to this service context group */ + axutil_hash_t *svc_ctx_map; + + /** service group associated with this service group context */ + axis2_svc_grp_t *svc_grp; + + /** name of the service group associated with this context */ + axis2_char_t *svc_grp_name; +}; + +AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL +axis2_svc_grp_ctx_create( + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp, + struct axis2_conf_ctx *conf_ctx) +{ + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + + svc_grp_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_grp_ctx_t)); + if(!svc_grp_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svc_grp_ctx->base = NULL; + svc_grp_ctx->parent = NULL; + svc_grp_ctx->id = NULL; + svc_grp_ctx->svc_ctx_map = NULL; + svc_grp_ctx->svc_grp = NULL; + svc_grp_ctx->svc_grp_name = NULL; + + svc_grp_ctx->base = axis2_ctx_create(env); + if(!(svc_grp_ctx->base)) + { + axis2_svc_grp_ctx_free(svc_grp_ctx, env); + return NULL; + } + + if(svc_grp) + { + svc_grp_ctx->svc_grp = svc_grp; + svc_grp_ctx->svc_grp_name = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp_ctx->svc_grp, + env); + svc_grp_ctx->id = axutil_strdup(env, svc_grp_ctx->svc_grp_name); + } + + if(conf_ctx) + { + svc_grp_ctx->parent = conf_ctx; + } + + svc_grp_ctx->svc_ctx_map = axutil_hash_make(env); + if(!(svc_grp_ctx->svc_ctx_map)) + { + axis2_svc_grp_ctx_free(svc_grp_ctx, env); + return NULL; + } + + axis2_svc_grp_ctx_fill_svc_ctx_map((svc_grp_ctx), env); + + return svc_grp_ctx; +} + +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) +{ + return svc_grp_ctx->base; +} + +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) +{ + return svc_grp_ctx->parent; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_grp_ctx_free( + struct axis2_svc_grp_ctx *svc_grp_ctx, + const axutil_env_t * env) +{ + if(svc_grp_ctx->id) + { + AXIS2_FREE(env->allocator, svc_grp_ctx->id); + } + + if(svc_grp_ctx->base) + { + axis2_ctx_free(svc_grp_ctx->base, env); + } + + if(svc_grp_ctx->svc_ctx_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(svc_grp_ctx->svc_ctx_map, env); hi; hi = axutil_hash_next(env, + hi)) + { + axutil_hash_this(hi, NULL, NULL, &val); + if(val) + { + axis2_svc_ctx_t *svc_ctx = NULL; + svc_ctx = (axis2_svc_ctx_t *)val; + axis2_svc_ctx_free(svc_ctx, env); + } + } + + axutil_hash_free(svc_grp_ctx->svc_ctx_map, env); + svc_grp_ctx->base = NULL; + } + + AXIS2_FREE(env->allocator, svc_grp_ctx); + + return; +} + +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, + axis2_conf_t * conf) +{ + if(svc_grp_ctx->svc_grp_name) + { + svc_grp_ctx->svc_grp = axis2_conf_get_svc_grp(conf, env, svc_grp_ctx->svc_grp_name); + } + + return AXIS2_SUCCESS; +} + +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) +{ + return svc_grp_ctx->id; +} + +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) +{ + if(svc_grp_ctx->id) + { + AXIS2_FREE(env->allocator, svc_grp_ctx->id); + svc_grp_ctx->id = NULL; + } + + if(id) + { + svc_grp_ctx->id = axutil_strdup(env, id); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_ctx_t *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) +{ + return (axis2_svc_ctx_t *)axutil_hash_get(svc_grp_ctx->svc_ctx_map, svc_name, + AXIS2_HASH_KEY_STRING); +} + +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) +{ + axutil_hash_index_t *hi = NULL; + void *next_svc = NULL; + + if(svc_grp_ctx->svc_grp) + { + axutil_hash_t *service_map = axis2_svc_grp_get_all_svcs(svc_grp_ctx->svc_grp, env); + if(service_map) + { + for(hi = axutil_hash_first(service_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &next_svc); + if(next_svc) + { + axis2_svc_t *svc = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_char_t *svc_name = NULL; + svc = (axis2_svc_t *)next_svc; + svc_ctx = axis2_svc_ctx_create(env, svc, svc_grp_ctx); + svc_name = axutil_qname_get_localpart(axis2_svc_get_qname(svc, env), env); + if(svc_name) + axutil_hash_set(svc_grp_ctx->svc_ctx_map, svc_name, AXIS2_HASH_KEY_STRING, + svc_ctx); + } + } + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL +axis2_svc_grp_ctx_get_svc_grp( + const axis2_svc_grp_ctx_t * svc_grp_ctx, + const axutil_env_t * env) +{ + return svc_grp_ctx->svc_grp; +} + +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) +{ + return svc_grp_ctx->svc_ctx_map; +} + diff --git a/src/core/deployment/Makefile.am b/src/core/deployment/Makefile.am new file mode 100644 index 0000000..7099839 --- /dev/null +++ b/src/core/deployment/Makefile.am @@ -0,0 +1,38 @@ +noinst_LTLIBRARIES = libaxis2_deployment.la + +noinst_HEADERS = axis2_deployment.h \ + axis2_arch_file_data.h \ + axis2_arch_reader.h \ + axis2_conf_builder.h \ + axis2_dep_engine.h \ + axis2_desc_builder.h \ + axis2_module_builder.h \ + axis2_repos_listener.h \ + axis2_svc_builder.h \ + axis2_svc_grp_builder.h \ + axis2_ws_info.h \ + axis2_ws_info_list.h + +libaxis2_deployment_la_SOURCES =phases_info.c \ + desc_builder.c \ + arch_reader.c \ + dep_engine.c \ + arch_file_data.c \ + ws_info.c \ + ws_info_list.c \ + svc_builder.c \ + svc_grp_builder.c \ + module_builder.c \ + conf_builder.c \ + repos_listener.c \ + conf_init.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/src/core/util \ + -I$(top_builddir)/axiom/include \ + -I$(top_builddir)/neethi/include \ + -I$(top_builddir)/util/include diff --git a/src/core/deployment/arch_file_data.c b/src/core/deployment/arch_file_data.c new file mode 100644 index 0000000..b785399 --- /dev/null +++ b/src/core/deployment/arch_file_data.c @@ -0,0 +1,369 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_arch_file_data +{ + axutil_file_t *file; + int type; + axis2_char_t *msg_recv; + axis2_char_t *module_name; + axis2_char_t *module_dll_name; + axis2_char_t *name; + /* + * To store services in a service group. Those services are temporarily + * stored in this table + */ + axutil_hash_t *svc_map; + axutil_array_list_t *deployable_svcs; + +}; + +AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL +axis2_arch_file_data_create( + const axutil_env_t * env) +{ + axis2_arch_file_data_t *arch_file_data = NULL; + arch_file_data = (axis2_arch_file_data_t *)AXIS2_MALLOC(env-> allocator, + sizeof(axis2_arch_file_data_t)); + + if(!arch_file_data) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)arch_file_data, 0, sizeof(axis2_arch_file_data_t)); + + arch_file_data->deployable_svcs = axutil_array_list_create(env, 0); + if(!arch_file_data->deployable_svcs) + { + axis2_arch_file_data_free(arch_file_data, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return arch_file_data; +} + +AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL +axis2_arch_file_data_create_with_type_and_file( + const axutil_env_t * env, + int type, + axutil_file_t * file) +{ + axis2_arch_file_data_t *arch_file_data = NULL; + arch_file_data = (axis2_arch_file_data_t *)axis2_arch_file_data_create(env); + if(!arch_file_data) + { + axis2_char_t *file_name = axutil_file_get_name(file, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create arch_file_data for file %s", + file_name); + return NULL; + } + + arch_file_data->type = type; + arch_file_data->file = axutil_file_clone(file, env); + return arch_file_data; +} + +AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL +axis2_arch_file_data_create_with_type_and_name( + const axutil_env_t * env, + int type, + const axis2_char_t * name) +{ + axis2_arch_file_data_t *arch_file_data = NULL; + arch_file_data = (axis2_arch_file_data_t *)axis2_arch_file_data_create(env); + if(!arch_file_data) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create arch_file_data for %s", name); + return NULL; + } + arch_file_data->type = type; + arch_file_data->name = axutil_strdup(env, name); + return arch_file_data; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_arch_file_data_free( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + if(arch_file_data->file) + { + axutil_file_free(arch_file_data->file, env); + } + if(arch_file_data->msg_recv) + { + AXIS2_FREE(env->allocator, arch_file_data->msg_recv); + } + if(arch_file_data->module_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_name); + } + if(arch_file_data->module_dll_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_dll_name); + } + if(arch_file_data->name) + { + AXIS2_FREE(env->allocator, arch_file_data->name); + } + + if(arch_file_data->svc_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + for(hi = axutil_hash_first(arch_file_data->svc_map, env); hi; hi + = axutil_hash_next(env, hi)) + { + axis2_svc_t *svc = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + svc = (axis2_svc_t *)val; + if(svc) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name :%s", axis2_svc_get_name(svc, + env)); + axis2_svc_free(svc, env); + } + } + axutil_hash_free(arch_file_data->svc_map, env); + } + if(arch_file_data->deployable_svcs) + { + axutil_array_list_free(arch_file_data->deployable_svcs, env); + } + + if(arch_file_data) + { + AXIS2_FREE(env->allocator, arch_file_data); + } + + return; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_msg_recv( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->msg_recv; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_msg_recv( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * msg_recv) +{ + AXIS2_PARAM_CHECK(env->error, msg_recv, AXIS2_FAILURE); + + if(arch_file_data->msg_recv) + { + AXIS2_FREE(env->allocator, arch_file_data->msg_recv); + arch_file_data->msg_recv = NULL; + } + arch_file_data->msg_recv = axutil_strdup(env, msg_recv); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return axutil_file_get_name(arch_file_data->file, env); +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_svc_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + axis2_char_t *svc_name = NULL; + + if(arch_file_data->file) + { + svc_name = axutil_file_get_name(arch_file_data->file, env); + } + else + { + svc_name = arch_file_data->name; + } + + return svc_name; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_arch_file_data_get_type( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->type; +} + +AXIS2_EXTERN axutil_file_t *AXIS2_CALL +axis2_arch_file_data_get_file( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->file; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_module_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + axis2_char_t *module_name = NULL; + + if(arch_file_data->file) + { + module_name = axutil_file_get_name(arch_file_data->file, env); + } + else + { + module_name = arch_file_data->module_name; + } + return module_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_module_name( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * module_name) +{ + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + + if(arch_file_data->module_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_name); + arch_file_data->module_name = NULL; + } + arch_file_data->module_name = axutil_strdup(env, module_name); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_module_dll_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->module_dll_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_module_dll_name( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * module_dll_name) +{ + AXIS2_PARAM_CHECK(env->error, module_dll_name, AXIS2_FAILURE); + + if(arch_file_data->module_dll_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_dll_name); + arch_file_data->module_dll_name = NULL; + } + arch_file_data->module_dll_name = axutil_strdup(env, module_dll_name); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_add_svc( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_svc_t * svc_desc) +{ + const axutil_qname_t *svc_qname = NULL; + axis2_char_t *svc_name = NULL; + AXIS2_PARAM_CHECK(env->error, svc_desc, AXIS2_FAILURE); + + svc_qname = axis2_svc_get_qname(svc_desc, env); + svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env); + if(!arch_file_data->svc_map) + { + arch_file_data->svc_map = axutil_hash_make(env); + if(!arch_file_data->svc_map) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + axutil_hash_set(arch_file_data->svc_map, svc_name, AXIS2_HASH_KEY_STRING, svc_desc); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN struct axis2_svc *AXIS2_CALL +axis2_arch_file_data_get_svc( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * svc_name) +{ + axis2_svc_t *svc = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_name, NULL); + + if(arch_file_data->svc_map) + { + svc = (axis2_svc_t *)axutil_hash_get(arch_file_data->svc_map, svc_name, + AXIS2_HASH_KEY_STRING); + } + else + { + return NULL; + } + return svc; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_arch_file_data_get_svc_map( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->svc_map; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_arch_file_data_get_deployable_svcs( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->deployable_svcs; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_deployable_svcs( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axutil_array_list_t * deployable_svcs) +{ + AXIS2_PARAM_CHECK(env->error, deployable_svcs, AXIS2_FAILURE); + if(arch_file_data->deployable_svcs) + { + AXIS2_FREE(env->allocator, arch_file_data->deployable_svcs); + arch_file_data->deployable_svcs = NULL; + } + arch_file_data->deployable_svcs = deployable_svcs; + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/arch_reader.c b/src/core/deployment/arch_reader.c new file mode 100644 index 0000000..3403d8e --- /dev/null +++ b/src/core/deployment/arch_reader.c @@ -0,0 +1,313 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +struct axis2_arch_reader +{ + axis2_desc_builder_t *desc_builder; +}; + +AXIS2_EXTERN axis2_arch_reader_t *AXIS2_CALL +axis2_arch_reader_create( + const axutil_env_t * env) +{ + axis2_arch_reader_t *arch_reader = NULL; + + arch_reader = (axis2_arch_reader_t *)AXIS2_MALLOC(env-> allocator, sizeof(axis2_arch_reader_t)); + + if(!arch_reader) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + arch_reader->desc_builder = NULL; + + return arch_reader; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_arch_reader_free( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env) +{ + /* Description builder is owned by dep_engine, so do not free it here */ + + if(arch_reader) + { + AXIS2_FREE(env->allocator, arch_reader); + } + + return; +} + +AXIS2_EXTERN struct axis2_svc *AXIS2_CALL +axis2_arch_reader_create_svc( + const axutil_env_t * env, + struct axis2_arch_file_data *file) +{ + axis2_svc_t *svc = NULL; + svc = axis2_svc_create(env); + return svc; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_reader_process_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine * dep_engine, + axis2_svc_grp_t * svc_grp) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *svc_grp_xml = NULL; + axis2_char_t *repos_path = NULL; + axis2_bool_t file_flag = AXIS2_FALSE; + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + file_flag = axis2_dep_engine_get_file_flag(dep_engine, env); + + if(!file_flag) + { + + repos_path = axis2_dep_engine_get_repos_path(dep_engine, env); + + svc_grp_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, AXIS2_SERVICE_FOLDER, + AXIS2_PATH_SEP_STR, file_name, AXIS2_PATH_SEP_STR, AXIS2_SVC_XML, NULL); + } + else + { + repos_path = axis2_dep_engine_get_svc_dir(dep_engine, env); + svc_grp_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, file_name, + AXIS2_PATH_SEP_STR, AXIS2_SVC_XML, NULL); + } + + if(!svc_grp_xml) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service xml file not found for %s", file_name); + return AXIS2_FAILURE; + } + status = axutil_file_handler_access(svc_grp_xml, AXIS2_F_OK); + if(AXIS2_SUCCESS == status) + { + struct axis2_arch_file_data *arch_file_data = NULL; + axis2_char_t *svc_name = NULL; + + status + = axis2_arch_reader_build_svc_grp(arch_reader, env, svc_grp_xml, dep_engine, svc_grp); + if(AXIS2_SUCCESS != status) + { + return status; + } + arch_file_data = axis2_dep_engine_get_current_file_item(dep_engine, env); + svc_name = axis2_arch_file_data_get_svc_name(arch_file_data, env); + axis2_svc_grp_set_name(svc_grp, env, svc_name); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SERVICE_XML_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Access to service configuration file %s failed", + file_name); + status = AXIS2_FAILURE; + } + AXIS2_FREE(env->allocator, svc_grp_xml); + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_reader_build_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * svc_xml, + axis2_dep_engine_t * dep_engine, + axis2_svc_grp_t * svc_grp) +{ + axis2_char_t *root_element_name = NULL; + axiom_node_t *svc_grp_node = NULL; + axiom_element_t *svc_grp_element = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, svc_xml, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + arch_reader->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, svc_xml, + dep_engine); + if(!arch_reader->desc_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating description builder for service file %s failed", svc_xml); + return AXIS2_FAILURE; + } + axis2_dep_engine_add_desc_builder(dep_engine, env, arch_reader->desc_builder); + + svc_grp_node = axis2_desc_builder_build_om(arch_reader->desc_builder, env); + + if(svc_grp_node) + { + svc_grp_element = axiom_node_get_data_element(svc_grp_node, env); + if(svc_grp_element) + { + root_element_name = axiom_element_get_localname(svc_grp_element, env); + } + } + + if(root_element_name && 0 == axutil_strcmp(AXIS2_SVC_ELEMENT, root_element_name)) + { + /* If service group is actually a service. In this case service group + * contain only single service */ + axis2_svc_t *svc = NULL; + axis2_svc_builder_t *svc_builder = NULL; + axis2_arch_file_data_t *file_data = NULL; + axutil_array_list_t *dep_svcs = NULL; + axis2_char_t *svc_name = NULL; + + file_data = axis2_dep_engine_get_current_file_item(dep_engine, env); + svc_name = axis2_arch_file_data_get_name(file_data, env); + svc = axis2_arch_file_data_get_svc(file_data, env, svc_name); + if(!svc) + { + axutil_qname_t *svc_qname = NULL; + + svc_qname = axutil_qname_create(env, svc_name, NULL, NULL); + svc = axis2_svc_create_with_qname(env, svc_qname); + status = axis2_arch_file_data_add_svc(file_data, env, svc); + axutil_qname_free(svc_qname, env); + if(AXIS2_SUCCESS != status) + { + axis2_svc_free(svc, env); + return status; + } + } + axis2_svc_set_parent(svc, env, svc_grp); + + svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env, dep_engine, svc); + status = axis2_svc_builder_populate_svc(svc_builder, env, svc_grp_node); + axis2_dep_engine_add_svc_builder(dep_engine, env, svc_builder); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Populating service failed for %s", svc_name); + return AXIS2_FAILURE; + } + + dep_svcs = axis2_arch_file_data_get_deployable_svcs(file_data, env); + if(!dep_svcs) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Deployable services list is NULL within arch file data"); + return AXIS2_FAILURE; + } + status = axutil_array_list_add(dep_svcs, env, svc); + if(AXIS2_SUCCESS != status) + { + return AXIS2_FAILURE; + } + + } + else if(root_element_name && 0 == axutil_strcmp(AXIS2_SVC_GRP_ELEMENT, root_element_name)) + { + axis2_svc_grp_builder_t *grp_builder = NULL; + grp_builder = axis2_svc_grp_builder_create_with_svc_and_dep_engine(env, svc_grp_node, + dep_engine); + status = axis2_svc_grp_builder_populate_svc_grp(grp_builder, env, svc_grp); + axis2_dep_engine_add_svc_grp_builder(dep_engine, env, grp_builder); + } + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_reader_read_module_arch( + const axutil_env_t * env, + axis2_char_t * file_name, + axis2_dep_engine_t * dep_engine, + axis2_module_desc_t * module_desc) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *module_xml = NULL; + axis2_char_t *repos_path = NULL; + axis2_bool_t file_flag; + + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + + file_flag = axis2_dep_engine_get_file_flag(dep_engine, env); + if(!file_flag) + { + repos_path = axis2_dep_engine_get_repos_path(dep_engine, env); + module_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, AXIS2_MODULE_FOLDER, + AXIS2_PATH_SEP_STR, file_name, AXIS2_PATH_SEP_STR, AXIS2_MODULE_XML, NULL); + } + else + { + repos_path = axis2_dep_engine_get_module_dir(dep_engine, env); + module_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, file_name, + AXIS2_PATH_SEP_STR, AXIS2_MODULE_XML, NULL); + } + + if(!module_xml) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + status = axutil_file_handler_access(module_xml, AXIS2_F_OK); + + if(AXIS2_SUCCESS == status) + { + axis2_module_builder_t *module_builder = NULL; + module_builder = axis2_module_builder_create_with_file_and_dep_engine_and_module(env, + module_xml, dep_engine, module_desc); + status = axis2_module_builder_populate_module(module_builder, env); + axis2_dep_engine_add_module_builder(dep_engine, env, module_builder); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_XML_NOT_FOUND_FOR_THE_MODULE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module configuration file access failed for module file %s", module_xml); + status = AXIS2_FAILURE; + } + AXIS2_FREE(env->allocator, module_xml); + return status; +} + +AXIS2_EXTERN axutil_file_t *AXIS2_CALL +axis2_arch_reader_create_module_arch( + const axutil_env_t * env, + axis2_char_t * module_name) +{ + axutil_file_t *file = NULL; + + file = axutil_file_create(env); + if(!file) + { + return NULL; + } + axutil_file_set_name(file, env, module_name); + return file; +} + diff --git a/src/core/deployment/axis2_arch_file_data.h b/src/core/deployment/axis2_arch_file_data.h new file mode 100644 index 0000000..d27d065 --- /dev/null +++ b/src/core/deployment/axis2_arch_file_data.h @@ -0,0 +1,265 @@ + +/* + * 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_ARCH_FILE_DATA_H +#define AXIS2_ARCH_FILE_DATA_H + +/** @defgroup axis2_arch_file_data Arch File Data + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_arch_file_data.h + * @brief Axis2 Arch File Data interface. arch_file_data construct contain + * deployment information retrieved from a module or service configuration file. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf; + + /** Type name for struct axis2_arch_fila_data */ + typedef struct axis2_arch_file_data axis2_arch_file_data_t; + + /** + * De-allocate memory + * @param arch_file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_arch_file_data_free( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_arch_file_data_get_msg_recv( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @param msg_recv pointer to message receiver + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_file_data_set_msg_recv( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * msg_recv); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return the name of the contained file. + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_arch_file_data_get_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return the service name. If contained file is not null this is the + * file name. else this is the name property + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_arch_file_data_get_svc_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_arch_file_data_get_type( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_file_t *AXIS2_CALL + axis2_arch_file_data_get_file( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_arch_file_data_get_module_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @param module_name pointer to module_name + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_file_data_set_module_name( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * module_name); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_arch_file_data_get_module_dll_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_file_data_set_module_dll_name( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * module_dll_name); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_file_data_add_svc( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + struct axis2_svc *svc_desc); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_arch_file_data_get_svc( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * svc_name); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_arch_file_data_get_svc_map( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_arch_file_data_get_deployable_svcs( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @param deployable_svcs pointer to deployable services + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_file_data_set_deployable_svcs( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axutil_array_list_t * deployable_svcs); + + /** + * Creates arch file data struct + * @param env pointer to environment struct + * @return pointer to newly created arch file data + */ + AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL + + axis2_arch_file_data_create( + const axutil_env_t * env); + + /** + * Creates arch file data struct + * @param env pointer to environment struct + * @param type type + * @param file folder name of service or module + * @return pointer to newly created arch file data + */ + AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL + + axis2_arch_file_data_create_with_type_and_file( + const axutil_env_t * env, + int type, + axutil_file_t * file); + + /** + * Creates arch file data struct + * @param env pointer to environment struct + * @param type type + * @param name pointer to name + * @return pointer to newly created arch file data + */ + AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL + + axis2_arch_file_data_create_with_type_and_name( + const axutil_env_t * env, + int type, + const axis2_char_t * name); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_ARCH_FILE_DATA_H */ diff --git a/src/core/deployment/axis2_arch_reader.h b/src/core/deployment/axis2_arch_reader.h new file mode 100644 index 0000000..274ded2 --- /dev/null +++ b/src/core/deployment/axis2_arch_reader.h @@ -0,0 +1,152 @@ + +/* + * 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_ARCH_READER_H +#define AXIS2_ARCH_READER_H + +/** @defgroup axis2_arch_reader Arch Reader + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf; + struct axis2_arch_file_data; + struct axis2_dep_engine; + + /** Type name for struct axis2_arch_reader */ + typedef struct axis2_arch_reader axis2_arch_reader_t; + + /** + * De-allocate memory + * @param arch_reader pointer to arch reader + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_arch_reader_free( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env); + + /** + * To create a service descrption axis2_svc_t using given + * deployment info file. + * @param env pointer to environment struct + * @param file pointer to file + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_arch_reader_create_svc( + const axutil_env_t * env, + struct axis2_arch_file_data *file); + + /** + * Construct the path to the service group configuration file(services.xml) + * using the passed file name and populate the passed service group + * description. + * @param arch_reader pointer to arch reader + * @param env pointer to environment struct + * @param file_name pointer to service group configuration file. + * @param dep_engine pointer to deployment engine + * @param svc_grp pointer to service group to be populated. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_reader_process_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *dep_engine, + axis2_svc_grp_t * svc_grp); + + /** + * Populate the passed service group description using the service group + * configuration file(services.xml). + * @param arch_reader pointer to arch reader + * @param env pointer to environment struct + * @param file_path path to the service group configuration file(services.xml) + * @param dep_engine pointer to deployment engine + * @param svc_grp pointer to service group + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_reader_build_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * file_path, + struct axis2_dep_engine *dep_engine, + struct axis2_svc_grp *svc_grp); + + /** + * Construct the path to the module configuration file(module.xml) + * using the passed file name and populate the passed module description. + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_reader_read_module_arch( + const axutil_env_t * env, + axis2_char_t * file_path, + struct axis2_dep_engine *dep_engine, + axis2_module_desc_t * module); + + /** + * Create an axis2 file using the passed module name. + * @param env pointer to environment struct + * @param module_name pointer to module name + */ + AXIS2_EXTERN axutil_file_t *AXIS2_CALL + + axis2_arch_reader_create_module_arch( + const axutil_env_t * env, + axis2_char_t * module_name); + + /** + * Creates arch reader struct + * @param env pointer to environment struct + * @return pointer to newly created arch reader + */ + AXIS2_EXTERN axis2_arch_reader_t *AXIS2_CALL + axis2_arch_reader_create( + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_ARCH_READER_H */ diff --git a/src/core/deployment/axis2_conf_builder.h b/src/core/deployment/axis2_conf_builder.h new file mode 100644 index 0000000..9a0aa91 --- /dev/null +++ b/src/core/deployment/axis2_conf_builder.h @@ -0,0 +1,116 @@ + +/* + * 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_BUILDER_H +#define AXIS2_CONF_BUILDER_H + +/** + * @defgroup axis2_conf_builder Conf Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include "axis2_desc_builder.h" +#include +#include "axis2_dep_engine.h" +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_desc_builder; + struct axis2_dep_engine; + + /** Type name for struct axis2_conf_builder */ + typedef struct axis2_conf_builder axis2_conf_builder_t; + + /** + * De-allocate memory + * @param conf_builder pointer to configuration builder + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_conf_builder_free( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env); + + /** + * @param conf_builder pointer to configuration builder + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_builder_populate_conf( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env); + + /** + * To get the list og modules that is requird to be engage globally + * @param conf_builder pointer to configuration builder + * @param env pointer to environment struct + * @param module_refs pointer to module refs + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_conf_builder_process_module_refs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs); + + /** + * Creates conf builder struct + * @param env pointer to environment struct + * @return pointer to newly created conf builder + */ + AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL + axis2_conf_builder_create( + const axutil_env_t * env); + + /** + * Creates conf builder struct + * @param env pointer to environment struct + * @param file This is the full path to the server xml file + * @param dep_engine pointer to dep engine + * @param conf pointer to conf + * @return pointer to newly created conf builder + */ + + AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL + + axis2_conf_builder_create_with_file_and_dep_engine_and_conf( + const axutil_env_t * env, + axis2_char_t * file, + struct axis2_dep_engine *dep_engine, + axis2_conf_t * conf); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_CONF_BUILDER_H */ diff --git a/src/core/deployment/axis2_dep_engine.h b/src/core/deployment/axis2_dep_engine.h new file mode 100644 index 0000000..a9130af --- /dev/null +++ b/src/core/deployment/axis2_dep_engine.h @@ -0,0 +1,418 @@ + +/* + * 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_DEP_ENGINE_H +#define AXIS2_DEP_ENGINE_H + +/** + * @defgroup axis2_dep_engine Deployment Engine + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_dep_engine.h + * @brief Axis2 Deployment Engine interface + */ + +#include +#include +#include +#include +#include +#include "axis2_arch_file_data.h" +#include "axis2_ws_info.h" +#include "axis2_conf_builder.h" +#include "axis2_repos_listener.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + struct axis2_arch_file_data; + struct axis2_arch_reader; + struct axis2_ws_info; + struct axis2_phases_info; + struct axis2_svc; + + /** Type name for struct axis2_dep_engine */ + typedef struct axis2_dep_engine axis2_dep_engine_t; + struct axis2_desc_builder; + struct axis2_module_builder; + struct axis2_svc_builder; + struct axis2_grp_builder; + struct axis2_svc_grp_builder; + + /** + * De-allocate memory + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_dep_engine_free( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * while parsing the axis2.xml the module refferences have to be stored some + * where , since at that time none of module availble (they load after parsing + * the document) + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param module_qname QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_qname); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param module_name pointer to module name + */ + AXIS2_EXTERN struct axis2_module_desc *AXIS2_CALL + + axis2_dep_engine_get_module( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_name); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_arch_file_data *AXIS2_CALL + + axis2_dep_engine_get_current_file_item( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param file pointer to file + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_ws_to_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_arch_file_data *file); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param file pointer to file + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_dep_engine_add_ws_to_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_ws_info *file); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_phases_info *AXIS2_CALL + axis2_dep_engine_get_phases_info( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return AxisConfiguration AxisConfiguration + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_dep_engine_get_axis_conf( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_dep_engine_load( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_dep_engine_load_client( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param dll_name pointer to dll_name + */ + AXIS2_EXTERN void *AXIS2_CALL + axis2_dep_engine_get_handler_dll( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * dll_name); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_do_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_dep_engine_is_hot_update( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param phases_info pointer to phases info + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_phases_info( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_phases_info *phases_info); + + /** + * This method is used to fill a axisservice object using services.xml , first it should create + * an axisservice object using WSDL and then fill that using given servic.xml and load all the requed + * class and build the chains , finally add the servicecontext to EngineContext and axisservice into + * EngineConfiguration + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param svc pointer to service + * @param file_name pointer to file name + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_dep_engine_build_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_svc *svc, + axis2_char_t * file_name); + + /** + * This method can be used to build ModuleDescription for a given module archiev file + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param module_archive pointer to module archive + * @param conf pointer to conf + */ + AXIS2_EXTERN struct axis2_module_desc *AXIS2_CALL + axis2_dep_engine_build_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_file_t * module_archive, + struct axis2_conf *conf); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_dep_engine_get_repos_path( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to module directory + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_dep_engine_get_file_flag( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + + /** + * @param dep_engine pointer to module directory + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_dep_engine_get_module_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to module directory + * @param env pointer to environment struct + * @param module_dir pointer of the directory path + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_module_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *module_dir); + + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_dep_engine_get_svc_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_svc_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *svc_dir); + + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param file_data pointer to file data + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_current_file_item( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_arch_file_data *file_data); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param arch_reader pointer to arch reader + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_arch_reader( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_arch_reader *arch_reader); + + /** + * No param constructor is need to deploye module and service programatically + * @param env pointer to environment struct + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create( + const axutil_env_t * env); + + /** + * Creates description builder struct + * This the constructor which is used by Engine in order to start + * Deployment module, + * @param env pointer to environment struct + * @param repos_path is the path to which Repositary Listner should listen. + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create_with_repos_name( + const axutil_env_t * env, + const axis2_char_t * repos_path); + + + /** + * Creates description builder struct using axis2 xml + * This the constructor which is used by Engine in order to start + * Deployment module, + * @param env pointer to environment struct + * @param axis2_xml is the path of the axis2.xml . + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create_with_axis2_xml( + const axutil_env_t * env, + const axis2_char_t * axis2_xml); + + + /** + * Creates deployment engine struct + * @param env pointer to environment struct + * @param repos_path is the path to which Repositary Listner should listen. + * @param svr_xml_file pointer to service xml file + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + + axis2_dep_engine_create_with_repos_name_and_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * repos_path, + const axis2_char_t * svr_xml_file); + + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create_with_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * svr_xml_file); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_desc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_desc_builder *desc_builder); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_module_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_module_builder *module_builder); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_svc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_svc_builder *svc_builder); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_dep_engine_add_svc_grp_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_svc_grp_builder *svc_grp_builder); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_DEP_ENGINE_H */ diff --git a/src/core/deployment/axis2_deployment.h b/src/core/deployment/axis2_deployment.h new file mode 100644 index 0000000..044f10f --- /dev/null +++ b/src/core/deployment/axis2_deployment.h @@ -0,0 +1,119 @@ + +/* + * 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_DEPLOYMENT_H +#define AXIS2_DEPLOYMENT_H + +/** + * @file axis2_axis2_deployment.h + * @brief axis2 deployment + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/*********************************** Constansts********************************/ + +/** + * DeployCons interface is to keep constent value required for Deployemnt + */ + +#define AXIS2_SVC 0 /* if it is a service */ +#define AXIS2_MODULE 1 /* if it is a module */ + +#define AXIS2_SVC_XML "services.xml" +#define AXIS2_MODULE_XML "module.xml" +#define AXIS2_PARAMETERST "parameter" /* paramater start tag */ +#define AXIS2_HANDLERST "handler" +#define AXIS2_MODULEST "module" +#define AXIS2_PHASEST "phase" +#define AXIS2_PHASE_ORDER "phaseOrder" +#define AXIS2_OPERATIONST "operation" /* operation start tag */ +#define AXIS2_IN_FLOW_START "inflow" /* inflow start tag */ +#define AXIS2_OUT_FLOW_START "outflow" /* outflowr start tag */ +#define AXIS2_IN_FAILTFLOW "INfaultflow" /* faultflow start tag */ +#define AXIS2_OUT_FAILTFLOW "Outfaultflow" /* faultflow start tag */ + +#define AXIS2_MODULE_PATH "modules" +#define AXIS2_SVC_PATH "services" + +/* for parameters */ +#define AXIS2_ATTNAME "name" +#define AXIS2_ATTLOCKED "locked" +#define AXIS2_TYPE "type" + +/* for operations */ +#define AXIS2_MEP "mep" + +/* for messages */ +#define AXIS2_MESSAGE "message" +#define AXIS2_LABEL "label" + +/* for handlers */ +#define AXIS2_REF "ref" +#define AXIS2_CLASSNAME "class" +#define AXIS2_BEFORE "before" +#define AXIS2_AFTER "after" +#define AXIS2_PHASE "phase" +#define AXIS2_PHASEFIRST "phaseFirst" +#define AXIS2_PHASELAST "phaseLast" +#define AXIS2_ORDER "order" /* to resolve the order tag */ +#define AXIS2_DESCRIPTION "description" + +#define AXIS2_TRANSPORTSENDER "transportSender" +#define AXIS2_TRANSPORTRECEIVER "transportReceiver" + +#define AXIS2_MESSAGERECEIVER "messageReceiver" + +#define AXIS2_HOTDEPLOYMENT "hotdeployment" +#define AXIS2_HOTUPDATE "hotupdate" +#define AXIS2_DISPATCH_ORDER "dispatchOrder" +#define AXIS2_DISPATCHER "dispatcher" + +/* element in a services.xml */ +#define AXIS2_SVC_ELEMENT "service" +#define AXIS2_SVC_WSDL_PATH "wsdl_path" +#define AXIS2_SVC_GRP_ELEMENT "serviceGroup" + +#define AXIS2_SERVER_XML_FILE "axis2.xml" + +#define AXIS2_MODULE_FOLDER "modules" +#define AXIS2_SERVICE_FOLDER "services" +#define AXIS2_LIB_FOLDER "lib" +#define AXIS2_LIB_DIR "libDir" + +#define AXIS2_ATTRIBUTE_DEFAULT_VERSION "version" +#define AXIS2_DEFAULT_MODULE_VERSION "defaultModuleVersions" + +/*********************************** Constants*********************************/ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_DEPLOYMENT_H */ diff --git a/src/core/deployment/axis2_desc_builder.h b/src/core/deployment/axis2_desc_builder.h new file mode 100644 index 0000000..347f592 --- /dev/null +++ b/src/core/deployment/axis2_desc_builder.h @@ -0,0 +1,292 @@ + +/* + * 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_BUILDER_H +#define AXIS2_DESC_BUILDER_H + +/** @defgroup axis2_desc_builder Description Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include "axis2_deployment.h" +#include "axis2_dep_engine.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_flow; + struct axis2_phase; + struct axis2_dep_engine; + + /** Type name for struct axis2_desc_builder */ + typedef struct axis2_desc_builder axis2_desc_builder_t; + + /** + * De-allocate memory + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_desc_builder_free( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env); + + /** + * This will creat OMElemnt for a given descrition document (axis2.xml , + * services.xml and module.xml) + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @return OMElement OMElement + */ + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + axis2_desc_builder_build_om( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env); + + /** + * To process Flow elements in services.xml + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param flow_element axiom_element_t + * @param parent pointer to parent + * @param node pointer to node + * @return flow + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_desc_builder_process_flow( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_element_t * flow_element, + axutil_param_container_t * parent, + axiom_node_t * node); + + /** + * To process Handler element + * @param handler_element OMElement + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param handler_element pointer to handler element + * @param parent pointer to parent + */ + AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL + + axis2_desc_builder_process_handler( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * handler_element, + axutil_param_container_t * parent); + + /** + * To get the Param out from the OM + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param params axutil_param_t + * @param param_container axutil_param_container_t + * @param parent axutil_param_container_t + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_builder_process_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * params, + axutil_param_container_t * param_container, + axutil_param_container_t * parent); + + /** + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param module_refs pointer to module refs + * @param op pointer to op + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_desc_builder_process_op_module_refs( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_op_t * op); + + /** + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param recv_element pointer to recv element + */ + AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL + + axis2_desc_builder_load_msg_recv( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_element_t * recv_element); + + /** + * This method is used to retrive service name form the arechive file name + * if the archive file name is service1.aar , then axis service name would be service1 + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_desc_builder_get_short_file_name( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param short_file_name pointer to short file name + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_desc_builder_get_file_name_without_prefix( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * short_file_name); + + /** + * this method is to get the value of attribue + * eg xsd:anyVal --> anyVal + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param in pointer to in + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_desc_builder_get_value( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * in); + + /** + * Populate the Axis2 Operation with details from the actionMapping, + * outputActionMapping and faultActionMapping elements from the operation + * element. + * @param operation + * @param op_desc + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_builder_process_action_mappings( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc); + + /** + * Populate the Axis2 Operation with details from the RESTLocation, + * RESTMethod elements from the operation element. + * @param operation + * @param op_desc + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_builder_process_rest_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc); + + /** + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL + axis2_desc_builder_load_default_msg_recv( + const axutil_env_t * env); + + AXIS2_EXTERN struct axis2_dep_engine *AXIS2_CALL + axis2_desc_builder_get_dep_engine( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env); + + /** + * Creates description builder struct + * @param env pointer to environment struct + * @return pointer to newly created description builder + */ + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + axis2_desc_builder_create( + const axutil_env_t * env); + + /** + * Creates description builder struct + * @param env pointer to environment struct + * @param engine pointer to engine + * @return pointer to newly created description builder + */ + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + + axis2_desc_builder_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine *engine); + + /** + * Creates description builder struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param engine pointer to engine + * @return pointer to newly created description builder + */ + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + + axis2_desc_builder_create_with_file_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *engine); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_process_policy_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_process_policy_reference_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_DESC_BUILDER_H */ diff --git a/src/core/deployment/axis2_module_builder.h b/src/core/deployment/axis2_module_builder.h new file mode 100644 index 0000000..cd713d6 --- /dev/null +++ b/src/core/deployment/axis2_module_builder.h @@ -0,0 +1,101 @@ + +/* + * 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_BUILDER_H +#define AXIS2_MODULE_BUILDER_H + +/** @defgroup axis2_module_builder Module Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_module_builder */ + typedef struct axis2_module_builder axis2_module_builder_t; + + /** + * De-allocate memory + * @param module_builder pointer to module builder + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_module_builder_free( + axis2_module_builder_t * module_builder, + const axutil_env_t * env); + + /** + * @param module_builder pointer to module builder + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_module_builder_populate_module( + axis2_module_builder_t * module_builder, + const axutil_env_t * env); + + /** + * Creates module builder struct + * @param env pointer to environment struct + * @return pointer to newly created module builder + */ + AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL + + axis2_module_builder_create( + const axutil_env_t * env); + + /** + * Creates module builder struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param dep_engine pointer to deployment engine + * @return pointer to newly created module builder + */ + AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL + + axis2_module_builder_create_with_file_and_dep_engine_and_module( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *dep_engine, + axis2_module_desc_t * module); + + /** Populates the module. + #define AXIS2_MODULE_BUILDER_POPULATE_MODULE(module_builder, env) \ + axis2_module_builder_populate_module (module_builder, env)*/ + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_MODULE_BUILDER_H */ diff --git a/src/core/deployment/axis2_repos_listener.h b/src/core/deployment/axis2_repos_listener.h new file mode 100644 index 0000000..56a37c8 --- /dev/null +++ b/src/core/deployment/axis2_repos_listener.h @@ -0,0 +1,144 @@ + +/* + * 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_REPOS_LISTENER_H +#define AXIS2_REPOS_LISTENER_H + +/** @defgroup axis2_repos_listener Repos Listener + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include "axis2_ws_info_list.h" +#include "axis2_dep_engine.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_dep_engine; + + /** Type name for struct axis2_repos_listener */ + typedef struct axis2_repos_listener axis2_repos_listener_t; + + /** + * De-allocate memory + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_repos_listener_free( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env); + + /** + * + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_repos_listener_check_modules( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_check_svcs( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_update( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * + * then it call to check_modules to load all the modules. + * and then it call to update() method inorder to update the deployment engine and engine. + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_init( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL + axis2_repos_listener_create( + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param folder_name this is the axis2 deployment root directory(repository path) + * @param dep_engine pointer to deployment engine + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL + axis2_repos_listener_create_with_folder_name_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * folder_name, + struct axis2_dep_engine *dep_engine); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_set_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env, + axis2_conf_t *conf); + + AXIS2_EXTERN axis2_conf_t *AXIS2_CALL + axis2_repos_listener_get_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env); + + + + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_REPOS_LISTENER_H */ diff --git a/src/core/deployment/axis2_svc_builder.h b/src/core/deployment/axis2_svc_builder.h new file mode 100644 index 0000000..c71e7dc --- /dev/null +++ b/src/core/deployment/axis2_svc_builder.h @@ -0,0 +1,149 @@ + +/* + * 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_BUILDER_H +#define AXIS2_SVC_BUILDER_H + +/** + * @defgroup axis2_svc_builder Service Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_dep_engine; + + /** Type name for struct axis2_svc_builder */ + typedef struct axis2_svc_builder axis2_svc_builder_t; + + /** + * De-allocate memory + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_builder_free( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env); + + /** + * top most method that is used to populate service from corresponding OM + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + * @param svc_node pointer to service node + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_builder_populate_svc( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_node_t * svc_node); + + /** + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + * @param module_confs pointer to module configurations + * @param parent pointer to parent + * @param svc pointer to service + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_builder_process_svc_module_conf( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_confs, + axutil_param_container_t * parent, + axis2_svc_t * svc); + + /** + * To get the list og modules that is requird to be engage globally + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + * @param module_refs pointer to module refs + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_builder_process_module_refs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs); + + AXIS2_EXTERN struct axis2_desc_builder *AXIS2_CALL + + axis2_svc_builder_get_desc_builder( + const axis2_svc_builder_t * svc_builder, + const axutil_env_t * env); + + /** + * Creates svc builder struct + * @param env pointer to environment struct + * @return pointer to newly created service builder + */ + AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL + axis2_svc_builder_create( + const axutil_env_t * env); + + /** + * Creates svc builder struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param dep_engine pointer to deployment engine + * @param svc pointer to service + * @return pointer to newly created service builder + */ + AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL + + axis2_svc_builder_create_with_file_and_dep_engine_and_svc( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *dep_engine, + axis2_svc_t * svc); + + /** + * Creates svc builder struct + * @param env pointer to environment struct + * @param dep_engine pointer to deployment engine + * @param svc pointer to service + * @return pointer to newly created service builder + */ + AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL + + axis2_svc_builder_create_with_dep_engine_and_svc( + const axutil_env_t * env, + struct axis2_dep_engine *dep_engine, + axis2_svc_t * svc); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SVC_BUILDER_H */ diff --git a/src/core/deployment/axis2_svc_grp_builder.h b/src/core/deployment/axis2_svc_grp_builder.h new file mode 100644 index 0000000..852c9a7 --- /dev/null +++ b/src/core/deployment/axis2_svc_grp_builder.h @@ -0,0 +1,122 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not svc_grp 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_BUILDER_H +#define AXIS2_SVC_GRP_BUILDER_H + +/** @defgroup axis2_svc_grp_builder Service Group Builder + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_svc_grp_builder.h + * @brief Axis2 Service Group Builder interface + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc_grp_builder */ + typedef struct axis2_svc_grp_builder axis2_svc_grp_builder_t; + + /** + * De-allocate memory + * @param svc_grp_builder pointer to service group builder + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_grp_builder_free( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env); + + /** + * @param grp_builder pointer to group builder + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_grp_builder_populate_svc_grp( + axis2_svc_grp_builder_t * grp_builder, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp); + + /** + * To get the list og modules that is requird to be engage globally + * @param grp_builder pointer to group builder + * @param env pointer to environment struct + * @param module_refs axiom_children_qname_iterator_t + * @param svc_group pointer to service group + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_grp_builder_process_module_refs( + axis2_svc_grp_builder_t * grp_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_svc_grp_t * svc_grp); + + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + + axis2_svc_grp_builder_get_desc_builder( + const axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env); + + /** + * Creates svc_grp builder struct + * @param env pointer to environment struct + * @return pointer to newly created service group builder + */ + AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL + + axis2_svc_grp_builder_create( + const axutil_env_t * env); + + /** + * Creates svc_grp builder struct + * @param env pointer to environment strut + * @param svc pointer to service + * @param dep_engine pointer to deployment engine + * @return pointer to newly created service group builder + */ + AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL + + axis2_svc_grp_builder_create_with_svc_and_dep_engine( + const axutil_env_t * env, + axiom_node_t * svc, + axis2_dep_engine_t * dep_engine); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SVC_GRP_BUILDER_H */ diff --git a/src/core/deployment/axis2_ws_info.h b/src/core/deployment/axis2_ws_info.h new file mode 100644 index 0000000..d6fd117 --- /dev/null +++ b/src/core/deployment/axis2_ws_info.h @@ -0,0 +1,144 @@ + +/* + * 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_WS_INFO_H +#define AXIS2_WS_INFO_H + +/** + * @defgroup axis2_ws_info Ws Info + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_ws_info.h + * @brief Axis2 Ws Info interface. ws_info construct contain file information + * for module or service configuration file. + */ +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf; + + /** Type name for struct axis2_ws_info */ + typedef struct axis2_ws_info axis2_ws_info_t; + + /** + * De-allocate memory + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_ws_info_free( + axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_ws_info_get_file_name( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ws_info_set_file_name( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN long AXIS2_CALL + axis2_ws_info_get_last_modified_date( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + * @param modified_data pointer to modified date + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_ws_info_set_last_modified_date( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + long last_modified_date); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_ws_info_get_type( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * Creates ws_info struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param last_modified_date pointer to last modified date + * @return pointer to newly created ws info + */ + AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL + + axis2_ws_info_create_with_file_name_and_last_modified_date( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date); + + /** + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param last_modifile_date last modified date + * @param type type + */ + AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL + + axis2_ws_info_create_with_file_name_and_last_modified_date_and_type( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date, + int type); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_WS_INFO_H */ diff --git a/src/core/deployment/axis2_ws_info_list.h b/src/core/deployment/axis2_ws_info_list.h new file mode 100644 index 0000000..3ffb68d --- /dev/null +++ b/src/core/deployment/axis2_ws_info_list.h @@ -0,0 +1,192 @@ + +/* + * 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_WS_INFO_LIST_H +#define AXIS2_WS_INFO_LIST_H + +/** @defgroup axis2_ws_info_list Ws Info List + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_ws_info_list.h + * @brief Axis2 Ws Info List interface. Ws Info List is the list of ws_info structs. + * Each ws_info construct contain file information for module or service configuration file. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "axis2_deployment.h" +#include +#include +#include "axis2_ws_info.h" +#include "axis2_arch_file_data.h" +#include "axis2_dep_engine.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_ws_info; + struct axis2_dep_engine; + + /** Type name for struct axis2_ws_info_list */ + typedef struct axis2_ws_info_list axis2_ws_info_list_t; + + /** + * De-allocate memory + * @param ws_info_list pointer to ws info list + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_ws_info_list_free( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env); + + /** + * This method is used to initialize the ws info list. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ws_info_list_init( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env); + + /** + * This will add the deployment info struct(ws_info) into the deployment info + * list and deployment info file to the deployment engine as new + * service or module deployment info struct/file. + * In doing this, it first create an deployment info struct called ws_info + * to keep the file info that will be added to deployment info file + * list and then create deployment info file called arch_file_data that will + * be added to deployment engine for actual deployment of the service/module. + * + * This will add two entries to deployment engine one for new Deployment and + * other for undeployment. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file actual axis2 configuration file for module/service. + * @param type indicate either service or module + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_ws_info_list_add_ws_info_item( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axutil_file_t * file, + int type); + + /** + * This method is used to check whether the service/module configuration + * file exist and if so it will return related ws_info object to the file, + * else return NULL; + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL + + axis2_ws_info_list_get_file_item( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * Compare the last update dates of both files and if those differ + * it will be assumed as the file has been modified. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file pointer to servie/module configuration file. + * @param ws_info pointer to ws info struct. + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_ws_info_list_is_modified( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axutil_file_t * file, + struct axis2_ws_info *ws_info); + + /** + * To check whether the deployment info file is alredy in the list. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_ws_info_list_is_file_exist( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * This is to check whether to undeploy ws info struct. + * What this realy does is, it check ws_info list and current deployment + * info name list. If ws_info exists in the ws_info_list but it's + * corresponding file name does not exist in the current deploymet file + * name list then, struct is deemed non existant. ie. that is hot + * undeployment. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_ws_info_list_check_for_undeploy( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env); + + /** + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ws_info_list_update( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env); + + /** + * Creates ws info list struct + * @param env pointer to environment struct + * @param dep_engine pointer to deployment engine + * @return pointer to newly created ws info list + */ + AXIS2_EXTERN axis2_ws_info_list_t *AXIS2_CALL + + axis2_ws_info_list_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine *dep_engine); + + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_WS_INFO_LIST_H */ diff --git a/src/core/deployment/conf_builder.c b/src/core/deployment/conf_builder.c new file mode 100644 index 0000000..15485b0 --- /dev/null +++ b/src/core/deployment/conf_builder.c @@ -0,0 +1,1337 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_conf_builder +{ + axis2_conf_t *conf; + struct axis2_desc_builder *desc_builder; +}; + +static axis2_status_t +axis2_conf_builder_process_disp_order( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * disp_order_node); + +static axis2_status_t +axis2_conf_builder_process_phase_orders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * phase_orders); + +static axutil_array_list_t * +axis2_conf_builder_get_phase_list( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * phase_orders_node); + +static axis2_status_t +axis2_conf_builder_process_transport_senders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_senders); + +static axis2_status_t +axis2_conf_builder_process_transport_recvs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_recvs); + +static axis2_status_t AXIS2_CALL +axis2_conf_builder_process_default_module_versions( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_versions); + +AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL +axis2_conf_builder_create( + const axutil_env_t * env) +{ + axis2_conf_builder_t *conf_builder = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + conf_builder = (axis2_conf_builder_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_conf_builder_t)); + + if(!conf_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + conf_builder->conf = NULL; + + return conf_builder; +} + +AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL +axis2_conf_builder_create_with_file_and_dep_engine_and_conf( + const axutil_env_t * env, + axis2_char_t * file, + axis2_dep_engine_t * engine, + axis2_conf_t * conf) +{ + axis2_conf_builder_t *conf_builder = NULL; + + conf_builder = (axis2_conf_builder_t *)axis2_conf_builder_create(env); + if(!conf_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + conf_builder->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, file, + engine); + conf_builder->conf = conf; + + return conf_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_conf_builder_free( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env) +{ + if(conf_builder->desc_builder) + { + axis2_desc_builder_free(conf_builder->desc_builder, env); + } + + if(conf_builder) + { + AXIS2_FREE(env->allocator, conf_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_builder_populate_conf( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env) +{ + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmsgrecv = NULL; + axutil_qname_t *qdisporder = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qtransportsender = NULL; + axutil_qname_t *qtransportrecv = NULL; + axutil_qname_t *qphaseorder = NULL; + axutil_qname_t *qdefmodver = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *msg_recvs = NULL; + axiom_children_qname_iterator_t *module_itr = NULL; + axiom_children_qname_iterator_t *trs_senders = NULL; + axiom_children_qname_iterator_t *trs_recvs = NULL; + axiom_children_qname_iterator_t *phase_orders = NULL; + axiom_children_qname_iterator_t *def_mod_versions = NULL; + axiom_element_t *conf_element = NULL; + axiom_node_t *conf_node = NULL; + axiom_element_t *disp_order_element = NULL; + axiom_node_t *disp_order_node = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_param_t *param = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_populate_conf"); + conf_node = axis2_desc_builder_build_om(conf_builder->desc_builder, env); + if(!conf_node) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Building om tree failed. Unable to continue"); + return AXIS2_FAILURE; + } + conf_element = axiom_node_get_data_element(conf_node, env); + /* processing Paramters */ + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(conf_element, env, qparamst, conf_node); + axutil_qname_free(qparamst, env); + axis2_desc_builder_process_params(conf_builder->desc_builder, env, itr, + axis2_conf_get_param_container(conf_builder->conf, env), axis2_conf_get_param_container( + conf_builder->conf, env)); + /* process Message Reciver */ + qmsgrecv = axutil_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL); + msg_recvs = axiom_element_get_children_with_qname(conf_element, env, qmsgrecv, conf_node); + axutil_qname_free(qmsgrecv, env); + while(axiom_children_qname_iterator_has_next(msg_recvs, env)) + { + axiom_node_t *msg_recv_node = NULL; + axiom_element_t *msg_recv_element = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axiom_attribute_t *recv_name = NULL; + axutil_qname_t *class_qname = NULL; + axis2_char_t *class_name = NULL; + + msg_recv_node = (axiom_node_t *)axiom_children_qname_iterator_next(msg_recvs, env); + msg_recv_element = (axiom_element_t *)axiom_node_get_data_element(msg_recv_node, env); + msg_recv = axis2_desc_builder_load_msg_recv(conf_builder->desc_builder, env, + msg_recv_element); + if(!msg_recv) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Message receiver loading failed. Unable to continue"); + return AXIS2_FAILURE; + } + + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + recv_name = axiom_element_get_attribute(msg_recv_element, env, class_qname); + axutil_qname_free(class_qname, env); + class_name = axiom_attribute_get_value(recv_name, env); + axis2_conf_add_msg_recv(conf_builder->conf, env, class_name, msg_recv); + } + + /* processing Dispatching Order */ + qdisporder = axutil_qname_create(env, AXIS2_DISPATCH_ORDER, NULL, NULL); + disp_order_element = axiom_element_get_first_child_with_qname(conf_element, env, qdisporder, + conf_node, &disp_order_node); + axutil_qname_free(qdisporder, env); + if(disp_order_element) + { + axis2_conf_builder_process_disp_order(conf_builder, env, disp_order_node); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Found the custom disptaching" + " order and continue with that order"); + } + else + { + status = axis2_conf_set_default_dispatchers(conf_builder->conf, env); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting default dispatchers to configuration failed, " + "unable to continue."); + return AXIS2_FAILURE; + } + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No custom dispatching order" + " found. Continue with the default dispatching order"); + } + + /* Process Module refs */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_itr = axiom_element_get_children_with_qname(conf_element, env, qmodulest, conf_node); + axutil_qname_free(qmodulest, env); + status = axis2_conf_builder_process_module_refs(conf_builder, env, module_itr); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing module ref's failed, unable to continue."); + return AXIS2_FAILURE; + } + /* Proccessing Transport Sennders */ + qtransportsender = axutil_qname_create(env, AXIS2_TRANSPORTSENDER, NULL, NULL); + trs_senders = axiom_element_get_children_with_qname(conf_element, env, qtransportsender, + conf_node); + axutil_qname_free(qtransportsender, env); + status = axis2_conf_builder_process_transport_senders(conf_builder, env, trs_senders); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing transport senders failed, unable to continue"); + return AXIS2_FAILURE; + } + + /* Proccessing Transport Recivers */ + qtransportrecv = axutil_qname_create(env, AXIS2_TRANSPORTRECEIVER, NULL, NULL); + trs_recvs = axiom_element_get_children_with_qname(conf_element, env, qtransportrecv, conf_node); + axutil_qname_free(qtransportrecv, env); + status = axis2_conf_builder_process_transport_recvs(conf_builder, env, trs_recvs); + + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing transport receivers failed, unable to continue"); + return AXIS2_FAILURE; + } + + /* processing Phase orders */ + qphaseorder = axutil_qname_create(env, AXIS2_PHASE_ORDER, NULL, NULL); + phase_orders = axiom_element_get_children_with_qname(conf_element, env, qphaseorder, conf_node); + axutil_qname_free(qphaseorder, env); + status = axis2_conf_builder_process_phase_orders(conf_builder, env, phase_orders); + + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing phase orders failed, unable to continue"); + return AXIS2_FAILURE; + } + + /* Processing default module versions */ + qdefmodver = axutil_qname_create(env, AXIS2_DEFAULT_MODULE_VERSION, NULL, NULL); + def_mod_versions = axiom_element_get_children_with_qname(conf_element, env, qdefmodver, + conf_node); + axutil_qname_free(qdefmodver, env); + if(def_mod_versions) + { + status = axis2_conf_builder_process_default_module_versions(conf_builder, env, + def_mod_versions); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing default module versions failed, unable to continue"); + return AXIS2_FAILURE; + } + } + + param = axutil_param_container_get_param( + axis2_conf_get_param_container(conf_builder->conf, env), env, AXIS2_ENABLE_MTOM); + if(param) + { + axis2_char_t *value = NULL; + value = axutil_param_get_value(param, env); + if(value) + { + axis2_conf_set_enable_mtom(conf_builder->conf, env, (!axutil_strcmp(value, + AXIS2_VALUE_TRUE))); + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_populate_conf"); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_builder_process_module_refs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs) +{ + axis2_status_t status = AXIS2_SUCCESS; + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_module_refs"); + AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_node_t *module_ref_node = NULL; + axiom_element_t *module_ref_element = NULL; + axutil_qname_t *qref = NULL; + + axiom_attribute_t *module_ref_att = NULL; + module_ref_node = (axiom_node_t *)axiom_children_qname_iterator_next(module_refs, env); + if(!module_ref_node) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Module ref node is empty. Unable to continue"); + return AXIS2_FAILURE; + } + module_ref_element = axiom_node_get_data_element(module_ref_node, env); + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref); + if(qref) + { + axutil_qname_free(qref, env); + } + + if(module_ref_att) + { + axutil_qname_t *qrefname = NULL; + axis2_char_t *ref_name = NULL; + + ref_name = axiom_attribute_get_value(module_ref_att, env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module %s found in axis2.xml", ref_name); + qrefname = axutil_qname_create(env, ref_name, NULL, NULL); + status = axis2_dep_engine_add_module(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env, qrefname); + if(qrefname) + { + axutil_qname_free(qrefname, env); + } + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_module_refs"); + return status; +} + +static axis2_status_t +axis2_conf_builder_process_disp_order( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * disp_order_node) +{ + axiom_element_t *disp_order_element = NULL; + axiom_children_qname_iterator_t *disps = NULL; + axutil_qname_t *qdisp = NULL; + axis2_bool_t found_disp = AXIS2_FALSE; + axis2_phase_t *disp_phase = NULL; + int count = 0; + axis2_bool_t qname_itr_has_next = AXIS2_FALSE; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_disp_order"); + AXIS2_PARAM_CHECK(env->error, disp_order_node, AXIS2_FAILURE); + + disp_order_element = axiom_node_get_data_element(disp_order_node, env); + qdisp = axutil_qname_create(env, AXIS2_DISPATCHER, NULL, NULL); + disps = axiom_element_get_children_with_qname(disp_order_element, env, qdisp, disp_order_node); + axutil_qname_free(qdisp, env); + disp_phase = axis2_phase_create(env, AXIS2_PHASE_DISPATCH); + if(!disp_phase) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Dispatch phase creation failed. Unable to continue"); + return AXIS2_FAILURE; + } + if(disps) + { + qname_itr_has_next = axiom_children_qname_iterator_has_next(disps, env); + } + while(qname_itr_has_next) + { + axiom_node_t *disp_node = NULL; + axiom_element_t *disp_element = NULL; + axiom_attribute_t *disp_att = NULL; + axis2_char_t *class_name = NULL; + axis2_char_t *dll_name = NULL; + axutil_qname_t *class_qname = NULL; + axis2_disp_t *disp_dll = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axis2_handler_desc_t *handler_desc = NULL; + axis2_handler_t *handler = NULL; + + found_disp = AXIS2_TRUE; + disp_node = (axiom_node_t *)axiom_children_qname_iterator_next(disps, env); + disp_element = (axiom_element_t *) axiom_node_get_data_element(disp_node, env); + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + disp_att = axiom_element_get_attribute(disp_element, env, class_qname); + axutil_qname_free(class_qname, env); + if(!disp_att) + { + qname_itr_has_next = axiom_children_qname_iterator_has_next(disps, env); + continue; + } + class_name = axiom_attribute_get_value(disp_att, env); + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + axutil_dll_desc_set_name(dll_desc, env, dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_HANDLER_DLL); + impl_info_param = axutil_param_create(env, class_name, NULL); + if(!impl_info_param) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Parameter creation failed for %s. Unable to continue", class_name); + + axis2_phase_free(disp_phase, env); + + return AXIS2_FAILURE; + } + + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + disp_dll = (axis2_disp_t *)axutil_class_loader_create_dll(env, impl_info_param); + + handler = axis2_disp_get_base(disp_dll, env); + handler_desc = axis2_handler_get_handler_desc(handler, env); + axis2_handler_desc_add_param(handler_desc, env, impl_info_param); + + axis2_phase_add_handler_at(disp_phase, env, count, handler); + count++; + qname_itr_has_next = axiom_children_qname_iterator_has_next(disps, env); + + } + + if(!found_disp) + { + axis2_phase_free(disp_phase, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_DISPATCHER_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No dispatcher found. Unable to continue"); + + return AXIS2_FAILURE; + } + else + { + status = axis2_conf_set_dispatch_phase(conf_builder->conf, env, disp_phase); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting dispatch phase failed. Unable to continue"); + + axis2_phase_free(disp_phase, env); + + return status; + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_disp_order"); + return AXIS2_SUCCESS; +} + +/** + * To process all the phase orders which are defined in axis2.xml retrieve each phase order node + * from the iterator passed as parameter and from each phase order node retrieve phases list + * defined for that phase order. Add the phases names into a array list and set it into the + * dep_engine->phases_info with the corresponding phase order name. + * @param phase_orders + */ +static axis2_status_t +axis2_conf_builder_process_phase_orders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * phase_orders) +{ + axis2_phases_info_t *info = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_phase_orders"); + + AXIS2_PARAM_CHECK(env->error, phase_orders, AXIS2_FAILURE); + + info = axis2_dep_engine_get_phases_info(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env); + + while(axiom_children_qname_iterator_has_next(phase_orders, env)) + { + axiom_node_t *phase_orders_node = NULL; + axiom_element_t *phase_orders_element = NULL; + axiom_attribute_t *phase_orders_att = NULL; + axutil_qname_t *qtype = NULL; + axis2_char_t *flow_type = NULL; + axutil_array_list_t *phase_list = NULL; + + phase_orders_node = (axiom_node_t *)axiom_children_qname_iterator_next(phase_orders, env); + if(phase_orders_node) + { + phase_orders_element = axiom_node_get_data_element(phase_orders_node, env); + } + if(phase_orders_element) + { + qtype = axutil_qname_create(env, AXIS2_TYPE, NULL, NULL); + phase_orders_att = axiom_element_get_attribute(phase_orders_element, env, qtype); + axutil_qname_free(qtype, env); + } + + if(phase_orders_att) + { + flow_type = axiom_attribute_get_value(phase_orders_att, env); + } + + phase_list = axis2_conf_builder_get_phase_list(conf_builder, env, phase_orders_node); + if(!phase_list) + { + axis2_status_t status_code = AXIS2_FAILURE; + + status_code = AXIS2_ERROR_GET_STATUS_CODE(env->error); + if(AXIS2_SUCCESS != status_code) + { + return status_code; + } + + return AXIS2_SUCCESS; + } + + if(flow_type && !axutil_strcmp(AXIS2_IN_FLOW_START, flow_type)) + { + axis2_phases_info_set_in_phases(info, env, phase_list); + } + else if(flow_type && !axutil_strcmp(AXIS2_IN_FAILTFLOW, flow_type)) + { + axis2_phases_info_set_in_faultphases(info, env, phase_list); + } + else if(flow_type && !axutil_strcmp(AXIS2_OUT_FLOW_START, flow_type)) + { + axis2_phases_info_set_out_phases(info, env, phase_list); + } + else if(flow_type && !axutil_strcmp(AXIS2_OUT_FAILTFLOW, flow_type)) + { + axis2_phases_info_set_out_faultphases(info, env, phase_list); + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_phase_orders"); + + return AXIS2_SUCCESS; +} + +/* From the phase order node passed as parameter retrieve all phase element nodes. From them extract + * the phase name and add it to a array list. Return the array list. + */ +static axutil_array_list_t * +axis2_conf_builder_get_phase_list( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * phase_orders_node) +{ + axutil_array_list_t *phase_list = NULL; + axiom_children_qname_iterator_t *phases = NULL; + axutil_qname_t *qphase = NULL; + axiom_element_t *phase_orders_element; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_get_phase_list"); + + AXIS2_PARAM_CHECK(env->error, phase_orders_node, NULL); + + phase_orders_element = axiom_node_get_data_element(phase_orders_node, env); + if(!phase_orders_element) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving phase orders data element from phase orders node failed. Unable to continue"); + + return NULL; + } + + phase_list = axutil_array_list_create(env, 0); + qphase = axutil_qname_create(env, AXIS2_PHASE, NULL, NULL); + phases = axiom_element_get_children_with_qname(phase_orders_element, env, qphase, + phase_orders_node); + + axutil_qname_free(qphase, env); + if(!phases) + { + axutil_array_list_free(phase_list, env); + + /* I guess this is not an error. So adding debug message*/ + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No phase node found in the phase orders node"); + + return NULL; + } + + while(axiom_children_qname_iterator_has_next(phases, env)) + { + axiom_node_t *phase_node = NULL; + axiom_element_t *phase_element = NULL; + axiom_attribute_t *phase_att = NULL; + axutil_qname_t *qattname = NULL; + axis2_char_t *att_value = NULL; + + phase_node = (axiom_node_t *)axiom_children_qname_iterator_next(phases, env); + if(phase_node) + { + phase_element = (axiom_element_t *)axiom_node_get_data_element(phase_node, env); + } + + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + if(phase_element) + { + phase_att = axiom_element_get_attribute(phase_element, env, qattname); + } + + if(phase_att) + { + att_value = axiom_attribute_get_value(phase_att, env); + } + + if(att_value) + { + axutil_array_list_add(phase_list, env, att_value); + } + + axutil_qname_free(qattname, env); + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_get_phase_list"); + + return phase_list; +} + +static axis2_status_t +axis2_conf_builder_process_transport_senders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_senders) +{ + axis2_status_t status = AXIS2_FAILURE; + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_transport_senders"); + while(axiom_children_qname_iterator_has_next(trs_senders, env)) + { + axis2_transport_out_desc_t *transport_out = NULL; + axiom_node_t *transport_node = NULL; + axiom_element_t *transport_element = NULL; + axiom_attribute_t *trs_name = NULL; + axutil_qname_t *qattname = NULL; + + transport_node = (axiom_node_t *)axiom_children_qname_iterator_next(trs_senders, env); + + if(transport_node) + { + transport_element = (axiom_element_t *)axiom_node_get_data_element(transport_node, env); + if(!transport_element) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving data element failed from the transport node." + " Unable to continue"); + return AXIS2_FAILURE; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport node is empty. Unable to continue"); + return AXIS2_FAILURE; + } + + /* getting trsnport Name */ + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + if(transport_element) + { + trs_name = axiom_element_get_attribute(transport_element, env, qattname); + } + + axutil_qname_free(qattname, env); + if(trs_name) + { + axis2_char_t *name = NULL; + axiom_attribute_t *trs_dll_att = NULL; + axis2_char_t *dll_name = NULL; + axis2_char_t *class_name = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qinfaultflowst = NULL; + axutil_qname_t *qoutfaultflowst = NULL; + axutil_qname_t *qdllname = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *in_fault_flow_element = NULL; + axiom_node_t *in_fault_flow_node = NULL; + axiom_element_t *out_fault_flow_element = NULL; + axiom_node_t *out_fault_flow_node = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + void *transport_sender = NULL; + axis2_char_t *path_qualified_dll_name = NULL; + axis2_char_t *repos_name = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *temp_path2 = NULL; + axis2_char_t *temp_path3 = NULL; + AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + /* AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP + * set to avoid C4701 on Windows + */ + axis2_bool_t axis2_flag = AXIS2_FALSE; + axutil_param_t *libparam; + axis2_char_t *libdir = NULL; + axis2_conf_t *conf; + + conf = conf_builder->conf; + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + + name = axiom_attribute_get_value(trs_name, env); + + if(name) + { + if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_SMTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_SMTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_XMPP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_XMPP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_TCP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_TCP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTPS)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTPS; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_AMQP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_AMQP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_UDP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_UDP; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport name %s doesn't match with transport enum. " + "Unable to continue", name); + return AXIS2_FAILURE; + } + + transport_out = axis2_transport_out_desc_create(env, transport_enum); + } + + if(!transport_out) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport_out value is NULL for transport %s", name); + return AXIS2_FAILURE; + } + + /* transport impl class */ + qdllname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + trs_dll_att = axiom_element_get_attribute(transport_element, env, qdllname); + axutil_qname_free(qdllname, env); + if(!trs_dll_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_TRANSPORT_SENDER_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport dll name attribute is not set in the " + "%s transport element node", name); + return AXIS2_FAILURE; + } + class_name = axiom_attribute_get_value(trs_dll_att, env); + impl_info_param = axutil_param_create(env, class_name, NULL); + if(!impl_info_param) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating module dll name parameter failed for %s. Unable " + "to continue", class_name); + axis2_transport_out_desc_free(transport_out, env); + return AXIS2_FAILURE; + } + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + if(!axis2_flag) + { + repos_name = axis2_dep_engine_get_repos_path(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env); + temp_path = axutil_stracat(env, repos_name, AXIS2_PATH_SEP_STR); + temp_path2 = axutil_stracat(env, temp_path, AXIS2_LIB_FOLDER); + temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR); + path_qualified_dll_name = axutil_stracat(env, temp_path3, dll_name); + AXIS2_FREE(env->allocator, temp_path); + AXIS2_FREE(env->allocator, temp_path2); + AXIS2_FREE(env->allocator, temp_path3); + } + else + { + libparam = axis2_conf_get_param(conf, env, AXIS2_LIB_DIR); + if(libparam) + { + libdir = axutil_param_get_value(libparam, env); + } + + if(!libdir) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Specifying" + "services and modules directories using axis2.xml but" + " path of the library directory is not present"); + return AXIS2_FAILURE; + } + path_qualified_dll_name = axutil_strcat(env, libdir, AXIS2_PATH_SEP_STR, dll_name, + NULL); + } + + axutil_dll_desc_set_name(dll_desc, env, path_qualified_dll_name); + AXIS2_FREE(env->allocator, path_qualified_dll_name); + + axutil_dll_desc_set_type(dll_desc, env, AXIS2_TRANSPORT_SENDER_DLL); + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + transport_sender = axutil_class_loader_create_dll(env, impl_info_param); + axis2_transport_out_desc_add_param(transport_out, env, impl_info_param); + + if(!transport_sender) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport sender is NULL for transport %s, unable to " + "continue", name); + axis2_transport_out_desc_free(transport_out, env); + return status; + } + + status = axis2_transport_out_desc_set_sender(transport_out, env, transport_sender); + if(!status) + { + axis2_transport_out_desc_free(transport_out, env); + return status; + } + + /* Process Parameters */ + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(transport_element, env, qparamst, + transport_node); + axutil_qname_free(qparamst, env); + + if(itr) + { + status = axis2_desc_builder_process_params(conf_builder->desc_builder, env, itr, + axis2_transport_out_desc_param_container(transport_out, env), + axis2_conf_get_param_container(conf_builder->conf, env)); + } + if(!status) + { + axis2_transport_out_desc_free(transport_out, env); + return status; + } + /* process IN_FLOW */ + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qinflowst, transport_node, &in_flow_node); + axutil_qname_free(qinflowst, env); + if(in_flow_element) + { + axis2_transport_out_desc_free(transport_out, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_IN_FLOW_NOT_ALLOWED_IN_TRS_OUT, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport in flow element is not allowed in the out path"); + return AXIS2_FAILURE; + } + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qoutflowst, transport_node, &out_flow_node); + axutil_qname_free(qoutflowst, env); + if(out_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + out_flow_element, axis2_conf_get_param_container(conf_builder->conf, env), + out_flow_node); + status = axis2_transport_out_desc_set_out_flow(transport_out, env, flow); + if(!status) + { + axis2_transport_out_desc_free(transport_out, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting the out flow failed on the trasnport out " + "description for the transport %s", name); + return status; + } + } + + /* process IN FAULT FLOW */ + qinfaultflowst = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qinfaultflowst, transport_node, &in_fault_flow_node); + axutil_qname_free(qinfaultflowst, env); + if(in_fault_flow_element) + { + axis2_transport_out_desc_free(transport_out, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_IN_FLOW_NOT_ALLOWED_IN_TRS_OUT, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "A soap fault has occured in the in flow while " + "processing transport senders. Unable to continue"); + return AXIS2_FAILURE; + } + + qoutfaultflowst = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qoutfaultflowst, transport_node, &out_fault_flow_node); + axutil_qname_free(qoutfaultflowst, env); + if(out_fault_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + out_fault_flow_element, + axis2_conf_get_param_container(conf_builder->conf, env), out_fault_flow_node); + status = axis2_transport_out_desc_set_fault_out_flow(transport_out, env, flow); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting the fault out flow into the transport out " + "failed"); + axis2_transport_out_desc_free(transport_out, env); + return status; + } + } + + /* adding to axis config */ + status = axis2_conf_add_transport_out(conf_builder->conf, env, transport_out, + transport_enum); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding transport out for %s into main configuration failed", name); + axis2_transport_out_desc_free(transport_out, env); + return status; + } + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_transport_senders"); + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_conf_builder_process_transport_recvs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_recvs) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_conf_t *conf; + axis2_bool_t axis2_flag = AXIS2_FALSE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_transport_recvs"); + AXIS2_PARAM_CHECK(env->error, trs_recvs, AXIS2_FAILURE); + + conf = conf_builder->conf; + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + + while(axiom_children_qname_iterator_has_next(trs_recvs, env)) + { + axis2_transport_in_desc_t *transport_in = NULL; + axiom_node_t *transport_node = NULL; + axiom_element_t *transport_element = NULL; + axiom_attribute_t *trs_name = NULL; + axutil_qname_t *qattname = NULL; + + transport_node = (axiom_node_t *)axiom_children_qname_iterator_next(trs_recvs, env); + if(transport_node) + { + transport_element = axiom_node_get_data_element(transport_node, env); + if(!transport_element) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving data element from the transport node failed."); + return AXIS2_FAILURE; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport node is NULL. Unable to continue"); + return AXIS2_FAILURE; + } + + /* getting transport Name */ + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + trs_name = axiom_element_get_attribute(transport_element, env, qattname); + axutil_qname_free(qattname, env); + + if(trs_name) + { + axis2_char_t *name = NULL; + axiom_attribute_t *trs_class_name = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *class_qname = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qinfaultflowst = NULL; + axutil_qname_t *qoutfaultflowst = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *in_fault_flow_element = NULL; + axiom_node_t *in_fault_flow_node = NULL; + axiom_element_t *out_fault_flow_element = NULL; + axiom_node_t *out_fault_flow_node = NULL; + AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + /* AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP + * set to avoid C4701 on Windows + */ + + name = axiom_attribute_get_value(trs_name, env); + if(name) + { + if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_SMTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_SMTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_XMPP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_XMPP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_TCP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_TCP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTPS)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTPS; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_AMQP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_AMQP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_UDP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_UDP; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport %s could not be recognized.", name); + return AXIS2_FAILURE; + } + + transport_in = axis2_transport_in_desc_create(env, transport_enum); + } + if(!transport_in) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating trasport_in_desc for transport %s failed", name); + return AXIS2_FAILURE; + } + + /* transport impl class */ + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + trs_class_name = axiom_element_get_attribute(transport_element, env, class_qname); + axutil_qname_free(class_qname, env); + + if(trs_class_name) + { + axis2_char_t *class_name = NULL; + axis2_char_t *dll_name = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axis2_transport_receiver_t *recv = NULL; + axis2_status_t stat = AXIS2_FAILURE; + axis2_char_t *path_qualified_dll_name = NULL; + axis2_char_t *repos_name = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *temp_path2 = NULL; + axis2_char_t *temp_path3 = NULL; + + axutil_param_t *tnsparam; + axis2_char_t *libpath; + + class_name = axiom_attribute_get_value(trs_class_name, env); + impl_info_param = axutil_param_create(env, class_name, NULL); + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, + class_name); + if(!axis2_flag) + { + /* Axis2 Configuration is not built using axis2.xml */ + repos_name = axis2_dep_engine_get_repos_path(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env); + temp_path = axutil_stracat(env, repos_name, AXIS2_PATH_SEP_STR); + temp_path2 = axutil_stracat(env, temp_path, AXIS2_LIB_FOLDER); + temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR); + path_qualified_dll_name = axutil_stracat(env, temp_path3, dll_name); + AXIS2_FREE(env->allocator, temp_path); + AXIS2_FREE(env->allocator, temp_path2); + AXIS2_FREE(env->allocator, temp_path3); + } + else + { + /* Axis2 Configuration is built using axis2.xml */ + tnsparam = axis2_conf_get_param(conf, env, AXIS2_LIB_DIR); + if(tnsparam) + { + libpath = (axis2_char_t *)axutil_param_get_value(tnsparam, env); + + if(libpath) + { + path_qualified_dll_name = axutil_strcat(env, libpath, + AXIS2_PATH_SEP_STR, dll_name, NULL); + } + } + } + + axutil_dll_desc_set_name(dll_desc, env, path_qualified_dll_name); + AXIS2_FREE(env->allocator, path_qualified_dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_TRANSPORT_RECV_DLL); + + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + recv = (axis2_transport_receiver_t *)axutil_class_loader_create_dll(env, + impl_info_param); + axis2_transport_in_desc_add_param(transport_in, env, impl_info_param); + + if(!recv) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport receiver loading failed for %s, " + "unable to continue", dll_name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + axis2_transport_receiver_set_is_application_client_side(recv, env, AXIS2_TRUE); + stat = axis2_transport_in_desc_set_recv(transport_in, env, recv); + + if(!stat) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting transport receiver for transport %s into " + "transport in description failed, unable to continue", name); + axis2_transport_in_desc_free(transport_in, env); + return stat; + } + + } + + /* process Parameters */ + /* processing Paramters */ + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(transport_element, env, qparamst, + transport_node); + axutil_qname_free(qparamst, env); + status = axis2_desc_builder_process_params(conf_builder->desc_builder, env, itr, + axis2_transport_in_desc_param_container(transport_in, env), + axis2_conf_get_param_container(conf_builder->conf, env)); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing transport receiver parameters failed. " + "Unable to continue"); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + /* process OUT_FLOW */ + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qoutflowst, transport_node, &out_flow_node); + axutil_qname_free(qoutflowst, env); + if(out_flow_element) + { + axis2_transport_in_desc_free(transport_in, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OUT_FLOW_NOT_ALLOWED_IN_TRS_IN, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Out flow element not allowed in transport in path"); + return AXIS2_FAILURE; + } + + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qinflowst, transport_node, &in_flow_node); + axutil_qname_free(qinflowst, env); + if(in_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + in_flow_element, axis2_conf_get_param_container(conf_builder->conf, env), + in_flow_node); + status = axis2_transport_in_desc_set_in_flow(transport_in, env, flow); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting in flow into transport_in_desc of transport " + "%s failed", name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + } + + qinfaultflowst = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qinfaultflowst, transport_node, &in_fault_flow_node); + axutil_qname_free(qinfaultflowst, env); + if(in_fault_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + in_fault_flow_element, axis2_conf_get_param_container(conf_builder->conf, env), + in_fault_flow_node); + status = axis2_transport_in_desc_set_fault_in_flow(transport_in, env, flow); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting in fault flow into transport_in_desc of " + "transport %s failed", name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + } + + qoutfaultflowst = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qoutfaultflowst, transport_node, &out_fault_flow_node); + if(out_fault_flow_element) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OUT_FLOW_NOT_ALLOWED_IN_TRS_IN, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Out flow element is not allowed in transport in path"); + return AXIS2_FAILURE; + } + + /* adding to axis config */ + status = axis2_conf_add_transport_in(conf_builder->conf, env, transport_in, + transport_enum); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding transport_in_desc for transport %s into main " + "configuration failed.", name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + + axutil_qname_free(qoutfaultflowst, env); + + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_transport_recvs"); + return AXIS2_SUCCESS; +} + +static axis2_status_t AXIS2_CALL +axis2_conf_builder_process_default_module_versions( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_versions) +{ + AXIS2_PARAM_CHECK(env->error, module_versions, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_versions, env)) + { + axiom_element_t *om_element = NULL; + axis2_char_t *name = NULL; + axis2_char_t *default_version = NULL; + axutil_qname_t *attribute_qname = NULL; + + om_element = (axiom_element_t *)axiom_children_qname_iterator_next(module_versions, env); + if(!om_element) + { + continue; + } + attribute_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + if(!attribute_qname) + { + continue; + } + name = axiom_element_get_attribute_value(om_element, env, attribute_qname); + axutil_qname_free(attribute_qname, env); + attribute_qname = NULL; + if(!name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Attribute value is NULL for " + "attribute %s", AXIS2_ATTNAME); + return AXIS2_FAILURE; + } + attribute_qname = axutil_qname_create(env, AXIS2_ATTRIBUTE_DEFAULT_VERSION, NULL, NULL); + if(!attribute_qname) + { + continue; + } + default_version = axiom_element_get_attribute_value(om_element, env, attribute_qname); + axutil_qname_free(attribute_qname, env); + attribute_qname = NULL; + if(!default_version) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Attribute value is NULL for " + "attribute %s", AXIS2_ATTRIBUTE_DEFAULT_VERSION); + return AXIS2_FAILURE; + } + axis2_conf_add_default_module_version(conf_builder->conf, env, name, default_version); + } + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/conf_init.c b/src/core/deployment/conf_init.c new file mode 100644 index 0000000..6a622b4 --- /dev/null +++ b/src/core/deployment/conf_init.c @@ -0,0 +1,460 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEFAULT_REPO_PATH "." + +axis2_status_t AXIS2_CALL +axis2_init_modules( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +static axis2_status_t AXIS2_CALL +axis2_load_services( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +axis2_status_t AXIS2_CALL +axis2_init_transports( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +static axis2_conf_ctx_t *AXIS2_CALL +axis2_build_conf_ctx_with_dep_engine( + const axutil_env_t * env, + axis2_dep_engine_t *dep_engine, + axis2_char_t *is_server_side) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axutil_property_t *property = NULL; + axis2_ctx_t *conf_ctx_base = NULL; + + conf = axis2_dep_engine_load(dep_engine, env); + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Loading deployment engine failed"); + axis2_dep_engine_free(dep_engine, env); + return NULL; + } + axis2_conf_set_dep_engine(conf, env, dep_engine); + + conf_ctx = axis2_conf_ctx_create(env, conf); + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating Axis2 configuration context failed."); + return NULL; + } + axis2_conf_ctx_set_root_dir(conf_ctx, env, axis2_dep_engine_get_repos_path(dep_engine, env)); + + conf_ctx_base = axis2_conf_ctx_get_base(conf_ctx, env); + property = axutil_property_create_with_args(env, 2, 0, 0, is_server_side); + axis2_ctx_set_property(conf_ctx_base, env, AXIS2_IS_SVR_SIDE, property); + + axis2_init_modules(env, conf_ctx); + axis2_init_transports(env, conf_ctx); + + if(!axutil_strcmp(is_server_side, AXIS2_VALUE_TRUE)) + { + axis2_load_services(env, conf_ctx); + } + + return conf_ctx; +} + +AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL +axis2_build_conf_ctx( + const axutil_env_t * env, + const axis2_char_t * repo_name) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_build_conf_ctx"); + dep_engine = axis2_dep_engine_create_with_repos_name(env, repo_name); + if(!dep_engine) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating deployment engine failed for repository %s", repo_name); + return NULL; + } + + conf_ctx = axis2_build_conf_ctx_with_dep_engine(env, dep_engine, AXIS2_VALUE_TRUE); + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Loading configuration context failed for repository %s.", repo_name); + return NULL; + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_build_conf_ctx"); + return conf_ctx; +} + +AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL +axis2_build_conf_ctx_with_file( + const axutil_env_t * env, + const axis2_char_t * file) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_dep_engine_t *dep_engine = NULL; + axis2_char_t *repos_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *index = NULL; + axis2_char_t *xmlfile = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_build_conf_ctx_with_file"); + temp_path = axutil_strdup(env, file); + index = axutil_rindex(temp_path, AXIS2_PATH_SEP_CHAR); + if(!index) + {/* searching from windows specific path seperator */ + index = axutil_rindex(temp_path, '\\'); + } + + if(!index) + { + /** only the xml file name is provided. Assume the default repo path */ + repos_path = AXIS2_GETENV("AXIS2C_HOME"); + xmlfile = (axis2_char_t*)file; + }else + { + xmlfile = index+1; + temp_path[index-temp_path] = '\0'; + repos_path = temp_path; + } + + dep_engine = axis2_dep_engine_create_with_repos_name_and_svr_xml_file(env, repos_path, xmlfile); + if(!dep_engine) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating deployment engine for given Axis2 configuration file" + "(axis2.xml) failed"); + return NULL; + } + + conf_ctx = axis2_build_conf_ctx_with_dep_engine(env, dep_engine, AXIS2_VALUE_TRUE); + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Loading configuration context failed for given Axis2 configuration %s.", file); + return NULL; + } + AXIS2_FREE(env->allocator, temp_path); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_build_conf_ctx_with_file"); + return conf_ctx; +} + +axis2_conf_ctx_t *AXIS2_CALL +axis2_build_client_conf_ctx( + const axutil_env_t * env, + const axis2_char_t * axis2_home) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_dep_engine_t *dep_engine = NULL; + axis2_conf_t *conf = NULL; + axutil_property_t *property = NULL; + axis2_ctx_t *conf_ctx_base = NULL; + + axis2_status_t status; + unsigned int len = 0; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_build_client_conf_ctx"); + /* Building conf using axis2.xml, in that case we check whether + * last 9 characters of the axis2_home equals to the "axis2.xml" + * else treat it as a directory + */ + + status = axutil_file_handler_access (axis2_home, AXIS2_R_OK); + if (status == AXIS2_SUCCESS) + { + len = (int)strlen (axis2_home); + /* We are sure that the difference lies within the int range */ + if ((len >= 9) && + !strcmp ((axis2_home + (len - 9)), "axis2.xml")) + { + dep_engine = axis2_dep_engine_create_with_axis2_xml (env, + axis2_home); + } + else + { + dep_engine = axis2_dep_engine_create(env); + } + } + else + { + AXIS2_LOG_WARNING (env->log, AXIS2_LOG_SI, + "Provided client repository path %s does not exsist or no "\ + "permission to read, therefore set axis2c home to DEFAULT_REPO_PATH.", + axis2_home); + axis2_home = DEFAULT_REPO_PATH; + dep_engine = axis2_dep_engine_create(env); + } + if (!dep_engine) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating deployment engine for client repository %s failed." , + axis2_home); + return NULL; + } + conf = axis2_dep_engine_load_client(dep_engine, env, axis2_home); + if (!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Loading deployment engine failed for client repository %s", + axis2_home); + axis2_dep_engine_free(dep_engine, env); + return NULL; + } + axis2_conf_set_dep_engine(conf, env, dep_engine); + + conf_ctx = axis2_conf_ctx_create(env, conf); + if (!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating Axis2 configuration context failed"); + return NULL; + } + axis2_conf_ctx_set_root_dir(conf_ctx, env, axis2_dep_engine_get_repos_path(dep_engine, env)); + + conf_ctx_base = axis2_conf_ctx_get_base(conf_ctx, env); + property = axutil_property_create_with_args(env, 2, 0, 0, AXIS2_VALUE_FALSE); + axis2_ctx_set_property(conf_ctx_base, env, AXIS2_IS_SVR_SIDE, property); + + axis2_init_modules(env, conf_ctx); + axis2_init_transports(env, conf_ctx); + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_build_client_conf_ctx"); + return conf_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_init_modules( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_conf_t *conf = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_init_modules"); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axutil_hash_t *module_map = axis2_conf_get_all_modules(conf, env); + if(module_map) + { + axutil_hash_index_t *hi = NULL; + void *module = NULL; + for(hi = axutil_hash_first(module_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &module); + if(module) + { + axis2_module_desc_t *mod_desc = (axis2_module_desc_t *)module; + if(mod_desc) + { + axis2_module_t *mod = axis2_module_desc_get_module(mod_desc, env); + if(mod) + { + axis2_module_init(mod, env, conf_ctx, mod_desc); + } + } + } + } + } + status = AXIS2_SUCCESS; + } + else + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "Retrieving Axis2 configuration from Axis2 configuration context " + "failed. Initializing modules failed"); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_init_modules"); + return status; +} + +static axis2_status_t AXIS2_CALL +axis2_load_services( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_conf_t *conf = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *svc_map = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_load_services"); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(!conf) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "Retrieving Axis2 configuration from Axis2 " + "configuration context failed, Loading services failed"); + return status; + } + + svc_map = axis2_conf_get_all_svcs_to_load(conf, env); + if(svc_map) + { + axutil_hash_index_t *hi = NULL; + void *svc = NULL; + for(hi = axutil_hash_first(svc_map, env); hi; hi = axutil_hash_next(env, hi)) + { + void *impl_class = NULL; + axutil_hash_t *ops_hash = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axutil_hash_this(hi, NULL, NULL, &svc); + if(!svc) + { + continue; + } + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + continue; + + ops_hash = axis2_svc_get_all_ops(svc, env); + if(ops_hash) + { + axutil_hash_index_t *op_hi = NULL; + void *op = NULL; + op_hi = axutil_hash_first(ops_hash, env); + if(op_hi) + { + axutil_hash_this(op_hi, NULL, NULL, &op); + if(op) + { + msg_recv = axis2_op_get_msg_recv(op, env); + if(msg_recv) + { + axis2_msg_recv_set_conf_ctx(msg_recv, env, conf_ctx); + axis2_msg_recv_load_and_init_svc(msg_recv, env, svc); + } + } + } + + } + /* + svc_desc = (axis2_svc_t *)svc; + if(!svc_desc) + { + continue; + } + + svc_name = axis2_svc_get_name(svc_desc, env); + impl_info_param = axis2_svc_get_param(svc_desc, env, AXIS2_SERVICE_CLASS); + + if(!impl_info_param) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid state of the service %s", svc_name); + return AXIS2_FAILURE; + } + axutil_class_loader_init(env); + impl_class = axutil_class_loader_create_dll(env, impl_info_param); + if(!impl_class) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service %s could not be loaded", svc_name); + return AXIS2_FAILURE; + } + + axis2_svc_set_impl_class(svc_desc, env, impl_class); + if(AXIS2_SVC_SKELETON_INIT_WITH_CONF((axis2_svc_skeleton_t *)impl_class, env, conf) + != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Initialization failed for the service %s. " + "Check the service's init_with_conf() function for errors and retry", svc_name); + } + */ + + } + } + status = AXIS2_SUCCESS; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_load_services"); + return status; +} + +axis2_status_t AXIS2_CALL +axis2_init_transports( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_conf_t *conf = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_init_transports"); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axis2_transport_in_desc_t **transport_in_map = NULL; + axis2_transport_out_desc_t **transport_out_map = NULL; + int i = 0; + + transport_in_map = axis2_conf_get_all_in_transports(conf, env); + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + if(transport_in_map[i]) + { + axis2_transport_receiver_t *listener = axis2_transport_in_desc_get_recv( + transport_in_map[i], env); + if(listener) + { + status = axis2_transport_receiver_init(listener, env, conf_ctx, + transport_in_map[i]); + } + } + } + + transport_out_map = axis2_conf_get_all_out_transports(conf, env); + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + if(transport_out_map[i]) + { + axis2_transport_sender_t *sender = axis2_transport_out_desc_get_sender( + transport_out_map[i], env); + if(sender) + { + status = AXIS2_TRANSPORT_SENDER_INIT(sender, env, conf_ctx, + transport_out_map[i]); + } + } + } + status = AXIS2_SUCCESS; + } + else + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "Retrieving Axis2 configuration from Axis2 configuration context " + "failed. Initializing transports failed"); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_init_transports"); + return status; +} + diff --git a/src/core/deployment/dep_engine.c b/src/core/deployment/dep_engine.c new file mode 100644 index 0000000..2c43380 --- /dev/null +++ b/src/core/deployment/dep_engine.c @@ -0,0 +1,1988 @@ +/* + * 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. + */ + +#include "axis2_dep_engine.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_dep_engine +{ + axis2_arch_file_data_t *curr_file; + axis2_arch_reader_t *arch_reader; + + /** + * To keep a reference to engine configuration. + * This reference will pass to engine when it call start() + * function + */ + axis2_conf_t *conf; + axis2_char_t *axis2_repos; + axis2_bool_t hot_dep; /* to do hot deployment or not */ + axis2_bool_t hot_update; /* to do hot update or not */ + + /* Whether dep_engine built using axis2.xml */ + axis2_bool_t file_flag; + + /** + * This will store all the web services to deploy + */ + axutil_array_list_t *ws_to_deploy; + + /** + * This will store all the web services to undeploy + */ + axutil_array_list_t *ws_to_undeploy; + axis2_phases_info_t *phases_info; /* To store phases list in axis2.xml */ + + axis2_char_t *folder_name; + + /** + * Module directory, dep_engine holds in the module build scenario. + */ + axis2_char_t *module_dir; + + /** + * Services directory, services are avialble in services directory + */ + + axis2_char_t *svc_dir; + + /** + * Full path to the server xml file(axis2.xml) + */ + axis2_char_t *conf_name; + + /** + * To store the module specified in the server.xml(axis2.xml) at the + * document parsing time + */ + axutil_array_list_t *module_list; + axis2_repos_listener_t *repos_listener; /*Added this here to help with freeing + memory allocated for this - Samisa */ + axis2_conf_builder_t *conf_builder; + axis2_svc_builder_t *svc_builder; + axutil_array_list_t *desc_builders; + axutil_array_list_t *module_builders; + axutil_array_list_t *svc_builders; + axutil_array_list_t *svc_grp_builders; +}; + +static axis2_status_t +axis2_dep_engine_set_dep_features( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + +static axis2_status_t +axis2_dep_engine_check_client_home( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home); + +static axis2_status_t +axis2_dep_engine_engage_modules( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + +static axis2_status_t +axis2_dep_engine_validate_system_predefined_phases( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + +static axis2_status_t +axis2_dep_engine_add_new_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_grp_t * svc_metadata); + +static axis2_status_t +axis2_dep_engine_load_module_dll( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_desc); + +static axis2_status_t +axis2_dep_engine_add_module_flow_handlers( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_flow_t * flow, + axutil_hash_t * handler_create_func_map); + +static axis2_status_t +axis2_dep_engine_add_new_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_metadata); + +static axis2_char_t * +axis2_dep_engine_get_axis_svc_name( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * file_name); + +static axis2_status_t +axis2_dep_engine_set_svc_and_module_dir_path( + axis2_dep_engine_t *dep_engine, + const axutil_env_t *env); + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create( + const axutil_env_t * env) +{ + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + dep_engine = (axis2_dep_engine_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_dep_engine_t)); + + if(!dep_engine) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + dep_engine = (axis2_dep_engine_t *)memset(dep_engine, 0, sizeof(axis2_dep_engine_t)); + dep_engine->curr_file = NULL; + dep_engine->arch_reader = NULL; + dep_engine->conf = NULL; + dep_engine->axis2_repos = NULL; + dep_engine->ws_to_deploy = NULL; + dep_engine->ws_to_undeploy = NULL; + dep_engine->phases_info = NULL; + dep_engine->folder_name = NULL; + dep_engine->module_dir = NULL; + dep_engine->svc_dir = NULL; + dep_engine->conf_name = NULL; + dep_engine->module_list = NULL; + dep_engine->repos_listener = NULL; + dep_engine->conf_builder = NULL; + dep_engine->svc_builder = NULL; + dep_engine->desc_builders = NULL; + dep_engine->module_builders = NULL; + dep_engine->svc_builders = NULL; + dep_engine->svc_grp_builders = NULL; + + dep_engine->ws_to_deploy = axutil_array_list_create(env, 0); + if(!(dep_engine->ws_to_deploy)) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + dep_engine->desc_builders = axutil_array_list_create(env, 0); + dep_engine->module_builders = axutil_array_list_create(env, 0); + dep_engine->svc_builders = axutil_array_list_create(env, 0); + dep_engine->svc_grp_builders = axutil_array_list_create(env, 0); + + dep_engine->phases_info = axis2_phases_info_create(env); + if(!(dep_engine->phases_info)) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_repos_name( + const axutil_env_t * env, + const axis2_char_t * repos_path) +{ + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create_with_repos_name_and_svr_xml_file( + env, repos_path, AXIS2_SERVER_XML_FILE); + + if(!dep_engine) + { + return NULL; + } + + dep_engine->file_flag = AXIS2_FALSE; + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_axis2_xml( + const axutil_env_t * env, + const axis2_char_t * axis2_xml) +{ + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create_with_svr_xml_file(env, axis2_xml); + if(!dep_engine) + { + return NULL; + } + dep_engine->file_flag = AXIS2_TRUE; + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_repos_name_and_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * repos_path, + const axis2_char_t * svr_xml_file) +{ + axis2_dep_engine_t *dep_engine = NULL; + axis2_char_t *conf_file_l = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, repos_path, NULL); + AXIS2_PARAM_CHECK(env->error, svr_xml_file, NULL); + if(!axutil_strcmp("", repos_path)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Repository path cannot be empty"); + return NULL; + } + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create(env); + + if(!dep_engine) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + status = axutil_file_handler_access(repos_path, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPOSITORY_NOT_EXIST, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Repository path %s does not exist", repos_path); + return NULL; + } + + dep_engine->folder_name = axutil_strdup(env, repos_path); + if(!dep_engine->folder_name) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + dep_engine->axis2_repos = axutil_strdup(env, repos_path); + if(!dep_engine->axis2_repos) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + conf_file_l = axutil_stracat(env, repos_path, AXIS2_PATH_SEP_STR); + dep_engine->conf_name = axutil_stracat(env, conf_file_l, svr_xml_file); + + AXIS2_FREE(env->allocator, conf_file_l); + if(!dep_engine->conf_name) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name cannot be NULL"); + return NULL; + } + + status = axutil_file_handler_access(dep_engine->conf_name, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name not found"); + return NULL; + } + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * svr_xml_file) +{ + axis2_dep_engine_t *dep_engine = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, svr_xml_file, NULL); + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create(env); + + if(!dep_engine) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + dep_engine->conf_name = axutil_strdup(env, (axis2_char_t *)svr_xml_file); + if(!dep_engine->conf_name) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name cannot be NULL"); + return NULL; + } + status = axutil_file_handler_access(dep_engine->conf_name, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name not found"); + return NULL; + } + + return dep_engine; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_dep_engine_free( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + if(!dep_engine) + { + return; + } + + if(dep_engine->curr_file) + { + axis2_arch_file_data_free(dep_engine->curr_file, env); + } + + if(dep_engine->phases_info) + { + axis2_phases_info_free(dep_engine->phases_info, env); + } + + if(dep_engine->conf_builder) + { + axis2_conf_builder_free(dep_engine->conf_builder, env); + } + + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + } + + if(dep_engine->svc_builder) + { + axis2_svc_builder_free(dep_engine->svc_builder, env); + } + + if(dep_engine->ws_to_deploy) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->ws_to_deploy, env); + for(i = 0; i < size; i++) + { + axis2_arch_file_data_t *file_data = NULL; + + file_data = (axis2_arch_file_data_t *)axutil_array_list_get(dep_engine->ws_to_deploy, + env, i); + + axis2_arch_file_data_free(file_data, env); + } + + axutil_array_list_free(dep_engine->ws_to_deploy, env); + dep_engine->ws_to_deploy = NULL; + } + + if(dep_engine->desc_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->desc_builders, env); + for(i = 0; i < size; i++) + { + axis2_desc_builder_t *desc_builder = NULL; + + desc_builder = (axis2_desc_builder_t *)axutil_array_list_get(dep_engine->desc_builders, + env, i); + + axis2_desc_builder_free(desc_builder, env); + } + + axutil_array_list_free(dep_engine->desc_builders, env); + } + + if(dep_engine->module_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->module_builders, env); + for(i = 0; i < size; i++) + { + axis2_module_builder_t *module_builder = NULL; + + module_builder = (axis2_module_builder_t *)axutil_array_list_get( + dep_engine->module_builders, env, i); + + axis2_module_builder_free(module_builder, env); + } + + axutil_array_list_free(dep_engine->module_builders, env); + } + + if(dep_engine->svc_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->svc_builders, env); + for(i = 0; i < size; i++) + { + axis2_svc_builder_t *svc_builder = NULL; + + svc_builder = (axis2_svc_builder_t *)axutil_array_list_get(dep_engine->svc_builders, + env, i); + + axis2_svc_builder_free(svc_builder, env); + } + + axutil_array_list_free(dep_engine->svc_builders, env); + } + + if(dep_engine->svc_grp_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->svc_grp_builders, env); + for(i = 0; i < size; i++) + { + axis2_svc_grp_builder_t *svc_grp_builder = NULL; + + svc_grp_builder = (axis2_svc_grp_builder_t *)axutil_array_list_get( + dep_engine->svc_grp_builders, env, i); + + axis2_svc_grp_builder_free(svc_grp_builder, env); + } + + axutil_array_list_free(dep_engine->svc_grp_builders, env); + } + + if(dep_engine->ws_to_undeploy) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->ws_to_undeploy, env); + + for(i = 0; i < size; i++) + { + axis2_arch_file_data_t *file_data = NULL; + + file_data = (axis2_arch_file_data_t *)axutil_array_list_get(dep_engine->ws_to_undeploy, + env, i); + + axis2_arch_file_data_free(file_data, env); + } + + axutil_array_list_free(dep_engine->ws_to_undeploy, env); + dep_engine->ws_to_undeploy = NULL; + } + + if(dep_engine->module_list) + { + int size = 0; + int i = 0; + + size = axutil_array_list_size(dep_engine->module_list, env); + + for(i = 0; i < size; i++) + { + axutil_qname_t *qname = NULL; + qname = axutil_array_list_get(dep_engine->module_list, env, i); + if(qname) + { + axutil_qname_free(qname, env); + } + } + + axutil_array_list_free(dep_engine->module_list, env); + } + + if(dep_engine->folder_name) + { + AXIS2_FREE(env->allocator, dep_engine->folder_name); + } + + if(dep_engine->conf_name) + { + AXIS2_FREE(env->allocator, dep_engine->conf_name); + } + + if(dep_engine->axis2_repos) + { + AXIS2_FREE(env->allocator, dep_engine->axis2_repos); + } + + if(dep_engine->repos_listener) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + } + + if(dep_engine) + { + AXIS2_FREE(env->allocator, dep_engine); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_qname) +{ + axutil_qname_t *qname = NULL; + + AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE); + + qname = axutil_qname_clone(module_qname, env); + if(!dep_engine->module_list) + { + dep_engine->module_list = axutil_array_list_create(env, 0); + if(!dep_engine->module_list) + { + axutil_qname_free(qname, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + } + return axutil_array_list_add(dep_engine->module_list, env, qname); +} + +struct axis2_module_desc *AXIS2_CALL +axis2_dep_engine_get_module( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_qname) +{ + AXIS2_PARAM_CHECK(env->error, module_qname, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + return axis2_conf_get_module(dep_engine->conf, env, module_qname); +} + +AXIS2_EXTERN struct axis2_arch_file_data *AXIS2_CALL +axis2_dep_engine_get_current_file_item( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->curr_file; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_ws_to_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_arch_file_data_t * file) +{ + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->ws_to_deploy, env, file); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_ws_to_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_ws_info_t * file) +{ + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + if(!(dep_engine->ws_to_undeploy)) + { + dep_engine->ws_to_undeploy = axutil_array_list_create(env, 0); + } + return axutil_array_list_add(dep_engine->ws_to_undeploy, env, file); +} + +AXIS2_EXTERN axis2_phases_info_t *AXIS2_CALL +axis2_dep_engine_get_phases_info( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->phases_info; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_dep_engine_get_axis_conf( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->conf; +} + +/** + * To set hot deployment and hot update + */ +static axis2_status_t +axis2_dep_engine_set_dep_features( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + axis2_char_t *value = NULL; + axutil_param_t *para_hot_dep = NULL; + axutil_param_t *para_hot_update = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + para_hot_dep = axis2_conf_get_param(dep_engine->conf, env, AXIS2_HOTDEPLOYMENT); + para_hot_update = axis2_conf_get_param(dep_engine->conf, env, AXIS2_HOTUPDATE); + + if(para_hot_dep) + { + value = (axis2_char_t *)axutil_param_get_value(para_hot_dep, env); + if(0 == axutil_strcasecmp(AXIS2_VALUE_FALSE, value)) + { + dep_engine->hot_dep = AXIS2_FALSE; + } + } + + if(para_hot_update) + { + value = (axis2_char_t *)axutil_param_get_value(para_hot_update, env); + if(0 == axutil_strcasecmp(AXIS2_VALUE_FALSE, value)) + { + dep_engine->hot_update = AXIS2_FALSE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_dep_engine_load( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_array_list_t *out_fault_phases = NULL; + + if(!dep_engine->conf_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_PATH_TO_CONFIG_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Path to axis2 configuration file is NULL. Unable to continue"); + return NULL; + } + + dep_engine->conf = axis2_conf_create(env); + if(!dep_engine->conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Allocation to configuration failed"); + return NULL; + } + + /* Set a flag to mark that conf is created using axis2 xml. To find out that conf is build using + * axis2 xml , this flag can be used. + */ + axis2_conf_set_axis2_flag(dep_engine->conf, env, dep_engine->file_flag); + axis2_conf_set_axis2_xml(dep_engine->conf, env, dep_engine->conf_name); + + dep_engine->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env, + dep_engine->conf_name, dep_engine, dep_engine->conf); + if(!(dep_engine->conf_builder)) + { + axis2_conf_free(dep_engine->conf, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Configuration builder creation failed"); + dep_engine->conf = NULL; + } + + /* Populate the axis2 configuration from reading axis2.xml. + */ + status = axis2_conf_builder_populate_conf(dep_engine->conf_builder, env); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Populating Axis2 Configuration failed"); + return NULL; + } + + status = axis2_dep_engine_set_svc_and_module_dir_path(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting service and module directory paths failed"); + return NULL; + } + + status = axis2_dep_engine_set_dep_features(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting deployment features failed"); + return NULL; + } + + if(dep_engine->repos_listener) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + } + + dep_engine->repos_listener = axis2_repos_listener_create_with_folder_name_and_dep_engine(env, + dep_engine->folder_name, dep_engine); + if(!dep_engine->repos_listener) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "dep_engine repos listener creation failed, folder name is %s", dep_engine->folder_name); + return NULL; + } + + axis2_conf_set_repo(dep_engine->conf, env, dep_engine->axis2_repos); + axis2_core_utils_calculate_default_module_version(env, axis2_conf_get_all_modules( + dep_engine->conf, env), dep_engine->conf); + + status = axis2_dep_engine_validate_system_predefined_phases(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Validating system predefined phases failed"); + return NULL; + } + + status = axis2_conf_set_phases_info(dep_engine->conf, env, dep_engine->phases_info); + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting phases info into Axis2 Configuration failed"); + return NULL; + } + + out_fault_phases = axis2_phases_info_get_op_out_faultphases(dep_engine->phases_info, env); + if(out_fault_phases) + { + status = axis2_conf_set_out_fault_phases(dep_engine->conf, env, out_fault_phases); + } + + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting out fault phases into Axis2 Configuratin failed"); + return NULL; + } + + status = axis2_dep_engine_engage_modules(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "dep engine failed to engaged_modules"); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, AXIS2_FAILURE); + return NULL; + } + + return dep_engine->conf; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_dep_engine_load_client( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home) +{ + axis2_bool_t is_repos_exist = AXIS2_FALSE; + axis2_status_t status = AXIS2_FAILURE; + axis2_bool_t flag = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, client_home, NULL); + + flag = axis2_dep_engine_get_file_flag(dep_engine, env); + + if(!flag) + { + dep_engine->axis2_repos = axutil_strdup(env, client_home); + if(!dep_engine->axis2_repos) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + if(client_home && axutil_strcmp("", client_home)) + { + status = axis2_dep_engine_check_client_home(dep_engine, env, client_home); + if(AXIS2_SUCCESS == status) + { + is_repos_exist = AXIS2_TRUE; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2.xml is not available in client repo %s ", client_home); + + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + + return NULL; + } + } + else + { + dep_engine->conf_name = axutil_strdup(env, AXIS2_CONFIGURATION_RESOURCE); + + if(!dep_engine->conf_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Axis2 Configuration file name cannot be NULL"); + return NULL; + } + } + } + + else + { + is_repos_exist = AXIS2_TRUE; + } + + dep_engine->conf = axis2_conf_create(env); + if(!dep_engine->conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Allocation for Axis2 Configuration failed"); + return NULL; + } + dep_engine->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env, + dep_engine->conf_name, dep_engine, dep_engine->conf); + + if(!(dep_engine->conf_builder)) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + } + + /** + Very important: Only after populating we will be able to access + parameters in axis2 xml. + */ + + axis2_conf_set_axis2_flag(dep_engine->conf, env, dep_engine->file_flag); + axis2_conf_set_axis2_xml(dep_engine->conf, env, dep_engine->conf_name); + + status = axis2_conf_builder_populate_conf(dep_engine->conf_builder, env); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Populating Axis2 Configuration failed"); + return NULL; + } + + status = axis2_dep_engine_set_svc_and_module_dir_path(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting service and module paths failed"); + return NULL; + } + + if(is_repos_exist) + { + dep_engine->hot_dep = AXIS2_FALSE; + dep_engine->hot_update = AXIS2_FALSE; + if(dep_engine->repos_listener) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + } + + dep_engine->repos_listener = axis2_repos_listener_create_with_folder_name_and_dep_engine( + env, dep_engine->folder_name, dep_engine); + } + + axis2_conf_set_repo(dep_engine->conf, env, dep_engine->axis2_repos); + axis2_core_utils_calculate_default_module_version(env, axis2_conf_get_all_modules( + dep_engine->conf, env), dep_engine->conf); + + axis2_conf_set_phases_info(dep_engine->conf, env, dep_engine->phases_info); + status = axis2_dep_engine_engage_modules(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Module engage failed for deployment engine"); + return NULL; + } + + return dep_engine->conf; +} + +static axis2_status_t +axis2_dep_engine_check_client_home( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home) +{ + axis2_char_t *path_l = NULL; + axis2_status_t status = AXIS2_FAILURE; + + dep_engine->folder_name = axutil_strdup(env, client_home); + if(!dep_engine->folder_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + path_l = axutil_stracat(env, client_home, AXIS2_PATH_SEP_STR); + dep_engine->conf_name = axutil_stracat(env, path_l, AXIS2_SERVER_XML_FILE); + AXIS2_FREE(env->allocator, path_l); + + if(!dep_engine->conf_name) + { + dep_engine->conf_name = axutil_strdup(env, AXIS2_CONFIGURATION_RESOURCE); + if(!dep_engine->conf_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name cannot be NULL"); + return AXIS2_FAILURE; + } + } + + status = axutil_file_handler_access(dep_engine->conf_name, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name not found"); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_dep_engine_engage_modules( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + int size = 0; + int i = 0; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + if(!dep_engine->module_list) + { + /* There are no modules */ + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No modules configured"); + return AXIS2_SUCCESS; + } + + size = axutil_array_list_size(dep_engine->module_list, env); + + for(i = 0; i < size; i++) + { + axutil_qname_t *qname = NULL; + qname = (axutil_qname_t *)axutil_array_list_get(dep_engine->module_list, env, i); + if(qname && dep_engine->conf) + { + status = axis2_conf_engage_module(dep_engine->conf, env, qname); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Engaging module %s to Axis2 Configuration failed", axutil_qname_get_localpart( + qname, env)); + + return status; + } + } + } + + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_dep_engine_validate_system_predefined_phases( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + axutil_array_list_t *in_phases = NULL; + axis2_char_t *phase0 = NULL; + axis2_char_t *phase1 = NULL; + axis2_char_t *phase2 = NULL; + axis2_char_t *phase3 = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + in_phases = axis2_phases_info_get_in_phases(dep_engine->phases_info, env); + if(in_phases) + { + phase0 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 0); + phase1 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 1); + phase2 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 2); + phase3 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 3); + } + + if((phase0 && 0 != axutil_strcmp(phase0, AXIS2_PHASE_TRANSPORT_IN)) || (phase1 && 0 + != axutil_strcmp(phase1, AXIS2_PHASE_PRE_DISPATCH)) || (phase2 && 0 != axutil_strcmp( + phase2, AXIS2_PHASE_DISPATCH)) || (phase3 && 0 != axutil_strcmp(phase3, + AXIS2_PHASE_POST_DISPATCH))) + { + AXIS2_ERROR_SET(env->error, AXI2_ERROR_INVALID_PHASE, AXIS2_FAILURE); + return AXIS2_SUCCESS; + } + + return AXIS2_SUCCESS; +} + +/* For each searvices belonging to the service group passed as parameter, + * 1) Modules defined to be engaged to passed service group are engaged. + * 2) Modules defined to be engaged to service are engaged. + * + * Then for each service operation modules defined to be engaged to that operation are engaged. + */ +static axis2_status_t +axis2_dep_engine_add_new_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_grp_t * svc_metadata) +{ + axutil_array_list_t *svcs = NULL; + int sizei = 0; + int i = 0; + + AXIS2_PARAM_CHECK(env->error, svc_metadata, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + svcs = axis2_arch_file_data_get_deployable_svcs(dep_engine->curr_file, env); + if(svcs) + { + sizei = axutil_array_list_size(svcs, env); + } + + for(i = 0; i < sizei; i++) + { + axis2_svc_t *svc = NULL; + axutil_file_t *file = NULL; + axutil_array_list_t *grp_modules = NULL; + axutil_array_list_t *list = NULL; + int sizej = 0; + int j = 0; + axutil_hash_t *ops = NULL; + axutil_hash_index_t *index_i = NULL; + axis2_char_t *file_name = NULL; + + svc = (axis2_svc_t *)axutil_array_list_get(svcs, env, i); + + file = axis2_arch_file_data_get_file(dep_engine->curr_file, env); + file_name = axutil_file_get_name(file, env); + axis2_svc_set_file_name(svc, env, file_name); + + /* Modules from service group */ + grp_modules = axis2_svc_grp_get_all_module_qnames(svc_metadata, env); + if(grp_modules) + { + sizej = axutil_array_list_size(grp_modules, env); + } + for(j = 0; j < sizej; j++) + { + axis2_module_desc_t *module_desc = NULL; + axutil_qname_t *qmodulename = NULL; + + qmodulename = (axutil_qname_t *)axutil_array_list_get(grp_modules, env, j); + module_desc = axis2_conf_get_module(dep_engine->conf, env, qmodulename); + if(module_desc) + { + axis2_svc_engage_module(svc, env, module_desc, dep_engine->conf); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid module reference taken from conf"); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + /* Modules from service */ + list = axis2_svc_get_all_module_qnames(svc, env); + sizej = axutil_array_list_size(list, env); + for(j = 0; j < sizej; j++) + { + axis2_module_desc_t *module_desc = NULL; + axutil_qname_t *qmodulename = NULL; + + qmodulename = (axutil_qname_t *)axutil_array_list_get(list, env, j); + module_desc = axis2_conf_get_module(dep_engine->conf, env, qmodulename); + if(module_desc) + { + axis2_status_t status = AXIS2_FAILURE; + status = axis2_svc_engage_module(svc, env, module_desc, dep_engine->conf); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Engaging module %s to service %s failed", axutil_qname_get_localpart( + qmodulename, env), file_name); + return status; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid module reference taken from conf"); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + ops = axis2_svc_get_all_ops(svc, env); + for(index_i = axutil_hash_first(ops, env); index_i; index_i + = axutil_hash_next(env, index_i)) + { + void *v = NULL; + axis2_op_t *op_desc = NULL; + axutil_array_list_t *modules = NULL; + int sizek = 0; + int k = 0; + + axutil_hash_this(index_i, NULL, NULL, &v); + op_desc = (axis2_op_t *)v; + + modules = axis2_op_get_all_module_qnames(op_desc, env); + if(modules) + { + sizek = axutil_array_list_size(modules, env); + } + for(k = 0; k < sizek; k++) + { + axutil_qname_t *module_qname = NULL; + axis2_module_desc_t *module = NULL; + + module_qname = (axutil_qname_t *)axutil_array_list_get(modules, env, k); + module = axis2_conf_get_module(dep_engine->conf, env, module_qname); + + if(module) + { + axis2_op_engage_module(op_desc, env, module, dep_engine->conf); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF_BY_OP, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module %s is not added to the Axis2 Configuration", + axutil_qname_get_localpart(module_qname, env)); + + return AXIS2_FAILURE; + } + } + } + + axis2_svc_grp_add_svc(svc_metadata, env, svc); + } + + return axis2_conf_add_svc_grp(dep_engine->conf, env, svc_metadata); +} + +/* Here we will load the actual module implementation dll using the class loader and store it in + * module description. + */ +static axis2_status_t +axis2_dep_engine_load_module_dll( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_desc) +{ + axis2_char_t *read_in_dll = NULL; + axis2_module_t *module = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axutil_file_t *module_folder = NULL; + AXIS2_TIME_T timestamp = 0; + axis2_char_t *module_folder_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *dll_path = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *dll_name = NULL; + + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + read_in_dll = axis2_arch_file_data_get_module_dll_name(dep_engine->curr_file, env); + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, read_in_dll); + + module_folder = axis2_arch_file_data_get_file(dep_engine->curr_file, env); + timestamp = axutil_file_get_timestamp(module_folder, env); + axutil_dll_desc_set_timestamp(dll_desc, env, timestamp); + module_folder_path = axutil_file_get_path(module_folder, env); + temp_path = axutil_stracat(env, module_folder_path, AXIS2_PATH_SEP_STR); + dll_path = axutil_stracat(env, temp_path, dll_name); + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "axis2_dep_engine_load_module_dll: DLL path is : %s", + dll_path); + status = axutil_dll_desc_set_name(dll_desc, env, dll_path); + if(AXIS2_SUCCESS != status) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting dll path %s to the dll description failed", dll_path); + + return AXIS2_FAILURE; + } + + /* Free all temp vars */ + AXIS2_FREE(env->allocator, temp_path); + temp_path = NULL; + AXIS2_FREE(env->allocator, dll_path); + dll_path = NULL; + + axutil_dll_desc_set_type(dll_desc, env, AXIS2_MODULE_DLL); + impl_info_param = axutil_param_create(env, read_in_dll, NULL); + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + module = (axis2_module_t *)axutil_class_loader_create_dll(env, impl_info_param); + + /* We cannot free the created impl_info_param here because by freeing + * so, it will free dll_desc which in turn unload the module. So we + * add this as a param to module_desc + */ + axis2_module_desc_add_param(module_desc, env, impl_info_param); + + return axis2_module_desc_set_module(module_desc, env, module); +} + +/* For each handler description of the module flow take the corresponding handler create function + * from handler_create_func_map and create the handler instance for the handler description. + */ +static axis2_status_t +axis2_dep_engine_add_module_flow_handlers( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_flow_t * flow, + axutil_hash_t * handler_create_func_map) +{ + int count = 0; + int j = 0; + + AXIS2_PARAM_CHECK(env->error, flow, AXIS2_FAILURE); + + count = axis2_flow_get_handler_count(flow, env); + + for(j = 0; j < count; j++) + { + axis2_handler_desc_t *handlermd = NULL; + axis2_handler_t *handler = NULL; + const axutil_string_t *handler_name = NULL; + AXIS2_HANDLER_CREATE_FUNC handler_create_func = NULL; + + handlermd = axis2_flow_get_handler(flow, env, j); + handler_name = axis2_handler_desc_get_name(handlermd, env); + handler_create_func = axutil_hash_get(handler_create_func_map, axutil_string_get_buffer( + handler_name, env), AXIS2_HASH_KEY_STRING); + + handler = handler_create_func(env, handler_name); + axis2_handler_init(handler, env, handlermd); + axis2_handler_desc_set_handler(handlermd, env, handler); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_dep_engine_get_handler_dll( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * class_name) +{ + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axis2_handler_t *handler = NULL; + axis2_char_t *dll_name = NULL; + + AXIS2_PARAM_CHECK(env->error, class_name, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + axutil_dll_desc_set_name(dll_desc, env, dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_HANDLER_DLL); + axutil_class_loader_init(env); + impl_info_param = axutil_param_create(env, NULL, NULL); + axutil_param_set_value(impl_info_param, env, dll_desc); + handler = (axis2_handler_t *)axutil_class_loader_create_dll(env, impl_info_param); + + return handler; +} + +/* Caller has module description filled with the information in module.xml by the time this + * function is called. Now it will load the actual module implementation and fill the module + * flows with the actual handler instances. Finally module description will be added into the + * configuration module list. + */ +static axis2_status_t +axis2_dep_engine_add_new_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_metadata) +{ + axis2_flow_t *in_flow = NULL; + axis2_flow_t *out_flow = NULL; + axis2_flow_t *in_fault_flow = NULL; + axis2_flow_t *out_fault_flow = NULL; + axis2_module_t *module = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axutil_qname_t *module_qname = NULL; + axis2_char_t *module_name = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + module_qname = axis2_module_desc_get_qname(module_metadata, env); + module_name = axutil_qname_get_localpart(module_qname, env); + status = axis2_dep_engine_load_module_dll(dep_engine, env, module_metadata); + + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Loading module description %s failed", module_name); + + return status; + } + + module = axis2_module_desc_get_module(module_metadata, env); + if(!module) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving module from module description %s failed", module_name); + + return AXIS2_FAILURE; + } + + /* Module implementor will provide functions for creating his handlers and by calling this + * function these function pointers will be stored in a hash map in the module. + */ + status = axis2_module_fill_handler_create_func_map(module, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Filling handler create function for module map %s failed", module_name); + return status; + } + + in_flow = axis2_module_desc_get_in_flow(module_metadata, env); + if(in_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_flow, + module->handler_create_func_map); + } + + out_flow = axis2_module_desc_get_out_flow(module_metadata, env); + if(out_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_flow, + module->handler_create_func_map); + } + + in_fault_flow = axis2_module_desc_get_fault_in_flow(module_metadata, env); + if(in_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_fault_flow, + module->handler_create_func_map); + } + + out_fault_flow = axis2_module_desc_get_fault_out_flow(module_metadata, env); + if(out_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_fault_flow, + module->handler_create_func_map); + } + + /* Add the module description into the axis2 configuration. Axis2 configuration will keep these + * handlers in a hash_map called all_modules. + */ + axis2_conf_add_module(dep_engine->conf, env, module_metadata); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_do_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + int size = 0; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + size = axutil_array_list_size(dep_engine->ws_to_deploy, env); + + if(size > 0) + { + int i = 0; + for(i = 0; i < size; i++) + { + int type = 0; + axis2_svc_grp_t *svc_grp = NULL; + axis2_char_t *file_name = NULL; + axis2_module_desc_t *meta_data = NULL; + + dep_engine->curr_file = (axis2_arch_file_data_t *)axutil_array_list_get( + dep_engine->ws_to_deploy, env, i); + + type = axis2_arch_file_data_get_type(dep_engine->curr_file, env); + switch(type) + { + case AXIS2_SVC: + { + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + } + + dep_engine->arch_reader = axis2_arch_reader_create(env); + svc_grp = axis2_svc_grp_create_with_conf(env, dep_engine->conf); + file_name = axis2_arch_file_data_get_name(dep_engine->curr_file, env); + status = axis2_arch_reader_process_svc_grp(dep_engine->arch_reader, env, + file_name, dep_engine, svc_grp); + + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing service group %s failed", file_name); + + return status; + } + + status = axis2_dep_engine_add_new_svc(dep_engine, env, svc_grp); + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding new service %s to the deployment engine failed", file_name); + + return status; + } + + dep_engine->curr_file = NULL; + break; + } + + case AXIS2_MODULE: + { + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + } + dep_engine->arch_reader = axis2_arch_reader_create(env); + meta_data = axis2_module_desc_create(env); + file_name = axis2_arch_file_data_get_name(dep_engine->curr_file, env); + status = axis2_arch_reader_read_module_arch(env, file_name, dep_engine, + meta_data); + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Reading module archive for file %s failed", file_name); + + return AXIS2_FAILURE; + } + + status = axis2_dep_engine_add_new_module(dep_engine, env, meta_data); + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE, AXIS2_FAILURE); + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding new module %s to the deployment engine failed", file_name); + + return AXIS2_FAILURE; + } + + dep_engine->curr_file = NULL; + break; + } + }; + + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + int size = 0; + axis2_char_t *svc_name = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + size = axutil_array_list_size(dep_engine->ws_to_undeploy, env); + + if(size > 0) + { + int i = 0; + for(i = 0; i < size; i++) + { + int type = 0; + axis2_ws_info_t *ws_info = NULL; + axutil_hash_t *faulty_svcs = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(dep_engine->ws_to_undeploy, env, i); + type = axis2_ws_info_get_type(ws_info, env); + if(type == AXIS2_SVC) + { + axis2_char_t *file_name = NULL; + + file_name = axis2_ws_info_get_file_name(ws_info, env); + svc_name = axis2_dep_engine_get_axis_svc_name(dep_engine, env, file_name); + + axis2_conf_remove_svc(dep_engine->conf, env, svc_name); + } + + faulty_svcs = axis2_conf_get_all_faulty_svcs(dep_engine->conf, env); + axutil_hash_set(faulty_svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL); + } + + } + + axutil_array_list_free(dep_engine->ws_to_undeploy, env); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_dep_engine_is_hot_update( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + return dep_engine->hot_update; +} + +static axis2_char_t * +axis2_dep_engine_get_axis_svc_name( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + axis2_char_t name_sep = '.'; + axis2_char_t *temp_name = NULL; + axis2_char_t *ptr = NULL; + axis2_char_t *file_name_l = NULL; + axis2_char_t *svc_name = NULL; + int len = 0; + + file_name_l = axutil_strdup(env, file_name); + ptr = AXIS2_STRRCHR(file_name_l, AXIS2_PATH_SEP_CHAR); + + temp_name = ptr + 1; + ptr = AXIS2_STRRCHR(temp_name, name_sep); + ptr[0] = '\0'; + len = (int)strlen(temp_name); + /* We are sure that the difference lies within the int range */ + svc_name = AXIS2_MALLOC(env->allocator, len + 1); + sscanf(temp_name, "%s", svc_name); + AXIS2_FREE(env->allocator, file_name_l); + + return svc_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_phases_info( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_phases_info_t * phases_info) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + dep_engine->phases_info = phases_info; + return AXIS2_SUCCESS; +} + +/** + * This method is used to fill a axis2 service instance using services.xml , + * first it should create an axis service instance and then fill that using + * given service.xml and load all the required class and build the chains , + * finally add the service context to engine context and axis2 service into + * Engine Configuration. + */ +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_dep_engine_build_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_t * svc, + axis2_char_t * file_name) +{ + axiom_node_t *node = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + dep_engine->curr_file = axis2_arch_file_data_create_with_type_and_name(env, AXIS2_SVC, ""); + + dep_engine->svc_builder = axis2_svc_builder_create_with_file_and_dep_engine_and_svc(env, + file_name, dep_engine, svc); + + node = axis2_desc_builder_build_om(axis2_svc_builder_get_desc_builder(dep_engine->svc_builder, + env), env); + + axis2_svc_builder_populate_svc(dep_engine->svc_builder, env, node); + + return svc; +} + +/** + * This function can be used to build Module Description for a given module + * archieve file. + */ +AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL +axis2_dep_engine_build_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_file_t * module_archive, + axis2_conf_t * conf) +{ + axis2_module_desc_t *module_desc = NULL; + axis2_module_t *module = NULL; + axis2_phases_info_t *phases_info = NULL; + axis2_arch_reader_t *arch_reader = NULL; + axis2_flow_t *in_flow = NULL; + axis2_flow_t *out_flow = NULL; + axis2_flow_t *in_fault_flow = NULL; + axis2_flow_t *out_fault_flow = NULL; + axis2_char_t *file_name = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, module_archive, NULL); + AXIS2_PARAM_CHECK(env->error, conf, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + phases_info = axis2_conf_get_phases_info(conf, env); + axis2_dep_engine_set_phases_info(dep_engine, env, phases_info); + dep_engine->curr_file = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_MODULE, + module_archive); + + module_desc = axis2_module_desc_create(env); + arch_reader = axis2_arch_reader_create(env); + file_name = axutil_file_get_name(module_archive, env); + status = axis2_arch_reader_read_module_arch(env, file_name, dep_engine, module_desc); + axis2_arch_reader_free(arch_reader, env); + if(AXIS2_SUCCESS != status) + { + axis2_module_desc_free(module_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Reading module archive for file %s failed", + file_name); + return NULL; + } + status = axis2_dep_engine_load_module_dll(dep_engine, env, module_desc); + if(AXIS2_SUCCESS != status) + { + axis2_module_desc_free(module_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Loading module dll %s failed", file_name); + return NULL; + } + + module = axis2_module_desc_get_module(module_desc, env); + + /* Module implementor will provide functions for creating his handlers and by calling this + * function these function pointers will be stored in a hash map in the module. + */ + axis2_module_fill_handler_create_func_map(module, env); + + in_flow = axis2_module_desc_get_in_flow(module_desc, env); + if(in_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_flow, + module->handler_create_func_map); + } + + out_flow = axis2_module_desc_get_out_flow(module_desc, env); + if(out_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_flow, + module->handler_create_func_map); + } + + in_fault_flow = axis2_module_desc_get_fault_in_flow(module_desc, env); + if(in_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_fault_flow, + module->handler_create_func_map); + } + + out_fault_flow = axis2_module_desc_get_fault_out_flow(module_desc, env); + if(out_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_fault_flow, + module->handler_create_func_map); + } + + dep_engine->curr_file = NULL; + + return module_desc; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_dep_engine_get_repos_path( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->folder_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_current_file_item( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_arch_file_data_t * file_data) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + if(dep_engine->curr_file) + { + axis2_arch_file_data_free(dep_engine->curr_file, env); + dep_engine->curr_file = NULL; + } + dep_engine->curr_file = file_data; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_arch_reader( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_arch_reader_t * arch_reader) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + } + dep_engine->arch_reader = arch_reader; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_module_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_builder_t * module_builder) +{ + AXIS2_PARAM_CHECK(env->error, module_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->module_builders, env, module_builder); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_svc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_builder_t * svc_builder) +{ + AXIS2_PARAM_CHECK(env->error, svc_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->svc_builders, env, svc_builder); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_svc_grp_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_grp_builder_t * svc_grp_builder) +{ + AXIS2_PARAM_CHECK(env->error, svc_grp_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->svc_grp_builders, env, svc_grp_builder); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_desc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_desc_builder * desc_builder) +{ + AXIS2_PARAM_CHECK(env->error, desc_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->desc_builders, env, desc_builder); +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_dep_engine_get_module_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return axutil_strdup(env, dep_engine->module_dir); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_module_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *module_dir) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_dir, AXIS2_FAILURE); + dep_engine->module_dir = axutil_strdup(env, module_dir); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_dep_engine_get_file_flag( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FALSE); + return dep_engine->file_flag; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_dep_engine_get_svc_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return axutil_strdup(env, dep_engine->svc_dir); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_svc_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *svc_dir) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_dir, AXIS2_FAILURE); + dep_engine->svc_dir = axutil_strdup(env, svc_dir); + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_dep_engine_set_svc_and_module_dir_path( + axis2_dep_engine_t *dep_engine, + const axutil_env_t *env) +{ + axis2_bool_t flag; + axis2_conf_t *conf; + axis2_char_t *dirpath; + axutil_param_t *dep_param; + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + flag = dep_engine->file_flag; + if(!flag) + { + return AXIS2_SUCCESS; + } + else + { + conf = dep_engine->conf; + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration cannot be NULL"); + return AXIS2_FAILURE; + } + + dep_param = axis2_conf_get_param(conf, env, AXIS2_MODULE_DIR); + if(dep_param) + { + dirpath = (axis2_char_t *)axutil_param_get_value(dep_param, env); + if(dirpath) + { + dep_engine->module_dir = dirpath; + dirpath = NULL; + } + } + dep_param = NULL; + + dep_param = axis2_conf_get_param(conf, env, AXIS2_SERVICE_DIR); + if(dep_param) + { + dirpath = (axis2_char_t *)axutil_param_get_value(dep_param, env); + if(dirpath) + { + dep_engine->svc_dir = dirpath; + dirpath = NULL; + } + } + } + + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/desc_builder.c b/src/core/deployment/desc_builder.c new file mode 100644 index 0000000..a6fde18 --- /dev/null +++ b/src/core/deployment/desc_builder.c @@ -0,0 +1,1148 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +struct axis2_desc_builder +{ + /** + * Store the full path to configuration file. + */ + axis2_char_t *file_name; + axiom_node_t *root; + struct axis2_dep_engine *engine; +}; + +static axis2_status_t +set_attrs_and_value( + axutil_param_t * param, + const axutil_env_t * env, + axiom_element_t * param_element, + axiom_node_t * param_node); + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_desc_builder_create( + const axutil_env_t * env) +{ + axis2_desc_builder_t *desc_builder = NULL; + + desc_builder = (axis2_desc_builder_t *)AXIS2_MALLOC(env-> allocator, + sizeof(axis2_desc_builder_t)); + + if(!desc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot allocate memory to desc_builder"); + return NULL; + } + desc_builder->file_name = NULL; + desc_builder->engine = NULL; + desc_builder->root = NULL; + + return desc_builder; +} + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_desc_builder_create_with_file_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * file_name, + axis2_dep_engine_t * engine) +{ + axis2_desc_builder_t *desc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + AXIS2_PARAM_CHECK(env->error, engine, NULL); + + desc_builder = (axis2_desc_builder_t *)axis2_desc_builder_create(env); + if(!desc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot allocate memory to desc_builder"); + return NULL; + } + + desc_builder->root = NULL; + + desc_builder->file_name = axutil_strdup(env, file_name); + if(!desc_builder->file_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot allocate memory to desc_builder->file_name"); + return NULL; + } + desc_builder->engine = engine; + + return desc_builder; +} + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_desc_builder_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine * engine) +{ + axis2_desc_builder_t *desc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, engine, NULL); + + desc_builder = (axis2_desc_builder_t *)axis2_desc_builder_create(env); + if(!desc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot allocate memory to desc_builder"); + return NULL; + } + + desc_builder->engine = engine; + + return desc_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_desc_builder_free( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env) +{ + if(desc_builder->file_name) + { + AXIS2_FREE(env->allocator, desc_builder->file_name); + } + + if(desc_builder->root) + { + axiom_node_free_tree(desc_builder->root, env); + } + + /* we cannot free deployment engine here */ + desc_builder->engine = NULL; + + if(desc_builder) + { + AXIS2_FREE(env->allocator, desc_builder); + } + return; +} + +AXIS2_EXTERN axiom_node_t *AXIS2_CALL +axis2_desc_builder_build_om( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env) +{ + axiom_xml_reader_t *reader = NULL; + axiom_document_t *document = NULL; + axiom_stax_builder_t *builder = NULL; + + if(!desc_builder->file_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_DESC_BUILDER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid state desc builder. Unable to continue"); + return NULL; + } + + /** create pull parser using the file path to configuration file */ + reader = axiom_xml_reader_create_for_file(env, desc_builder->file_name, NULL); + + if(!reader) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create xml reader for %s", + desc_builder->file_name); + return NULL; + }; + + /** create axiom_stax_builder by parsing pull_parser struct */ + builder = axiom_stax_builder_create(env, reader); + + if(!(builder)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Could not create xml stream reader for desc builder %s. Unable " + "to continue", desc_builder->file_name); + return NULL; + } + + /** + get the om document form builder + document is the container of om model created using builder + */ + document = axiom_stax_builder_get_document(builder, env); + + /** + * In description building we don't want defferred building. So build + * the whole tree at once + */ + axiom_document_build_all(document, env); + + /** + get root element , building starts hear + */ + desc_builder->root = axiom_document_get_root_element(document, env); + /** + We have built the whole document. So no need of keeping the builder. + */ + axiom_stax_builder_free_self(builder, env); + + return desc_builder->root; +} + +AXIS2_EXTERN axis2_flow_t *AXIS2_CALL +axis2_desc_builder_process_flow( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_element_t * flow_element, + axutil_param_container_t * parent, + axiom_node_t * flow_node) +{ + axis2_flow_t *flow = NULL; + axiom_children_qname_iterator_t *handlers = NULL; + axutil_qname_t *qchild = NULL; + + AXIS2_PARAM_CHECK(env->error, parent, NULL); + AXIS2_PARAM_CHECK(env->error, flow_node, NULL); + + flow = axis2_flow_create(env); + if(!flow) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Could not allocate to flow"); + return NULL; + } + + if(!flow_element) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "There is no flow element to process"); + return NULL; + } + + qchild = axutil_qname_create(env, AXIS2_HANDLERST, NULL, NULL); + handlers = axiom_element_get_children_with_qname(flow_element, env, qchild, flow_node); + if(qchild) + { + axutil_qname_free(qchild, env); + } + + while(axiom_children_qname_iterator_has_next(handlers, env)) + { + axiom_node_t *handler_node = NULL; + axis2_handler_desc_t *handler_desc = NULL; + axis2_status_t status = AXIS2_FAILURE; + + handler_node = (axiom_node_t *)axiom_children_qname_iterator_next(handlers, env); + + handler_desc = axis2_desc_builder_process_handler(desc_builder, env, handler_node, parent); + status = axis2_flow_add_handler(flow, env, handler_desc); + if(!status) + { + const axutil_string_t *handler_name = NULL; + const axis2_char_t *hname = NULL; + handler_name = axis2_handler_desc_get_name(handler_desc, env); + hname = axutil_string_get_buffer(handler_name, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding handler %s to flow failed", hname); + axis2_flow_free(flow, env); + return NULL; + } + } + return flow; +} + +struct axis2_handler_desc *AXIS2_CALL +axis2_desc_builder_process_handler( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * handler_node, + struct axutil_param_container *parent) +{ + axis2_handler_desc_t *handler_desc = NULL; + axiom_attribute_t *name_attrib = NULL; + axutil_qname_t *attr_qname = NULL; + axiom_attribute_t *class_attrib = NULL; + axutil_qname_t *class_qname = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *attrib_value = NULL; + axiom_element_t *handler_element = NULL; + axiom_node_t *order_node = NULL; + axiom_element_t *order_element = NULL; + axutil_qname_t *order_qname = NULL; + axutil_string_t *handler_name = NULL; + const axis2_char_t *hname = NULL; + + AXIS2_PARAM_CHECK(env->error, handler_node, NULL); + AXIS2_PARAM_CHECK(env->error, parent, NULL); + + handler_desc = axis2_handler_desc_create(env, NULL); + if(!handler_desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create handler description"); + return NULL; + } + /* Setting Handler name */ + attr_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + handler_element = axiom_node_get_data_element(handler_node, env); + name_attrib = axiom_element_get_attribute(handler_element, env, attr_qname); + if(attr_qname) + { + axutil_qname_free(attr_qname, env); + } + + if(!name_attrib) + { + axis2_handler_desc_free(handler_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Name attribute not fould for handler."); + return NULL; + } + else + { + axis2_char_t *value = NULL; + + value = axiom_attribute_get_value(name_attrib, env); + handler_name = axutil_string_create(env, value); + status = axis2_handler_desc_set_name(handler_desc, env, handler_name); + if(handler_name) + { + axutil_string_free(handler_name, env); + } + + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting name for handler description failed in %s", desc_builder->file_name); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + hname = axutil_string_get_buffer(handler_name, env); + /*Setting Handler Class name */ + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + class_attrib = axiom_element_get_attribute(handler_element, env, class_qname); + if(class_qname) + { + axutil_qname_free(class_qname, env); + } + + if(!class_attrib) + { + axis2_handler_desc_free(handler_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Library name attribute not found for handler %s", + hname); + return NULL; + } + else + { + attrib_value = axiom_attribute_get_value(class_attrib, env); + status = axis2_handler_desc_set_class_name(handler_desc, env, attrib_value); + } + + /*processing phase Rules (order) */ + + order_qname = axutil_qname_create(env, AXIS2_ORDER, NULL, NULL); + order_element = axiom_element_get_first_child_with_qname(handler_element, env, order_qname, + handler_node, &order_node); + if(order_qname) + { + axutil_qname_free(order_qname, env); + } + + if(!order_element || !order_node) + { + axis2_handler_desc_free(handler_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Order node not found for handler description %s", + hname); + return NULL; + } + else + { + axutil_hash_t *order_itr = NULL; + axiom_children_qname_iterator_t *params = NULL; + axutil_qname_t *param_qname = NULL; + axutil_hash_index_t *index_i = NULL; + + order_itr = axiom_element_get_all_attributes(order_element, env); + if(!order_itr) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Order element for handler desc %s does not contain any " + "attribute", hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + index_i = axutil_hash_first(order_itr, env); + + while(index_i) + { + axiom_attribute_t *order_attrib = NULL; + axutil_qname_t *qname = NULL; + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + void *v = NULL; + + axutil_hash_this(index_i, NULL, NULL, &v); + order_attrib = (axiom_attribute_t *)v; + qname = axiom_attribute_get_qname(order_attrib, env); + name = axutil_qname_get_localpart(qname, env); + + value = axiom_attribute_get_value(order_attrib, env); + if(!axutil_strcmp(AXIS2_AFTER, name)) + { + struct axis2_phase_rule *phase_rule = NULL; + + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_after(phase_rule, env, value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s phase rule failed for handler %s", AXIS2_AFTER, hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + if(!axutil_strcmp(AXIS2_BEFORE, name)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_before(phase_rule, env, value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s phase rule failed for handler %s", AXIS2_BEFORE, hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + if(!axutil_strcmp(AXIS2_PHASE, name)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_name(phase_rule, env, value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting phase rule name failed for handler %s", hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + if(!axutil_strcmp(AXIS2_PHASEFIRST, name)) + { + axis2_char_t *bool_val = NULL; + + bool_val = axis2_desc_builder_get_value(desc_builder, env, value); + if(!axutil_strcmp(bool_val, AXIS2_VALUE_TRUE)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_first(phase_rule, env, AXIS2_TRUE); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s property for phase rules for handler " + "%s failed", AXIS2_PHASEFIRST, hname); + axis2_handler_desc_free(handler_desc, env); + AXIS2_FREE(env->allocator, bool_val); + return NULL; + } + } + else if(!axutil_strcmp(bool_val, AXIS2_VALUE_FALSE)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_first(phase_rule, env, AXIS2_FALSE); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s property for phase rules for handler " + "%s failed", AXIS2_PHASEFIRST, hname); + axis2_handler_desc_free(handler_desc, env); + AXIS2_FREE(env->allocator, bool_val); + return NULL; + } + } + AXIS2_FREE(env->allocator, bool_val); + } + index_i = axutil_hash_next(env, index_i); + } + + param_qname = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params = axiom_element_get_children_with_qname(handler_element, env, param_qname, + handler_node); + axutil_qname_free(param_qname, env); + status = axis2_desc_builder_process_params(desc_builder, env, params, + axis2_handler_desc_get_param_container(handler_desc, env), parent); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing params failed for handler %s", + hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + + status = axis2_handler_desc_set_parent(handler_desc, env, parent); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting parent failed for handler %s", hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + return handler_desc; +} + +static axis2_status_t +set_attrs_and_value( + axutil_param_t * param, + const axutil_env_t * env, + axiom_element_t * param_element, + axiom_node_t * param_node) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *attrs = NULL; + axiom_child_element_iterator_t *childs = NULL; + + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, param_element, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, param_node, AXIS2_FAILURE); + + /* Setting attributes */ + attrs = axiom_element_extract_attributes(param_element, env, param_node); + if(attrs) + { + axutil_hash_index_t *i = NULL; + + for(i = axutil_hash_first(attrs, env); i; i = axutil_hash_next(env, i)) + { + void *v = NULL; + axiom_attribute_t *value = NULL; + axutil_generic_obj_t *obj = NULL; + axutil_qname_t *attr_qname = NULL; + axis2_char_t *attr_name = NULL; + + axutil_hash_this(i, NULL, NULL, &v); + if(!v) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Attibute missing in the parameter element"); + axutil_param_free(param, env); + return AXIS2_FAILURE; + } + obj = axutil_generic_obj_create(env); + if(!obj) + { + axutil_param_free(param, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + value = (axiom_attribute_t *)v; + axutil_generic_obj_set_value(obj, env, value); + axutil_generic_obj_set_free_func(obj, env, axiom_attribute_free_void_arg); + attr_qname = axiom_attribute_get_qname(value, env); + attr_name = axutil_qname_to_string(attr_qname, env); + axutil_hash_set(attrs, attr_name, AXIS2_HASH_KEY_STRING, obj); + } + axutil_param_set_attributes(param, env, attrs); + } + + childs = axiom_element_get_child_elements(param_element, env, param_node); + if(childs) + { + axutil_array_list_t *value_list = NULL; + + value_list = axutil_array_list_create(env, 0); + axutil_param_set_value_list(param, env, value_list); + + while(AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(childs, env)) + { + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + axutil_param_t *param = NULL; + axis2_char_t *pname = NULL; + + node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(childs, env); + element = axiom_node_get_data_element(node, env); + param = axutil_param_create(env, NULL, NULL); + pname = axiom_element_get_localname(element, env); + status = axutil_param_set_name(param, env, pname); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name to parameter failed"); + axutil_param_free(param, env); + return status; + } + axutil_param_set_param_type(param, env, AXIS2_DOM_PARAM); + set_attrs_and_value(param, env, element, node); + axutil_array_list_add(value_list, env, param); + } + } + else + { + axis2_char_t *para_test_value = NULL; + axis2_char_t *temp = NULL; + + temp = axiom_element_get_text(param_element, env, param_node); + para_test_value = axutil_strdup(env, temp); + status = axutil_param_set_value(param, env, para_test_value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting value to parameter failed"); + axutil_param_free(param, env); + AXIS2_FREE(env->allocator, para_test_value); + return status; + } + axutil_param_set_param_type(param, env, AXIS2_TEXT_PARAM); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_rest_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc) +{ + axiom_element_t *op_element = NULL; + axutil_qname_t *qname = NULL; + axutil_qname_t *param_qname = NULL; + axiom_node_t *rest_node = NULL; + axiom_element_t *rest_element = NULL; + axiom_children_qname_iterator_t *rest_mappings = NULL; + + AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); + + op_element = axiom_node_get_data_element(op_node, env); + + param_qname = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + + if(op_element) + { + rest_mappings + = axiom_element_get_children_with_qname(op_element, env, param_qname, op_node); + } + + while(rest_mappings && axiom_children_qname_iterator_has_next(rest_mappings, env)) + { + axis2_char_t *param_value = NULL; + rest_node = (axiom_node_t *)axiom_children_qname_iterator_next(rest_mappings, env); + rest_element = axiom_node_get_data_element(rest_node, env); + param_value = axiom_element_get_attribute_value(rest_element, env, qname); + if(!strcmp(param_value, AXIS2_REST_HTTP_METHOD)) + { + axis2_op_set_rest_http_method(op_desc, env, axiom_element_get_text(rest_element, env, + rest_node)); + } + param_value = axiom_element_get_attribute_value(rest_element, env, qname); + if(!strcmp(param_value, AXIS2_REST_HTTP_LOCATION)) + { + axis2_op_set_rest_http_location(op_desc, env, axiom_element_get_text(rest_element, env, + rest_node)); + } + if(axis2_op_get_rest_http_method(op_desc, env) && axis2_op_get_rest_http_location(op_desc, + env)) + { + break; + } + } + + axutil_qname_free(qname, env); + axutil_qname_free(param_qname, env); + return AXIS2_SUCCESS; +} + +/** + * Populate the Axis2 Operation with details from the actionMapping, + * outputActionMapping and faultActionMapping elements from the operation + * element. + * + * @param operation + * @param op_desc + */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_action_mappings( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc) +{ + axiom_element_t *op_element = NULL; + axutil_qname_t *qname = NULL; + axiom_children_qname_iterator_t *action_mappings = NULL; + axutil_array_list_t *mapping_list = axutil_array_list_create(env, 0); + AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); + + op_element = axiom_node_get_data_element(op_node, env); + qname = axutil_qname_create(env, AXIS2_ACTION_MAPPING, NULL, NULL); + if(op_element) + { + action_mappings = axiom_element_get_children_with_qname(op_element, env, qname, op_node); + } + + axutil_qname_free(qname, env); + qname = NULL; + if(!action_mappings) + { + if(mapping_list) + { + axutil_array_list_free(mapping_list, env); + mapping_list = NULL; + } + return AXIS2_SUCCESS; + } + while(axiom_children_qname_iterator_has_next(action_mappings, env)) + { + axiom_element_t *mapping_element = NULL; + axiom_node_t *mapping_node = NULL; + axis2_char_t *input_action_string = NULL; + axis2_char_t *temp_str = NULL; + + /* This is to check whether some one has locked the parmter at the top + * level + */ + mapping_node = (axiom_node_t *)axiom_children_qname_iterator_next(action_mappings, env); + mapping_element = axiom_node_get_data_element(mapping_node, env); + temp_str = axiom_element_get_text(mapping_element, env, mapping_node); + input_action_string = axutil_strtrim(env, temp_str, NULL); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Input action mapping found %s", + input_action_string); + if(axutil_strcmp("", input_action_string)) + { + axutil_array_list_add(mapping_list, env, input_action_string); + } + else + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Zero length " + "input_action_string found. Not added to the mapping list"); + } + } + axis2_op_set_wsamapping_list(op_desc, env, mapping_list); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * params, + axutil_param_container_t * param_container, + axutil_param_container_t * parent) +{ + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, params, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, param_container, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(params, env)) + { + axiom_element_t *param_element = NULL; + axiom_node_t *param_node = NULL; + axutil_param_t *param = NULL; + axutil_param_t *parent_para = NULL; + axiom_attribute_t *para_name = NULL; + axiom_attribute_t *para_locked = NULL; + axutil_qname_t *att_locked = NULL; + axutil_qname_t *att_qname = NULL; + axis2_char_t *pname = NULL; + + /* This is to check whether some one has locked the parmter at the top + * level + */ + param_node = (axiom_node_t *)axiom_children_qname_iterator_next(params, env); + param_element = axiom_node_get_data_element(param_node, env); + param = axutil_param_create(env, NULL, NULL); + + /* Setting paramter name */ + att_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + para_name = axiom_element_get_attribute(param_element, env, att_qname); + axutil_qname_free(att_qname, env); + if(!para_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Parameter name attribute not found for parameter"); + axutil_param_free(param, env); + return AXIS2_FAILURE; + } + pname = axiom_attribute_get_value(para_name, env); + status = axutil_param_set_name(param, env, pname); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not set parameter name for parameter"); + axutil_param_free(param, env); + return status; + } + + /* Setting paramter Value (the chiled elemnt of the paramter) */ + set_attrs_and_value(param, env, param_element, param_node); + + /* Setting locking attrib */ + att_locked = axutil_qname_create(env, AXIS2_ATTLOCKED, NULL, NULL); + para_locked = axiom_element_get_attribute(param_element, env, att_locked); + axutil_qname_free(att_locked, env); + if(parent) + { + axis2_char_t *param_name = NULL; + + param_name = axutil_param_get_name(param, env); + parent_para = axutil_param_container_get_param(parent, env, param_name); + } + if(para_locked) + { + axis2_char_t *locked_value = NULL; + locked_value = axiom_attribute_get_value(para_locked, env); + if(!axutil_strcmp(AXIS2_VALUE_TRUE, locked_value)) + { + axis2_char_t *param_name = NULL; + axis2_bool_t is_param_locked = AXIS2_FALSE; + /*if the parameter is locked at some level parameter value replace + * by that + */ + param_name = axutil_param_get_name(param, env); + is_param_locked = axutil_param_container_is_param_locked(parent, env, param_name); + if(parent && is_param_locked) + { + axutil_param_free(param, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked", param_name); + return AXIS2_FAILURE; + } + else + { + axutil_param_set_locked(param, env, AXIS2_TRUE); + } + } + else + { + axutil_param_set_locked(param, env, AXIS2_FALSE); + } + } + + if(parent) + { + axis2_char_t *name = NULL; + axis2_bool_t bvalue = AXIS2_FALSE; + + name = axutil_param_get_name(param, env); + bvalue = axutil_param_container_is_param_locked(parent, env, name); + if(parent_para || !bvalue) + { + status = axutil_param_container_add_param(param_container, env, param); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding parameter %s failed", name); + axutil_param_free(param, env); + return status; + } + } + } + else + { + status = axutil_param_container_add_param(param_container, env, param); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding parameter %s failed", pname); + axutil_param_free(param, env); + return status; + } + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_op_module_refs( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_op_t * op) +{ + axiom_element_t *moduleref = NULL; + axiom_attribute_t *module_ref_attrib = NULL; + axutil_qname_t *qref = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE); + + while(module_refs && axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_node_t *moduleref_node = axiom_children_qname_iterator_next(module_refs, env); + moduleref = (axiom_element_t *)axiom_node_get_data_element(moduleref_node, env); + + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_attrib = axiom_element_get_attribute(moduleref, env, qref); + axutil_qname_free(qref, env); + if(module_ref_attrib) + { + axis2_char_t *ref_name = NULL; + axutil_qname_t *ref_qname = NULL; + axis2_module_desc_t *module_desc = NULL; + + ref_name = axiom_attribute_get_value(module_ref_attrib, env); + ref_qname = axutil_qname_create(env, ref_name, NULL, NULL); + module_desc = axis2_dep_engine_get_module(desc_builder->engine, env, ref_qname); + if(!module_desc) + { + axutil_qname_free(ref_qname, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module %s not found in the deployment engine", ref_name); + + return AXIS2_FAILURE; + } + else + { + status = axis2_op_add_module_qname(op, env, ref_qname); + axutil_qname_free(ref_qname, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding module ref %s to operation %s failed", ref_name, + axutil_qname_get_localpart(axis2_op_get_qname(op, env), env)); + + return AXIS2_FAILURE; + } + } + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL +axis2_desc_builder_load_msg_recv( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + struct axiom_element * recv_element) +{ + axiom_attribute_t *recv_name = NULL; + axis2_char_t *class_name = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axutil_qname_t *class_qname = NULL; + axutil_param_t *impl_info_param = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axis2_char_t *repos_name = NULL; + axis2_char_t *dll_name = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *temp_path2 = NULL; + axis2_char_t *temp_path3 = NULL; + axis2_conf_t *conf = NULL; + axis2_char_t *msg_recv_dll_name = NULL; + + AXIS2_PARAM_CHECK(env->error, recv_element, NULL); + + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + recv_name = axiom_element_get_attribute(recv_element, env, class_qname); + axutil_qname_free(class_qname, env); + class_name = axiom_attribute_get_value(recv_name, env); + + conf = axis2_dep_engine_get_axis_conf(desc_builder->engine, env); + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Configuration not found in the deployment engine"); + return NULL; + } + impl_info_param = axis2_conf_get_param(conf, env, class_name); + + if(!impl_info_param) + { + dll_desc = axutil_dll_desc_create(env); + msg_recv_dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, + class_name); + repos_name = axis2_dep_engine_get_repos_path(desc_builder->engine, env); + temp_path = axutil_stracat(env, repos_name, AXIS2_PATH_SEP_STR); + temp_path2 = axutil_stracat(env, temp_path, AXIS2_LIB_FOLDER); + temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR); + dll_name = axutil_stracat(env, temp_path3, msg_recv_dll_name); + AXIS2_FREE(env->allocator, temp_path); + AXIS2_FREE(env->allocator, temp_path2); + AXIS2_FREE(env->allocator, temp_path3); + axutil_dll_desc_set_name(dll_desc, env, dll_name); + AXIS2_FREE(env->allocator, dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_MSG_RECV_DLL); + impl_info_param = axutil_param_create(env, class_name, NULL); + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + /* set the impl_info_param(which contain dll_desc as value) so that + * loaded msg_recv loader lib can be re-used in future + */ + axis2_conf_add_param(conf, env, impl_info_param); + } + + axutil_class_loader_init(env); + msg_recv = (axis2_msg_recv_t *)axutil_class_loader_create_dll(env, impl_info_param); + return msg_recv; +} + +AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL +axis2_desc_builder_load_default_msg_recv( + const axutil_env_t * env) +{ + axis2_msg_recv_t *msg_recv = NULL; + + msg_recv = axis2_raw_xml_in_out_msg_recv_create(env); + return msg_recv; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_desc_builder_get_short_file_name( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + const axis2_char_t *separator = NULL; + axis2_char_t *value = NULL; + axis2_char_t *file_name_l = NULL; + axis2_char_t *short_name = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + file_name_l = axutil_strdup(env, file_name); + if(!file_name_l) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + separator = "."; + + value = axutil_strstr(file_name_l, separator); + + value[0] = AXIS2_EOLN; + short_name = file_name_l; + + return short_name; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_desc_builder_get_file_name_without_prefix( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * short_file_name) +{ + axis2_char_t *file_name_l = NULL; + axis2_char_t *short_name = NULL; + int len = 0; + AXIS2_PARAM_CHECK(env->error, short_file_name, NULL); + file_name_l = axutil_strdup(env, short_file_name); + if(!file_name_l) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + len = axutil_strlen(AXIS2_LIB_PREFIX); + short_name = &file_name_l[len]; + return short_name; + +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_desc_builder_get_value( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * in) +{ + const axis2_char_t *separator = ":"; + axis2_char_t *value = NULL; + axis2_char_t *in_l = NULL; + + AXIS2_PARAM_CHECK(env->error, in, NULL); + + in_l = axutil_strdup(env, in); + if(!in_l) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + value = axutil_strstr(in_l, separator); + value = value + 1; + + return value; +} + +AXIS2_EXTERN struct axis2_dep_engine *AXIS2_CALL +axis2_desc_builder_get_dep_engine( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env) +{ + return desc_builder->engine; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_process_policy_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include) +{ + while(axiom_children_qname_iterator_has_next(iterator, env)) + { + axiom_node_t *node = NULL; + node = axiom_children_qname_iterator_next(iterator, env); + if(node) + { + axiom_element_t *element = NULL; + neethi_policy_t *policy = NULL; + + element = axiom_node_get_data_element(node, env); + policy = neethi_engine_get_policy(env, node, element); + if(!policy) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return AXIS2_FAILURE; + } + axis2_policy_include_add_policy_element(policy_include, env, type, policy); + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_process_policy_reference_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include) +{ + while(axiom_children_qname_iterator_has_next(iterator, env)) + { + axiom_node_t *node = NULL; + node = axiom_children_qname_iterator_next(iterator, env); + if(node) + { + axiom_element_t *element = NULL; + neethi_reference_t *reference = NULL; + + element = axiom_node_get_data_element(node, env); + /* TODO: add neethi_engine_get_policy_reference + reference = neethi_engine_get_policy_reference(env, node, element); */ + axis2_policy_include_add_policy_reference_element(policy_include, env, type, reference); + } + } + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/module_builder.c b/src/core/deployment/module_builder.c new file mode 100644 index 0000000..ad91866 --- /dev/null +++ b/src/core/deployment/module_builder.c @@ -0,0 +1,514 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_module_builder +{ + axis2_module_desc_t *module_desc; + struct axis2_desc_builder *desc_builder; +}; + +static axutil_array_list_t *AXIS2_CALL axis2_module_builder_process_ops( + axis2_module_builder_t * module_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr); + +AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL +axis2_module_builder_create( + const axutil_env_t * env) +{ + axis2_module_builder_t *module_builder = NULL; + + module_builder = (axis2_module_builder_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_module_builder_t)); + + if(!module_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory to create module builder"); + return NULL; + } + + return module_builder; +} + +AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL +axis2_module_builder_create_with_file_and_dep_engine_and_module( + const axutil_env_t * env, + axis2_char_t * file_name, + axis2_dep_engine_t * dep_engine, + axis2_module_desc_t * module_desc) +{ + axis2_module_builder_t *module_builder = NULL; + + module_builder = (axis2_module_builder_t *)axis2_module_builder_create(env); + if(!module_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory to create module builder %s", file_name); + return NULL; + } + module_builder->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, + file_name, dep_engine); + if(!module_builder->desc_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Description builder creation failed for module builder %s", file_name); + axis2_module_builder_free(module_builder, env); + return NULL; + } + module_builder->module_desc = module_desc; + return module_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_module_builder_free( + axis2_module_builder_t * module_builder, + const axutil_env_t * env) +{ + if(module_builder->desc_builder) + { + axis2_desc_builder_free(module_builder->desc_builder, env); + } + + if(module_builder) + { + AXIS2_FREE(env->allocator, module_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_module_builder_populate_module( + axis2_module_builder_t * module_builder, + const axutil_env_t * env) +{ + axiom_element_t *module_element = NULL; + axiom_node_t *module_node = NULL; + axutil_qname_t *qdllname = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qinfaultflow = NULL; + axutil_qname_t *qoutfaultflow = NULL; + axutil_qname_t *qopst = NULL; + axiom_attribute_t *module_dll_att = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *op_itr = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *in_fault_flow_element = NULL; + axiom_node_t *in_fault_flow_node = NULL; + axiom_element_t *out_fault_flow_element = NULL; + axiom_node_t *out_fault_flow_node = NULL; + axis2_conf_t *parent = NULL; + axutil_array_list_t *ops = NULL; + axutil_param_container_t *parent_container = NULL; + int size = 0; + int i = 0; + axis2_arch_file_data_t *file_data = NULL; + axis2_char_t *module_name = NULL; + axutil_qname_t *module_qname = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_module_builder_populate_module"); + + module_node = axis2_desc_builder_build_om(module_builder->desc_builder, env); + module_element = axiom_node_get_data_element(module_node, env); + if(!module_element) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Data element not found for the module node, Unable to proceed"); + return AXIS2_FAILURE; + } + file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine( + module_builder->desc_builder, env), env); + module_name = axis2_arch_file_data_get_module_name(file_data, env); + + module_qname = axutil_qname_create(env, module_name, NULL, NULL); + axis2_module_desc_set_qname(module_builder->module_desc, env, module_qname); + + if(module_qname) + { + axutil_qname_free(module_qname, env); + } + /* Setting Module Dll Name , if it is there */ + + qdllname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + module_dll_att = axiom_element_get_attribute(module_element, env, qdllname); + if(qdllname) + { + axutil_qname_free(qdllname, env); + } + + if(module_dll_att) + { + axis2_char_t *class_name = NULL; + + class_name = axiom_attribute_get_value(module_dll_att, env); + if(class_name && (axutil_strcmp("", class_name))) + { + axis2_dep_engine_t *dep_engine = axis2_desc_builder_get_dep_engine( + module_builder->desc_builder, env); + if(dep_engine) + { + axis2_arch_file_data_t *file_data = NULL; + + file_data = axis2_dep_engine_get_current_file_item(dep_engine, env); + axis2_arch_file_data_set_module_dll_name(file_data, env, class_name); + } + } + } + + /* Processing Paramters */ + /* Processing service level paramters */ + + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(module_element, env, qparamst, module_node); + if(qparamst) + { + axutil_qname_free(qparamst, env); + } + parent = axis2_module_desc_get_parent(module_builder->module_desc, env); + + if(parent) + { + parent_container = axis2_conf_get_param_container(parent, env); + } + axis2_desc_builder_process_params(module_builder->desc_builder, env, itr, + axis2_module_desc_get_param_container(module_builder->module_desc, env), parent_container); + + /* Process IN_FLOW */ + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname(module_element, env, qinflowst, + module_node, &in_flow_node); + if(qinflowst) + { + axutil_qname_free(qinflowst, env); + } + + if(in_flow_element && in_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, in_flow_element, + axis2_module_desc_get_param_container(module_builder->module_desc, env), in_flow_node); + status = axis2_module_desc_set_in_flow(module_builder->module_desc, env, flow); + + if(!status) + { + if(flow) + { + axis2_flow_free(flow, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting in flow failed for module desc %s", + module_name); + return status; + } + } + + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname(module_element, env, qoutflowst, + module_node, &out_flow_node); + if(qoutflowst) + { + axutil_qname_free(qoutflowst, env); + } + + if(out_flow_element && out_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, out_flow_element, + axis2_module_desc_get_param_container(module_builder->module_desc, env), out_flow_node); + status = axis2_module_desc_set_out_flow(module_builder->module_desc, env, flow); + + if(!status) + { + axis2_flow_free(flow, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting out flow failed for module desc %s", + module_name); + return status; + } + } + + qinfaultflow = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_fault_flow_element = axiom_element_get_first_child_with_qname(module_element, env, + qinfaultflow, module_node, &in_fault_flow_node); + if(qinfaultflow) + { + axutil_qname_free(qinfaultflow, env); + } + + if(in_fault_flow_element && NULL != in_fault_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, + in_fault_flow_element, axis2_module_desc_get_param_container( + module_builder->module_desc, env), in_fault_flow_node); + status = axis2_module_desc_set_fault_in_flow(module_builder->module_desc, env, flow); + + if(!status) + { + axis2_flow_free(flow, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting fault in flow failed for module desc %s", module_name); + return status; + } + } + + qoutfaultflow = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_fault_flow_element = axiom_element_get_first_child_with_qname(module_element, env, + qoutfaultflow, module_node, &out_fault_flow_node); + if(qoutfaultflow) + { + axutil_qname_free(qoutfaultflow, env); + } + + if(out_fault_flow_element && NULL != out_fault_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, + out_fault_flow_element, axis2_module_desc_get_param_container( + module_builder->module_desc, env), out_fault_flow_node); + status = axis2_module_desc_set_fault_out_flow(module_builder->module_desc, env, flow); + if(AXIS2_SUCCESS != status) + { + axis2_flow_free(flow, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting fault out flow failed for module desc %s", module_name); + return status; + } + } + + /* Processing Operations */ + qopst = axutil_qname_create(env, AXIS2_OPERATIONST, NULL, NULL); + op_itr = axiom_element_get_children_with_qname(module_element, env, qopst, module_node); + if(qopst) + { + axutil_qname_free(qopst, env); + } + ops = axis2_module_builder_process_ops(module_builder, env, op_itr); + size = axutil_array_list_size(ops, env); + for(i = 0; i < size; i++) + { + axis2_op_t *op_desc = NULL; + + op_desc = (axis2_op_t *)axutil_array_list_get(ops, env, i); + axis2_module_desc_add_op(module_builder->module_desc, env, op_desc); + } + axutil_array_list_free(ops, env); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_module_builder_populate_module"); + return AXIS2_SUCCESS; +} + +static axutil_array_list_t *AXIS2_CALL +axis2_module_builder_process_ops( + axis2_module_builder_t * module_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr) +{ + axutil_array_list_t *ops = NULL; + + AXIS2_PARAM_CHECK(env->error, op_itr, NULL); + + ops = axutil_array_list_create(env, 0); + while(axiom_children_qname_iterator_has_next(op_itr, env)) + { + axiom_element_t *op_element = NULL; + axiom_node_t *op_node = NULL; + axiom_attribute_t *op_name_att = NULL; + axiom_attribute_t *op_mep_att = NULL; + axutil_qname_t *qattname = NULL; + axis2_char_t *mep_url = NULL; + axis2_char_t *op_name = NULL; + axutil_qname_t *qopname = NULL; + axutil_qname_t *qmsgrecv = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qmep = NULL; + axiom_children_qname_iterator_t *params = NULL; + axiom_children_qname_iterator_t *modules = NULL; + axiom_element_t *recv_element = NULL; + axiom_node_t *recv_node = NULL; + axis2_phases_info_t *info = NULL; + axis2_op_t *op_desc = NULL; + axutil_qname_t *qpolicy = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + + op_node = (axiom_node_t *)axiom_children_qname_iterator_next(op_itr, env); + op_element = axiom_node_get_data_element(op_node, env); + /* getting operation name */ + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + op_name_att = axiom_element_get_attribute(op_element, env, qattname); + if(qattname) + { + axutil_qname_free(qattname, env); + } + + if(!op_name_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OP_NAME_MISSING, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation name missing for module operation."); + return NULL; + } + qmep = axutil_qname_create(env, AXIS2_MEP, NULL, NULL); + op_mep_att = axiom_element_get_attribute(op_element, env, qmep); + if(qmep) + { + axutil_qname_free(qmep, env); + } + + if(op_mep_att) + { + mep_url = axiom_attribute_get_value(op_mep_att, env); + } + if(!mep_url) + { + /* Assuming in-out mep */ + op_desc = axis2_op_create_from_module(env); + } + else + { + op_desc = axis2_op_create_from_module(env); + axis2_op_set_msg_exchange_pattern(op_desc, env, mep_url); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "mep_url:%s", mep_url); + } + + op_name = axiom_attribute_get_value(op_name_att, env); + qopname = axutil_qname_create(env, op_name, NULL, NULL); + axis2_op_set_qname(op_desc, env, qopname); + if(qopname) + { + axutil_qname_free(qopname, env); + } + + /* Operation parameters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params = axiom_element_get_children_with_qname(op_element, env, qparamst, op_node); + if(qparamst) + { + axutil_qname_free(qparamst, env); + } + + axis2_desc_builder_process_params(module_builder->desc_builder, env, params, + axis2_op_get_param_container(op_desc, env), axis2_module_desc_get_param_container( + module_builder->module_desc, env)); + /* To process wsamapping */ + axis2_desc_builder_process_action_mappings(module_builder->desc_builder, env, op_node, + op_desc); + + /* To process REST params */ + axis2_desc_builder_process_rest_params(module_builder->desc_builder, env, op_node, op_desc); + + /* setting the policy_include */ + + desc = axis2_op_get_base(op_desc, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + /* processing .. elements */ + + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + if(itr) + { + axis2_process_policy_elements(env, AXIS2_MODULE_OPERATION_POLICY, itr, policy_include); + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + + /* setting the mep of the operation */ + + /* loading the message receivers */ + qmsgrecv = axutil_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL); + recv_element = axiom_element_get_first_child_with_qname(op_element, env, qmsgrecv, op_node, + &recv_node); + if(qmsgrecv) + { + axutil_qname_free(qmsgrecv, env); + } + if(recv_element && NULL != recv_node) + { + axis2_msg_recv_t *msg_recv = NULL; + + msg_recv = axis2_desc_builder_load_msg_recv(module_builder-> desc_builder, env, + recv_element); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + } + else + { + axis2_msg_recv_t *msg_recv = NULL; + /* setting default message reciver */ + msg_recv = axis2_desc_builder_load_default_msg_recv(env); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + } + /* Process Module Refs */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + modules = axiom_element_get_children_with_qname(op_element, env, qmodulest, op_node); + if(qmodulest) + { + axutil_qname_free(qmodulest, env); + } + axis2_desc_builder_process_op_module_refs(module_builder->desc_builder, env, modules, + op_desc); + /* setting Operation phase */ + info = axis2_dep_engine_get_phases_info(axis2_desc_builder_get_dep_engine( + module_builder->desc_builder, env), env); + axis2_phases_info_set_op_phases(info, env, op_desc); + + /* adding operation */ + axutil_array_list_add(ops, env, op_desc); + } + return ops; +} + diff --git a/src/core/deployment/phases_info.c b/src/core/deployment/phases_info.c new file mode 100644 index 0000000..075fc8e --- /dev/null +++ b/src/core/deployment/phases_info.c @@ -0,0 +1,564 @@ +/* + * 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. + */ + +#include + +struct axis2_phases_info +{ + axutil_array_list_t *in_phases; + axutil_array_list_t *out_phases; + axutil_array_list_t *in_faultphases; + axutil_array_list_t *out_faultphases; + axutil_hash_t *op_in_phases; + axutil_hash_t *op_out_phases; + axutil_hash_t *op_in_faultphases; + axutil_hash_t *op_out_faultphases; + +}; + +AXIS2_EXTERN axis2_phases_info_t *AXIS2_CALL +axis2_phases_info_create( + const axutil_env_t * env) +{ + axis2_phases_info_t *phases_info = NULL; + + phases_info = (axis2_phases_info_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_phases_info_t)); + + if(!phases_info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)phases_info, 0, sizeof(axis2_phases_info_t)); + phases_info->op_in_phases = axutil_hash_make(env); + phases_info->op_out_phases = axutil_hash_make(env); + phases_info->op_in_faultphases = axutil_hash_make(env); + phases_info->op_out_faultphases = axutil_hash_make(env); + + return phases_info; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_phases_info_free( + axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + if(phases_info->in_phases) + { + axutil_array_list_free(phases_info->in_phases, env); + } + + if(phases_info->out_phases) + { + axutil_array_list_free(phases_info->out_phases, env); + } + + if(phases_info->in_faultphases) + { + axutil_array_list_free(phases_info->in_faultphases, env); + } + + if(phases_info->out_faultphases) + { + axutil_array_list_free(phases_info->out_faultphases, env); + } + + if(phases_info->op_in_phases) + { + axutil_hash_free(phases_info->op_in_phases, env); + } + + if(phases_info->op_out_phases) + { + axutil_hash_free(phases_info->op_out_phases, env); + } + + if(phases_info->op_in_faultphases) + { + axutil_hash_free(phases_info->op_in_faultphases, env); + } + + if(phases_info->op_out_faultphases) + { + axutil_hash_free(phases_info->op_out_faultphases, env); + } + + if(phases_info) + { + AXIS2_FREE(env->allocator, phases_info); + } + + return; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, in_phases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->in_phases) + { + axutil_array_list_free(phases_info->in_phases, env); + } + + phases_info->in_phases = in_phases; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, out_phases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->out_phases) + { + axutil_array_list_free(phases_info->out_phases, env); + phases_info->out_phases = NULL; + } + phases_info->out_phases = out_phases; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, in_faultphases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->in_faultphases) + { + axutil_array_list_free(phases_info->in_faultphases, env); + phases_info->in_faultphases = NULL; + } + phases_info->in_faultphases = in_faultphases; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, out_faultphases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->out_faultphases) + { + axutil_array_list_free(phases_info->out_faultphases, env); + phases_info->out_faultphases = NULL; + } + phases_info->out_faultphases = out_faultphases; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->in_phases; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->out_phases; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->in_faultphases; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->out_faultphases; +} + +/* Here we create the operation inflow as an array list and create phases for phases defined in + * inflow of axis2.xml and add them into the array list. + */ +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) +{ + struct axis2_phase *phase = NULL; + int i = 0; + int size = 0; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_in_phases = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + op_in_phases = axutil_array_list_create(env, 0); + if(!op_in_phases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + if(!phases_info->in_phases) + { + return op_in_phases; + } + + /* For each inflow phase name create a phase instance and add into the inflow. */ + size = axutil_array_list_size(phases_info->in_phases, env); + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->in_phases, env, i); + + if(!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name) || !axutil_strcmp( + AXIS2_PHASE_PRE_DISPATCH, phase_name) || !axutil_strcmp(AXIS2_PHASE_DISPATCH, + phase_name) || !axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) + { + /* We are not concerned here with system phases. */ + } + else + { + /* This is the cause for jira AXIS2C-624. As solution I create new + * phases for each operation specific flow making the operation + * the owner of the flow and the phases contained within it*/ + /*phase = axutil_hash_get(phases_info->op_in_phases, phase_name, + AXIS2_HASH_KEY_STRING); + if(!phase) + { + phase = axis2_phase_create(env, phase_name); + axutil_hash_set(phases_info->op_in_phases, phase_name, + AXIS2_HASH_KEY_STRING, phase); + } */ + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_in_phases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_in_phases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_in_phases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + axutil_array_list_free(op_in_phases, env); + op_in_phases = NULL; + return NULL; + } + } + } + + return op_in_phases; +} + +/* Here we create the operation outflow as an array list and create phases for phases defined in + * outflow of axis2.xml and add them into the array list. + */ +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) +{ + struct axis2_phase *phase = NULL; + int i = 0; + int size = 0; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_out_phases = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + if(phases_info->out_phases) + { + size = axutil_array_list_size(phases_info->out_phases, env); + } + + op_out_phases = axutil_array_list_create(env, 0); + if(!op_out_phases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->out_phases, env, i); + + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_out_phases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_out_phases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_out_phases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + + axutil_array_list_free(op_out_phases, env); + op_out_phases = NULL; + return NULL; + } + } + + return op_out_phases; +} + +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) +{ + int i = 0; + int size = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_in_faultphases = NULL; + struct axis2_phase *phase = NULL; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + if(!phases_info->in_faultphases) + { + return NULL; + } + + size = axutil_array_list_size(phases_info->in_faultphases, env); + if(0 == size) + { + return NULL; + } + + op_in_faultphases = axutil_array_list_create(env, 0); + if(!op_in_faultphases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->in_faultphases, env, i); + + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_in_faultphases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_in_faultphases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_in_faultphases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + axutil_array_list_free(op_in_faultphases, env); + op_in_faultphases = NULL; + return NULL; + + } + } + + return op_in_faultphases; +} + +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) +{ + int i = 0; + int size = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_out_faultphases = NULL; + struct axis2_phase *phase = NULL; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + if(!phases_info->out_faultphases) + { + return NULL; + } + size = axutil_array_list_size(phases_info->out_faultphases, env); + + if(0 == size) + { + return NULL; + } + + op_out_faultphases = axutil_array_list_create(env, 0); + if(!op_out_faultphases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->out_faultphases, env, i); + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_out_faultphases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_out_faultphases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_out_faultphases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + axutil_array_list_free(op_out_faultphases, env); + op_out_faultphases = NULL; + return NULL; + + } + } + + return op_out_faultphases; +} + +/* + * Get user defined phase instances for each flow defined in axis2.xml in an array list and add it + * into operation. This is called service builder, module builder and service client to add phases + * into operations. + */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phases_info_set_op_phases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axis2_op_t * op_desc) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_array_list_t *op_in_phases = NULL; + axutil_array_list_t *op_out_phases = NULL; + axutil_array_list_t *op_in_faultphases = NULL; + axutil_array_list_t *op_out_faultphases = NULL; + + AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + op_in_phases = axis2_phases_info_get_op_in_phases(phases_info, env); + if(!op_in_phases) + { + status = AXIS2_ERROR_GET_STATUS_CODE(env->error); + /* op_in_phases cannot be NULL */ + return status; + } + + op_out_phases = axis2_phases_info_get_op_out_phases(phases_info, env); + if(!op_out_phases) + { + status = AXIS2_ERROR_GET_STATUS_CODE(env->error); + /* op_out_phases cannot be NULL */ + return status; + } + + op_in_faultphases = axis2_phases_info_get_op_in_faultphases(phases_info, env); + op_out_faultphases = axis2_phases_info_get_op_out_faultphases(phases_info, env); + + status = axis2_op_set_in_flow(op_desc, env, op_in_phases); + status = axis2_op_set_out_flow(op_desc, env, op_out_phases); + if(op_in_faultphases) + { + status = axis2_op_set_fault_in_flow(op_desc, env, op_in_faultphases); + } + + if(op_out_faultphases) + { + status = axis2_op_set_fault_out_flow(op_desc, env, op_out_faultphases); + } + + return status; +} + +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) +{ + int size = 0, i = 0; + + axutil_array_list_t *new_flow = NULL; + if(flow_to_copy) + { + size = axutil_array_list_size((axutil_array_list_t *)flow_to_copy, env); + } + + if(size > 0) + { + new_flow = axutil_array_list_create(env, 0); + if(!new_flow) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + } + + for(i = 0; i < size; i++) + { + void *item = axutil_array_list_get((axutil_array_list_t *)flow_to_copy, env, i); + axis2_phase_increment_ref((axis2_phase_t *)item, env); + axutil_array_list_add(new_flow, env, item); + } + + return new_flow; +} + diff --git a/src/core/deployment/repos_listener.c b/src/core/deployment/repos_listener.c new file mode 100644 index 0000000..1df1325 --- /dev/null +++ b/src/core/deployment/repos_listener.c @@ -0,0 +1,398 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_repos_listener +{ + + /** + * Referance to a ws info list + */ + axis2_ws_info_list_t *info_list; + + /** + * The parent directory of the modules and services directories + * that the listener should listen + */ + axis2_char_t *folder_name; + axis2_conf_t *conf; +}; + +static axis2_status_t +axis2_repos_listener_search( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env, + axis2_char_t * folder_name, + int type); + +AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL +axis2_repos_listener_create( + const axutil_env_t * env) +{ + axis2_repos_listener_t *repos_listener = NULL; + + repos_listener = (axis2_repos_listener_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_repos_listener_t)); + + if(!repos_listener) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + repos_listener->folder_name = NULL; + repos_listener->info_list = NULL; + repos_listener->folder_name = AXIS2_FALSE; + + return repos_listener; +} + +/** + * This constructor take two argumnets, folder name and referance to + * deployment engine. Fisrt it initilize the sysetm , by loading all the + * modules in the /modules directory and also create a ws info list to + * keep info about available modules and services. + * @param folderName path to parent directory that the repos_listener + * should listens + * @param deploy_engine refearnce to engine registry inorder to + * inform the updates + */ + +AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL +axis2_repos_listener_create_with_folder_name_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * folder_name, + axis2_dep_engine_t * dep_engine) +{ + axis2_repos_listener_t *repos_listener = NULL; + axis2_status_t status = AXIS2_FAILURE; + + axis2_conf_t *conf; + axis2_bool_t file_flag; + + repos_listener = (axis2_repos_listener_t *)axis2_repos_listener_create(env); + + if(!repos_listener) + { + return NULL; + } + + file_flag = axis2_dep_engine_get_file_flag(dep_engine, env); + + if(!file_flag) + { + repos_listener->folder_name = axutil_strdup(env, folder_name); + if(!repos_listener->folder_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + } + + repos_listener->info_list = axis2_ws_info_list_create_with_dep_engine(env, dep_engine); + if(!repos_listener->info_list) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating ws info list failed"); + return NULL; + } + + /* Here dep_engine's conf will set to repo_listner. Then we could get + * details of the axis2.xml through axis2 configuration. + */ + + conf = axis2_dep_engine_get_axis_conf(dep_engine, env); + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Deployment engines axis2 configuration not available"); + + return NULL; + } + axis2_repos_listener_set_conf(repos_listener, env, conf); + + status = axis2_repos_listener_init(repos_listener, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPOS_LISTENER_INIT_FAILED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Repository listener initialization failed"); + + return NULL; + } + return repos_listener; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_repos_listener_free( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + if(!repos_listener) + return; + + if(repos_listener->folder_name) + { + AXIS2_FREE(env->allocator, repos_listener->folder_name); + } + + if(repos_listener->info_list) + { + axis2_ws_info_list_free(repos_listener->info_list, env); + } + + AXIS2_FREE(env->allocator, repos_listener); + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_check_modules( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + axis2_char_t *module_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_bool_t axis2_flag = AXIS2_FALSE; + axis2_conf_t *conf; + + axutil_param_t *module_param; + axis2_char_t *module_dir; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + + conf = axis2_repos_listener_get_conf(repos_listener, env); + + /* Configuration is needed only to decide we are using axis2.xml. Other + * case we don't need. Hence even if conf is NULL we can continue. + */ + + if(conf) + { + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + } + + if(!axis2_flag) + { + + temp_path = axutil_stracat(env, repos_listener->folder_name, AXIS2_PATH_SEP_STR); + module_path = axutil_stracat(env, temp_path, AXIS2_MODULE_PATH); + AXIS2_FREE(env->allocator, temp_path); + } + else + { + module_param = axis2_conf_get_param(conf, env, AXIS2_MODULE_DIR); + if(module_param) + { + module_dir = (axis2_char_t *)axutil_param_get_value(module_param, env); + module_path = axutil_strdup(env, module_dir); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "While creating axis2 configuration using " + "axis2.xml, modulesDir parameter not available."); + } + + } + + status = axis2_repos_listener_search(repos_listener, env, module_path, AXIS2_MODULE); + + AXIS2_FREE(env->allocator, module_path); + + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_check_svcs( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + axis2_char_t *svc_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_status_t status = AXIS2_FAILURE; + + axis2_conf_t *conf; + axis2_bool_t axis2_flag = AXIS2_FALSE; + + axutil_param_t *svc_param; + axis2_char_t *svc_dir; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + + conf = axis2_repos_listener_get_conf(repos_listener, env); + + if(conf) + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + + if(!axis2_flag) + { + temp_path = axutil_stracat(env, repos_listener->folder_name, AXIS2_PATH_SEP_STR); + svc_path = axutil_stracat(env, temp_path, AXIS2_SVC_PATH); + AXIS2_FREE(env->allocator, temp_path); + } + else + { + svc_param = axis2_conf_get_param(conf, env, AXIS2_SERVICE_DIR); + if(svc_param) + { + svc_dir = axutil_param_get_value(svc_param, env); + svc_path = axutil_strdup(env, svc_dir); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "While creating axis2 configuration using axis2.xml, servicesDir" + " parameter not available."); + } + } + + status = axis2_repos_listener_search(repos_listener, env, svc_path, AXIS2_SVC); + AXIS2_FREE(env->allocator, svc_path); + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_update( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + return axis2_ws_info_list_update(repos_listener->info_list, env); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_init( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + + status = axis2_ws_info_list_init(repos_listener->info_list, env); + if(AXIS2_SUCCESS != status) + { + return status; + } + /* if check_modules return AXIS2_FAILURE that means + * there are no modules to load + */ + axis2_repos_listener_check_modules(repos_listener, env); + + /* if check_svcs return AXIS2_FAILURE that means + * there are no services to load + */ + axis2_repos_listener_check_svcs(repos_listener, env); + return axis2_repos_listener_update(repos_listener, env); +} + +/** + * Folder name could be a repository modules or services folder. If it is modules + * folder then current_info_list contain the list of axis2 files corresponding to + * the modules within it. For services folder it should be understood similarly. + */ +static axis2_status_t +axis2_repos_listener_search( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env, + axis2_char_t * folder_name, + int type) +{ + int size = 0; + int i = 0; + axutil_array_list_t *current_info_list = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, folder_name, AXIS2_FAILURE); + current_info_list = axutil_dir_handler_list_service_or_module_dirs(env, folder_name); + if(!current_info_list) + { + axis2_status_t status_code = AXIS2_FAILURE; + + status_code = AXIS2_ERROR_GET_STATUS_CODE(env->error); + if(AXIS2_SUCCESS != status) + { + return status; + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No %s in the folder.", folder_name); + return AXIS2_SUCCESS; + } + + size = axutil_array_list_size(current_info_list, env); + + for(i = 0; i < size; i++) /* Loop until empty */ + { + axutil_file_t *file = NULL; + file = axutil_array_list_get(current_info_list, env, i); + status = axis2_ws_info_list_add_ws_info_item(repos_listener->info_list, env, file, type); + if(AXIS2_SUCCESS != status) + { + int size_j = 0; + int j = 0; + axis2_char_t* file_name = axutil_file_get_name(file, env); + + size_j = axutil_array_list_size(current_info_list, env); + for(j = 0; j < size_j; j++) + { + axutil_file_t *del_file = NULL; + + del_file = axutil_array_list_get(current_info_list, env, j); + axutil_file_free(del_file, env); + } + axutil_array_list_free(current_info_list, env); + current_info_list = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding file %s to ws info list failed", + file_name); + return status; + } + } + + for(i = 0; i < size; i++) + { + axutil_file_t *del_file = NULL; + + del_file = axutil_array_list_get(current_info_list, env, i); + axutil_file_free(del_file, env); + } + axutil_array_list_free(current_info_list, env); + current_info_list = NULL; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_set_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env, + axis2_conf_t *conf) +{ + AXIS2_PARAM_CHECK(env->error, repo_listener, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + repo_listener->conf = conf; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_repos_listener_get_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, repo_listener, NULL); + return repo_listener->conf; +} + diff --git a/src/core/deployment/svc_builder.c b/src/core/deployment/svc_builder.c new file mode 100644 index 0000000..7f55fb6 --- /dev/null +++ b/src/core/deployment/svc_builder.c @@ -0,0 +1,840 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +struct axis2_svc_builder +{ + axis2_svc_t *svc; + struct axis2_desc_builder *desc_builder; +}; + +static axutil_array_list_t * +axis2_svc_builder_process_ops( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr); + +static void +axis2_svc_builder_process_msgs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * iterator, + axis2_op_t * op); + +AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL +axis2_svc_builder_create( + const axutil_env_t * env) +{ + axis2_svc_builder_t *svc_builder = NULL; + + svc_builder = (axis2_svc_builder_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_builder_t)); + + if(!svc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Allocation to svc_builder failed"); + return NULL; + } + + svc_builder->desc_builder = NULL; + svc_builder->svc = NULL; + + return svc_builder; +} + +AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL +axis2_svc_builder_create_with_file_and_dep_engine_and_svc( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine * dep_engine, + axis2_svc_t * svc) +{ + axis2_svc_builder_t *svc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + AXIS2_PARAM_CHECK(env->error, svc, NULL); + svc_builder = (axis2_svc_builder_t *)axis2_svc_builder_create(env); + if(!svc_builder) + { + return NULL; + } + svc_builder->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, file_name, + dep_engine); + if(!svc_builder->desc_builder) + { + axis2_svc_builder_free(svc_builder, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating description builder for service builder %s failed", file_name); + return NULL; + } + svc_builder->svc = svc; + return svc_builder; +} + +AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL +axis2_svc_builder_create_with_dep_engine_and_svc( + const axutil_env_t * env, + axis2_dep_engine_t * dep_engine, + axis2_svc_t * svc) +{ + axis2_svc_builder_t *svc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + AXIS2_PARAM_CHECK(env->error, svc, NULL); + svc_builder = (axis2_svc_builder_t *)axis2_svc_builder_create(env); + if(!svc_builder) + { + return NULL; + } + svc_builder->desc_builder = axis2_desc_builder_create_with_dep_engine(env, dep_engine); + if(!svc_builder->desc_builder) + { + axis2_svc_builder_free(svc_builder, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating description builder for service builder failed"); + return NULL; + } + svc_builder->svc = svc; + return svc_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_builder_free( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env) +{ + if(svc_builder->desc_builder) + { + axis2_desc_builder_free(svc_builder->desc_builder, env); + } + + svc_builder->svc = NULL; + + if(svc_builder) + { + AXIS2_FREE(env->allocator, svc_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_builder_populate_svc( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_node_t * svc_node) +{ + axiom_element_t *svc_element = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *operation_itr = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qdesc = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qin_faultflowst = NULL; + axutil_qname_t *qout_faultflowst = NULL; + axutil_qname_t *qopst = NULL; + axutil_qname_t *qattname = NULL; + axutil_qname_t *qpolicy = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_svc_grp_t *parent = NULL; + axiom_element_t *desc_element = NULL; + axiom_node_t *desc_node = NULL; + axiom_children_qname_iterator_t *module_refs = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *in_faultflow_node = NULL; + axiom_element_t *in_faultflow_element = NULL; + axiom_node_t *out_faultflow_node = NULL; + axiom_element_t *out_faultflow_element = NULL; + axiom_attribute_t *name_attr = NULL; + axutil_array_list_t *ops = NULL; + axis2_char_t *svc_name = NULL; + axis2_char_t *class_name = NULL; + axis2_char_t *svc_dll_name = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axutil_param_t *wsdl_path_param = NULL; + axis2_char_t *wsdl_path = NULL; + axis2_arch_file_data_t *arch_file_data = NULL; + axutil_file_t *svc_folder = NULL; + axis2_char_t *dll_path = NULL; + axis2_char_t *svc_folder_path = NULL; + int i = 0; + int size = 0; + AXIS2_TIME_T timestamp = 0; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + axutil_qname_t *qname_addressing = NULL; + axis2_bool_t addressing_engaged = AXIS2_FALSE; + axutil_array_list_t *svc_module_qnames = NULL; + int svc_module_qname_size = 0; + + AXIS2_PARAM_CHECK(env->error, svc_node, AXIS2_FAILURE); + + svc_element = axiom_node_get_data_element(svc_node, env); + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + if(!qparamst) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + itr = axiom_element_get_children_with_qname(svc_element, env, qparamst, svc_node); + axutil_qname_free(qparamst, env); + qparamst = NULL; + + parent = axis2_svc_get_parent(svc_builder->svc, env); + + desc = axis2_svc_get_base(svc_builder->svc, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + status = axis2_desc_builder_process_params(svc_builder->desc_builder, env, itr, + axis2_svc_get_param_container(svc_builder->svc, env), axis2_svc_grp_get_param_container( + parent, env)); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing parameters failed"); + return status; + } + + /* process service description */ + qdesc = axutil_qname_create(env, AXIS2_DESCRIPTION, NULL, NULL); + desc_element = axiom_element_get_first_child_with_qname(svc_element, env, qdesc, svc_node, + &desc_node); + axutil_qname_free(qdesc, env); + qdesc = NULL; + if(desc_element) + { + axiom_element_t *desc_value_element = NULL; + axiom_node_t *desc_value_node = NULL; + axis2_char_t *description_text = NULL; + + desc_value_element = axiom_element_get_first_element(desc_element, env, desc_node, + &desc_value_node); + description_text = axiom_element_get_text(desc_element, env, desc_node); + if(description_text) + { + axis2_svc_set_svc_desc(svc_builder->svc, env, description_text); + } + } + + /* wsdl path */ + wsdl_path_param = axutil_param_container_get_param(axis2_svc_get_param_container( + svc_builder->svc, env), env, AXIS2_SVC_WSDL_PATH); + + if(wsdl_path_param) + { + wsdl_path = axutil_param_get_value(wsdl_path_param, env); + } + + if(wsdl_path) + { + axis2_svc_set_svc_wsdl_path(svc_builder->svc, env, wsdl_path); + } + + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + name_attr = axiom_element_get_attribute(svc_element, env, qattname); + svc_name = axiom_attribute_get_value(name_attr, env); + axis2_svc_set_name(svc_builder->svc, env, svc_name); + axutil_qname_free(qattname, env); + + /* create dll_desc and set it in a parameter. then set that param in param + * container taken from svc + */ + dll_desc = axutil_dll_desc_create(env); + impl_info_param = axutil_param_container_get_param(axis2_svc_get_param_container( + svc_builder->svc, env), env, AXIS2_SERVICE_CLASS); + if(!impl_info_param) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s parameter not found", AXIS2_SERVICE_CLASS); + return AXIS2_FAILURE; + } + class_name = axutil_strtrim(env, axutil_param_get_value(impl_info_param, env), NULL); + svc_dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + + if(class_name) + { + AXIS2_FREE(env->allocator, class_name); + class_name = NULL; + } + + arch_file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine( + svc_builder->desc_builder, env), env); + svc_folder = axis2_arch_file_data_get_file(arch_file_data, env); + timestamp = axutil_file_get_timestamp(svc_folder, env); + axutil_dll_desc_set_timestamp(dll_desc, env, timestamp); + svc_folder_path = axutil_file_get_path(svc_folder, env); + axis2_svc_set_svc_folder_path(svc_builder->svc, env, svc_folder_path); + dll_path = axutil_strcat(env, svc_folder_path, AXIS2_PATH_SEP_STR, svc_dll_name, NULL); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "DLL path is : %s", dll_path); + status = axutil_dll_desc_set_name(dll_desc, env, dll_path); + if(AXIS2_SUCCESS != status) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name to %s dll description failed", + dll_path); + return status; + } + AXIS2_FREE(env->allocator, dll_path); + dll_path = NULL; + + axutil_dll_desc_set_type(dll_desc, env, AXIS2_SVC_DLL); + status = axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + if(AXIS2_SUCCESS != status) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting dll_desc to parameter %s failed", + class_name); + return status; + } + /* processing service wide modules which required to engage globally */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_refs = axiom_element_get_children_with_qname(svc_element, env, qmodulest, svc_node); + axutil_qname_free(qmodulest, env); + qmodulest = NULL; + status = axis2_svc_builder_process_module_refs(svc_builder, env, module_refs); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing module references failed"); + return status; + } + + if(!addressing_engaged) + { + svc_module_qnames = axis2_svc_get_all_module_qnames(svc_builder->svc, env); + if(svc_module_qnames) + { + svc_module_qname_size = axutil_array_list_size(svc_module_qnames, env); + qname_addressing = axutil_qname_create(env, AXIS2_MODULE_ADDRESSING, NULL, NULL); + for(i = 0; i < svc_module_qname_size; i++) + { + if(axutil_qname_equals(axutil_array_list_get(svc_module_qnames, env, i), env, + qname_addressing)) + { + addressing_engaged = AXIS2_TRUE; + break; + } + } + axutil_qname_free(qname_addressing, env); + } + svc_module_qnames = NULL; + } + + /* process IN_FLOW */ + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qinflowst, svc_node, &in_flow_node); + axutil_qname_free(qinflowst, env); + qinflowst = NULL; + + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qoutflowst, svc_node, &out_flow_node); + axutil_qname_free(qoutflowst, env); + qoutflowst = NULL; + + qin_faultflowst = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_faultflow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qin_faultflowst, svc_node, &in_faultflow_node); + axutil_qname_free(qin_faultflowst, env); + qin_faultflowst = NULL; + + qout_faultflowst = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_faultflow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qout_faultflowst, svc_node, &out_faultflow_node); + axutil_qname_free(qout_faultflowst, env); + qout_faultflowst = NULL; + + /* processing operations */ + qopst = axutil_qname_create(env, AXIS2_OPERATIONST, NULL, NULL); + operation_itr = axiom_element_get_children_with_qname(svc_element, env, qopst, svc_node); + axutil_qname_free(qopst, env); + qopst = NULL; + ops = axis2_svc_builder_process_ops(svc_builder, env, operation_itr); + if(ops) + { + size = axutil_array_list_size(ops, env); + } + for(i = 0; i < size; i++) + { + axis2_op_t *op_desc = NULL; + axutil_array_list_t *params = NULL; + int j = 0; + int sizej = 0; + + op_desc = (axis2_op_t *)axutil_array_list_get(ops, env, i); + if(addressing_engaged) + { + params = axis2_op_get_all_params(op_desc, env); + /* Adding wsa-mapping into service */ + sizej = axutil_array_list_size(params, env); + for(j = 0; j < sizej; j++) + { + axutil_param_t *param = NULL; + axis2_char_t *param_name = NULL; + + param = axutil_array_list_get(params, env, j); + param_name = axutil_param_get_name(param, env); + if(0 == axutil_strcmp(param_name, AXIS2_WSA_MAPPING)) + { + axis2_char_t *key = NULL; + + key = (axis2_char_t *)axutil_param_get_value(param, env); + axis2_svc_add_mapping(svc_builder->svc, env, key, op_desc); + } + } + } + axis2_svc_add_op(svc_builder->svc, env, op_desc); + if(axis2_op_get_rest_http_method(op_desc, env) && axis2_op_get_rest_http_location(op_desc, + env)) + { + axis2_svc_add_rest_mapping(svc_builder->svc, env, axis2_op_get_rest_http_method( + op_desc, env), axis2_op_get_rest_http_location(op_desc, env), op_desc); + } + } + axutil_array_list_free(ops, env); + + /* + + setting the PolicyInclude + processing .. elements + */ + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include); + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + + return AXIS2_SUCCESS; +} + +static axutil_array_list_t * +axis2_svc_builder_process_ops( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr) +{ + axutil_array_list_t *ops = NULL; + + AXIS2_PARAM_CHECK(env->error, op_itr, NULL); + + ops = axutil_array_list_create(env, 0); + while(AXIS2_TRUE == axiom_children_qname_iterator_has_next(op_itr, env)) + { + axiom_element_t *op_element = NULL; + axiom_node_t *op_node = NULL; + axiom_attribute_t *op_name_att = NULL; + axiom_attribute_t *op_mep_att = NULL; + axutil_qname_t *qmep = NULL; + axutil_qname_t *qopname = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmsgrecv = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qattname = NULL; + axis2_char_t *mep_url = NULL; + axis2_char_t *op_name = NULL; + axis2_op_t *op_desc = NULL; + axiom_children_qname_iterator_t *params_itr = NULL; + axiom_children_qname_iterator_t *module_itr = NULL; + axiom_element_t *recv_element = NULL; + axiom_node_t *recv_node = NULL; + axis2_status_t status = AXIS2_FAILURE; + struct axis2_dep_engine *dep_engine = NULL; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *qpolicy = NULL; + axutil_qname_t *qmessage = NULL; + + op_node = axiom_children_qname_iterator_next(op_itr, env); + /* getting operation name */ + op_element = axiom_node_get_data_element(op_node, env); + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + op_name_att = axiom_element_get_attribute(op_element, env, qattname); + axutil_qname_free(qattname, env); + qattname = NULL; + if(!op_name_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OP_NAME_MISSING, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + + op_name = axiom_attribute_get_value(op_name_att, env); + qopname = axutil_qname_create(env, op_name, NULL, NULL); + op_desc = axis2_op_create(env); + axis2_op_set_qname(op_desc, env, qopname); + axutil_qname_free(qopname, env); + qopname = NULL; + + /* set the mep of the operation */ + qmep = axutil_qname_create(env, AXIS2_MEP, NULL, NULL); + op_mep_att = axiom_element_get_attribute(op_element, env, qmep); + axutil_qname_free(qmep, env); + qmep = NULL; + op_name = axiom_attribute_get_value(op_name_att, env); + + if(op_mep_att) + { + mep_url = axiom_attribute_get_value(op_mep_att, env); + if(mep_url) + { + axis2_op_set_msg_exchange_pattern(op_desc, env, mep_url); + } + } + + desc = axis2_op_get_base(op_desc, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + /* operation parameters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params_itr = axiom_element_get_children_with_qname(op_element, env, qparamst, op_node); + axutil_qname_free(qparamst, env); + qparamst = NULL; + status = axis2_desc_builder_process_params(svc_builder->desc_builder, env, params_itr, + axis2_op_get_param_container(op_desc, env), axis2_svc_get_param_container( + svc_builder->svc, env)); + /* To process wsamapping */ + axis2_desc_builder_process_action_mappings(svc_builder->desc_builder, env, op_node, op_desc); + + /* To process REST params */ + axis2_desc_builder_process_rest_params(svc_builder->desc_builder, env, op_node, op_desc); + + /* loading the message receivers */ + qmsgrecv = axutil_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL); + recv_element = axiom_element_get_first_child_with_qname(op_element, env, qmsgrecv, op_node, + &recv_node); + axutil_qname_free(qmsgrecv, env); + qmsgrecv = NULL; + if(recv_element && NULL != recv_node) + { + axis2_msg_recv_t *msg_recv = NULL; + msg_recv = axis2_desc_builder_load_msg_recv(svc_builder->desc_builder, env, + recv_element); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + + } + else + { + axis2_msg_recv_t *msg_recv = NULL; + /* setting the default message receiver */ + msg_recv = axis2_desc_builder_load_default_msg_recv(env); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + } + /* process module refs */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_itr = axiom_element_get_children_with_qname(op_element, env, qmodulest, op_node); + axutil_qname_free(qmodulest, env); + qmodulest = NULL; + status = axis2_desc_builder_process_op_module_refs(svc_builder-> desc_builder, env, + module_itr, op_desc); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing module operation references failed for operation %s", op_name); + return NULL; + } + + /* setting the policy_include */ + + /* processing .. elements */ + + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include); + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + + qmessage = axutil_qname_create(env, AXIS2_MESSAGE, NULL, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qmessage, op_node); + axutil_qname_free(qmessage, env); + qmessage = NULL; + + if(itr) + { + axis2_svc_builder_process_msgs(svc_builder, env, itr, op_desc); + } + + /* setting operation phase */ + dep_engine = axis2_desc_builder_get_dep_engine(svc_builder->desc_builder, env); + if(dep_engine) + { + axis2_phases_info_t *info = axis2_dep_engine_get_phases_info(dep_engine, env); + axis2_phases_info_set_op_phases(info, env, op_desc); + } + + /* adding operation */ + status = axutil_array_list_add(ops, env, op_desc); + } + + return ops; +} + +static void +axis2_svc_builder_process_msgs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * iterator, + axis2_op_t * op) +{ + while(axiom_children_qname_iterator_has_next(iterator, env)) + { + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + axutil_qname_t *qname = NULL; + axis2_char_t *msg_label = NULL; + axis2_msg_t *msg = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *qpolicy = NULL; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + + node = axiom_children_qname_iterator_next(iterator, env); + element = axiom_node_get_data_element(node, env); + qname = axutil_qname_create(env, AXIS2_LABEL, NULL, NULL); + + if(element) + { + msg_label = axiom_element_get_attribute_value(element, env, qname); + } + + if(msg_label) + { + msg = axis2_op_get_msg(op, env, msg_label); + } + + if(msg) + { + /* operation parameters */ + axiom_children_qname_iterator_t *params_itr = NULL; + axutil_qname_t *qparamst = NULL; + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params_itr = axiom_element_get_children_with_qname(element, env, qparamst, node); + axutil_qname_free(qparamst, env); + qparamst = NULL; + axis2_desc_builder_process_params(svc_builder->desc_builder, env, params_itr, + axis2_msg_get_param_container(msg, env), axis2_op_get_param_container(op, env)); + + desc = axis2_msg_get_base(msg, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + /* setting the policy_include */ + + /* processing .. elements */ + + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include); + /* axis2_process_policy_elements(env, AXIS2_MESSAGE_POLICY, itr, + policy_include); */ + + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, + NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + } + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_builder_process_svc_module_conf( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_confs, + axutil_param_container_t * parent, + axis2_svc_t * svc) +{ + while(axiom_children_qname_iterator_has_next(module_confs, env)) + { + axiom_element_t *module_conf_element = NULL; + axiom_node_t *module_conf_node = NULL; + axiom_attribute_t *module_name_att = NULL; + axutil_qname_t *qattname = NULL; + + module_conf_node = axiom_children_qname_iterator_next(module_confs, env); + module_conf_element = axiom_node_get_data_element(module_conf_node, env); + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + module_name_att = axiom_element_get_attribute(module_conf_element, env, qattname); + axutil_qname_free(qattname, env); + qattname = NULL; + if(!module_name_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_CONF, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module name attribute not found for module node"); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_builder_process_module_refs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs) +{ + AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_element_t *module_ref_element = NULL; + axiom_node_t *module_ref_node = NULL; + axiom_attribute_t *module_ref_att = NULL; + axutil_qname_t *qref = NULL; + + module_ref_node = axiom_children_qname_iterator_next(module_refs, env); + module_ref_element = axiom_node_get_data_element(module_ref_node, env); + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref); + axutil_qname_free(qref, env); + if(module_ref_att) + { + axis2_char_t *ref_name = NULL; + axutil_qname_t *qrefname = NULL; + + ref_name = axiom_attribute_get_value(module_ref_att, env); + qrefname = axutil_qname_create(env, ref_name, NULL, NULL); + if(!axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine( + svc_builder->desc_builder, env), env, qrefname)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to find " + "Module %s, in Service %s", ref_name, axis2_svc_get_name(svc_builder->svc, env)); + return AXIS2_FAILURE; + } + else + { + axis2_svc_add_module_qname(svc_builder->svc, env, qrefname); + } + axutil_qname_free(qrefname, env); + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN struct axis2_desc_builder *AXIS2_CALL +axis2_svc_builder_get_desc_builder( + const axis2_svc_builder_t * svc_builder, + const axutil_env_t * env) +{ + return svc_builder->desc_builder; +} + diff --git a/src/core/deployment/svc_grp_builder.c b/src/core/deployment/svc_grp_builder.c new file mode 100644 index 0000000..6aa07ad --- /dev/null +++ b/src/core/deployment/svc_grp_builder.c @@ -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. + */ + +#include + +struct axis2_svc_grp_builder +{ + axiom_node_t *svc_grp; + axis2_desc_builder_t *desc_builder; +}; + +AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL +axis2_svc_grp_builder_create( + const axutil_env_t * env) +{ + axis2_svc_grp_builder_t *svc_grp_builder = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + svc_grp_builder = (axis2_svc_grp_builder_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_svc_grp_builder_t)); + + if(!svc_grp_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svc_grp_builder->svc_grp = NULL; + svc_grp_builder->desc_builder = NULL; + + return svc_grp_builder; +} + +AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL +axis2_svc_grp_builder_create_with_svc_and_dep_engine( + const axutil_env_t * env, + axiom_node_t * svc_grp, + axis2_dep_engine_t * dep_engine) +{ + axis2_svc_grp_builder_t *svc_grp_builder = NULL; + + svc_grp_builder = (axis2_svc_grp_builder_t *)axis2_svc_grp_builder_create(env); + if(!svc_grp_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + svc_grp_builder = NULL; + } + svc_grp_builder->desc_builder = axis2_desc_builder_create_with_dep_engine(env, dep_engine); + if(!svc_grp_builder->desc_builder) + { + axis2_svc_grp_builder_free(svc_grp_builder, env); + return NULL; + } + svc_grp_builder->svc_grp = svc_grp; + + return svc_grp_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_grp_builder_free( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env) +{ + if(svc_grp_builder->desc_builder) + { + axis2_desc_builder_free(svc_grp_builder->desc_builder, env); + } + if(svc_grp_builder) + { + AXIS2_FREE(env->allocator, svc_grp_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_builder_populate_svc_grp( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp) +{ + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *module_ref_itr = NULL; + axiom_children_qname_iterator_t *svc_itr = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qsvc_element = NULL; + axiom_element_t *svc_grp_element = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_conf_t *parent = NULL; + + /* Processing service level paramters */ + svc_grp_element = axiom_node_get_data_element(svc_grp_builder->svc_grp, env); + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + + itr = axiom_element_get_children_with_qname(svc_grp_element, env, qparamst, + svc_grp_builder->svc_grp); + + if(qparamst) + { + axutil_qname_free(qparamst, env); + qparamst = NULL; + } + + parent = axis2_svc_grp_get_parent(svc_grp, env); + status = axis2_desc_builder_process_params(svc_grp_builder->desc_builder, env, itr, + axis2_svc_grp_get_param_container(svc_grp, env), + axis2_conf_get_param_container(parent, env)); + + /* Processing service modules required to be engaged globally */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_ref_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qmodulest, + svc_grp_builder-> svc_grp); + + if(qmodulest) + { + axutil_qname_free(qmodulest, env); + qmodulest = NULL; + } + + axis2_svc_grp_builder_process_module_refs(svc_grp_builder, env, module_ref_itr, svc_grp); + qsvc_element = axutil_qname_create(env, AXIS2_SVC_ELEMENT, NULL, NULL); + svc_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qsvc_element, + svc_grp_builder->svc_grp); + + if(qsvc_element) + { + axutil_qname_free(qsvc_element, env); + qsvc_element = NULL; + } + + while(axiom_children_qname_iterator_has_next(svc_itr, env)) + { + axiom_node_t *svc_node = NULL; + axiom_element_t *svc_element = NULL; + axiom_attribute_t *svc_name_att = NULL; + axis2_char_t *svc_name = NULL; + axutil_qname_t *qattname = NULL; + + svc_node = (axiom_node_t *)axiom_children_qname_iterator_next(svc_itr, env); + svc_element = axiom_node_get_data_element(svc_node, env); + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + svc_name_att = axiom_element_get_attribute(svc_element, env, qattname); + + if(qattname) + { + axutil_qname_free(qattname, env); + qattname = NULL; + } + + svc_name = axiom_attribute_get_value(svc_name_att, env); + if(!svc_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_NAME_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service name attribute has no value"); + return AXIS2_FAILURE; + } + else + { + axis2_svc_t *axis_svc = NULL; + axis2_arch_file_data_t *file_data = NULL; + axutil_array_list_t *deployable_svcs = NULL; + axis2_svc_builder_t *svc_builder = NULL; + + file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine( + svc_grp_builder->desc_builder, env), env); + axis_svc = axis2_arch_file_data_get_svc(file_data, env, svc_name); + if(!axis_svc) + { + axutil_qname_t *qsvc_name = NULL; + + qsvc_name = axutil_qname_create(env, svc_name, NULL, NULL); + axis_svc = axis2_svc_create_with_qname(env, qsvc_name); + axutil_qname_free(qsvc_name, env); + axis2_arch_file_data_add_svc(file_data, env, axis_svc); + + } + /* Adding service to the deployable services list */ + deployable_svcs = axis2_arch_file_data_get_deployable_svcs(file_data, env); + axutil_array_list_add(deployable_svcs, env, axis_svc); + axis2_svc_set_parent(axis_svc, env, svc_grp); + svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env, + axis2_desc_builder_get_dep_engine(svc_grp_builder-> desc_builder, env), axis_svc); + status = axis2_svc_builder_populate_svc(svc_builder, env, svc_node); + axis2_svc_builder_free(svc_builder, env); + + } + } + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_builder_process_module_refs( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_svc_grp_t * svc_grp) +{ + AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_node_t *module_ref_node = NULL; + axiom_element_t *module_ref_element = NULL; + axiom_attribute_t *module_ref_att = NULL; + axutil_qname_t *qref = NULL; + + module_ref_node = (axiom_node_t *)axiom_children_qname_iterator_next(module_refs, env); + module_ref_element = axiom_node_get_data_element(module_ref_node, env); + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref); + if(module_ref_att) + { + axis2_char_t *ref_name = NULL; + axutil_qname_t *qrefname = NULL; + axis2_module_desc_t *module = NULL; + + ref_name = axiom_attribute_get_value(module_ref_att, env); + qrefname = axutil_qname_create(env, ref_name, NULL, NULL); + module = axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine( + svc_grp_builder->desc_builder, env), env, qrefname); + if(!module) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module %s not found in deployment engine.", ref_name); + return AXIS2_FAILURE; + } + else + { + axis2_svc_grp_add_module_ref(svc_grp, env, qrefname); + } + axutil_qname_free(qrefname, env); + } + axutil_qname_free(qref, env); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_svc_grp_builder_get_desc_builder( + const axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env) +{ + return svc_grp_builder->desc_builder; +} + diff --git a/src/core/deployment/ws_info.c b/src/core/deployment/ws_info.c new file mode 100644 index 0000000..0f2fa37 --- /dev/null +++ b/src/core/deployment/ws_info.c @@ -0,0 +1,158 @@ +/* + * 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. + */ + +#include "axis2_ws_info.h" +#include + +struct axis2_ws_info +{ + axis2_char_t *file_name; + long last_modified_date; + + /** + * To check whether the file is a module or a servise + */ + int type; +}; + +AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL +axis2_ws_info_create_with_file_name_and_last_modified_date( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date) +{ + axis2_ws_info_t *ws_info = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + ws_info = (axis2_ws_info_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_ws_info_t)); + + if(!ws_info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ws_info->file_name = NULL; + ws_info->last_modified_date = 0; + ws_info->type = 0; + + ws_info->file_name = axutil_strdup(env, file_name); + if(!ws_info->file_name) + { + axis2_ws_info_free(ws_info, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ws_info->last_modified_date = last_modified_date; + + return ws_info; +} + +AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL +axis2_ws_info_create_with_file_name_and_last_modified_date_and_type( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date, + int type) +{ + axis2_ws_info_t *ws_info = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + ws_info = (axis2_ws_info_t *)axis2_ws_info_create_with_file_name_and_last_modified_date(env, + file_name, last_modified_date); + if(!ws_info) + { + axis2_ws_info_free(ws_info, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + ws_info->type = type; + return ws_info; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_ws_info_free( + axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + if(ws_info->file_name) + { + AXIS2_FREE(env->allocator, ws_info->file_name); + } + + if(ws_info) + { + AXIS2_FREE(env->allocator, ws_info); + } + + return; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_ws_info_get_file_name( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + return ws_info->file_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_set_file_name( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + + if(ws_info->file_name) + { + AXIS2_FREE(env->allocator, ws_info->file_name); + ws_info->file_name = NULL; + } + ws_info->file_name = file_name; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN long AXIS2_CALL +axis2_ws_info_get_last_modified_date( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + return ws_info->last_modified_date; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_set_last_modified_date( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + long last_modified_date) +{ + ws_info->last_modified_date = last_modified_date; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_ws_info_get_type( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + return ws_info->type; +} + diff --git a/src/core/deployment/ws_info_list.c b/src/core/deployment/ws_info_list.c new file mode 100644 index 0000000..41a85c7 --- /dev/null +++ b/src/core/deployment/ws_info_list.c @@ -0,0 +1,370 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_ws_info_list +{ + /** + * This is to store all the deployment info about the deployment files + * for services or modules in a specified folder. + */ + axutil_array_list_t *ws_info_list; + + /** + * All the curently updated deployment info list. + */ + axutil_array_list_t *current_info_list; + + /** + * Referance to deployment engine to make update. + */ + struct axis2_dep_engine *dep_engine; + +}; + +AXIS2_EXTERN axis2_ws_info_list_t *AXIS2_CALL +axis2_ws_info_list_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine *dep_engine) +{ + axis2_ws_info_list_t *ws_info_list = NULL; + + ws_info_list = (axis2_ws_info_list_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_ws_info_list_t)); + + if(!ws_info_list) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)ws_info_list, 0, sizeof(axis2_ws_info_list_t)); + + ws_info_list->dep_engine = dep_engine; + + ws_info_list->ws_info_list = axutil_array_list_create(env, 0); + if(!(ws_info_list->ws_info_list)) + { + axis2_ws_info_list_free(ws_info_list, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ws_info_list->current_info_list = axutil_array_list_create(env, 0); + if(!(ws_info_list->current_info_list)) + { + axis2_ws_info_list_free(ws_info_list, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return ws_info_list; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_ws_info_list_free( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + if(ws_info_list->current_info_list) + { + int list_size = 0; + int i = 0; + + list_size = axutil_array_list_size(ws_info_list->current_info_list, env); + for(i = 0; i < list_size; i++) + { + axis2_char_t *file_name = NULL; + + file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list->current_info_list, env, + i); + AXIS2_FREE(env->allocator, file_name); + } + axutil_array_list_free(ws_info_list->current_info_list, env); + } + + if(ws_info_list->ws_info_list) + { + int list_size = 0; + int i = 0; + + list_size = axutil_array_list_size(ws_info_list->ws_info_list, env); + for(i = 0; i < list_size; i++) + { + axis2_ws_info_t *ws_info = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); + axis2_ws_info_free(ws_info, env); + } + axutil_array_list_free(ws_info_list->ws_info_list, env); + } + + if(ws_info_list) + { + AXIS2_FREE(env->allocator, ws_info_list); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_init( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + int size = 0; + int i = 0; + + size = axutil_array_list_size(ws_info_list->ws_info_list, env); + for(i = 0; i < size; i++) + { + axis2_ws_info_t *ws_info = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list->ws_info_list, env, i); + axis2_ws_info_free(ws_info, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_add_ws_info_item( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axutil_file_t * file, + int type) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *file_name = NULL; + axis2_char_t *temp_name = NULL; + + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + + temp_name = axutil_file_get_name(file, env); + file_name = axutil_strdup(env, temp_name); + if(!file_name) + { + return AXIS2_FAILURE; + } + + switch(type) + { + case AXIS2_SVC: + { + axis2_ws_info_t *ws_info = NULL; + long last_modified_date = 0; + axis2_arch_file_data_t *file_data = NULL; + + last_modified_date = (long)axutil_file_get_timestamp(file, env); + /* We are sure that the difference lies within the long range */ + ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env, + file_name, last_modified_date, AXIS2_SVC); + status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info); + + if(AXIS2_SUCCESS != status) + { + return status; + } + file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_SVC, file); + /* To inform that new web service is to be deployed */ + status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data); + if(AXIS2_SUCCESS != status) + { + return status; + } + break; + } + case AXIS2_MODULE: + { + axis2_ws_info_t *ws_info = NULL; + long last_modified_date = 0; + axis2_arch_file_data_t *file_data = NULL; + + last_modified_date = (long)axutil_file_get_timestamp(file, env); + /* We are sure that the difference lies within the long range */ + ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env, + file_name, last_modified_date, AXIS2_MODULE); + status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info); + + if(AXIS2_SUCCESS != status) + { + return status; + } + file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_MODULE, file); + /* To inform that new module is to be deployed */ + status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data); + if(AXIS2_SUCCESS != status) + { + return status; + } + + break; + } + } + return axutil_array_list_add(ws_info_list->current_info_list, env, file_name); +} + +AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL +axis2_ws_info_list_get_file_item( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + int i = 0; + int size = 0; + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + size = axutil_array_list_size(ws_info_list->ws_info_list, env); + for(i = 0; i < size; i++) + { + axis2_ws_info_t *ws_info = NULL; + axis2_char_t *file_name_l = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); + + file_name_l = axis2_ws_info_get_file_name(ws_info, env); + if(!axutil_strcmp(file_name_l, file_name)) + { + return ws_info; + } + } + return NULL; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_ws_info_list_is_modified( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axutil_file_t * file, + axis2_ws_info_t * ws_info) +{ + long last_modified_date = 0; + + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, ws_info, AXIS2_FAILURE); + + last_modified_date = axis2_ws_info_get_last_modified_date(ws_info, env); + return (last_modified_date != axutil_file_get_timestamp(file, env)); +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_ws_info_list_is_file_exist( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + axis2_ws_info_t *ws_info = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + ws_info = axis2_ws_info_list_get_file_item(ws_info_list, env, file_name); + return !(ws_info == NULL); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_check_for_undeploy( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + int list_size = 0; + axutil_array_list_t *temp_list = NULL; + int i = 0; + + /* Create temp list */ + temp_list = axutil_array_list_create(env, 0); + if(!temp_list) + { + return AXIS2_FAILURE; + } + list_size = axutil_array_list_size(ws_info_list->ws_info_list, env); + + for(i = 0; i < list_size; i++) + { + /* For each ws_info item in the ws_info_list check whether it is also + * in the current_info_list. If not mark it to be undeployed by adding + * it to a temporarily list. Also add that item to the undeploy list of + * deployment engine.*/ + int current_lists_size = 0; + axis2_ws_info_t *file_item = NULL; + axis2_char_t *file_item_name = NULL; + axis2_bool_t exist = AXIS2_FALSE; + int j = 0; + + file_item = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); + + file_item_name = axis2_ws_info_get_file_name(file_item, env); + current_lists_size = axutil_array_list_size(ws_info_list->current_info_list, env); + for(j = 0; j < current_lists_size; j++) + { + axis2_char_t *file_name = NULL; + file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list-> current_info_list, + env, j); + if(!axutil_strcmp(file_name, file_item_name)) + { + exist = AXIS2_TRUE; + break; + } + } + + if(!exist) + { + axis2_ws_info_t *ws_info = NULL; + long last_modified_date = 0; + + last_modified_date = axis2_ws_info_get_last_modified_date(file_item, env); + axutil_array_list_add(temp_list, env, file_item); + ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date(env, + file_item_name, last_modified_date); + /* This ws_info is to be undeployed */ + axis2_dep_engine_add_ws_to_undeploy(ws_info_list->dep_engine, env, ws_info); + } + + } + + list_size = axutil_array_list_size(temp_list, env); + for(i = 0; i < list_size; i++) + { + /* Get each ws_info item from the temp list created and remove that + * item from the ws_info_list */ + axis2_ws_info_t *file_item = NULL; + int index = 0; + + file_item = (axis2_ws_info_t *)axutil_array_list_get(temp_list, env, i); + index = axutil_array_list_index_of(ws_info_list->ws_info_list, env, file_item); + axutil_array_list_remove(ws_info_list->ws_info_list, env, index); + } + axutil_array_list_free(temp_list, env); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_update( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + + status = axis2_ws_info_list_check_for_undeploy(ws_info_list, env); + if(AXIS2_SUCCESS != status) + { + return AXIS2_FAILURE; + } + + return axis2_dep_engine_do_deploy(ws_info_list->dep_engine, env); +} + diff --git a/src/core/description/Makefile.am b/src/core/description/Makefile.am new file mode 100644 index 0000000..5c3618c --- /dev/null +++ b/src/core/description/Makefile.am @@ -0,0 +1,24 @@ +noinst_LTLIBRARIES = libaxis2_description.la + +libaxis2_description_la_SOURCES =desc.c \ + op.c \ + policy_include.c \ + svc.c \ + module_desc.c \ + svc_grp.c \ + phase_rule.c \ + handler_desc.c \ + flow.c \ + flow_container.c \ + transport_in_desc.c \ + transport_out_desc.c \ + msg.c + +libaxis2_description_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include \ + -I$(top_builddir)/neethi/include + diff --git a/src/core/description/desc.c b/src/core/description/desc.c new file mode 100644 index 0000000..bd5a80a --- /dev/null +++ b/src/core/description/desc.c @@ -0,0 +1,261 @@ +/* + * 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. + */ + +#include +#include +#include +#include + +struct axis2_desc +{ + + /** parameter container */ + axutil_param_container_t *param_container; + + /** children of this description */ + axutil_hash_t *children; + + axis2_desc_t *parent; + + axis2_policy_include_t *policy_include; +}; + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_desc_create( + const axutil_env_t * env) +{ + axis2_desc_t *desc = NULL; + + desc = (axis2_desc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_desc_t)); + + if(!desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + desc->param_container = NULL; + desc->children = NULL; + desc->parent = NULL; + desc->policy_include = NULL; + + desc->param_container = (axutil_param_container_t *)axutil_param_container_create(env); + if(!(desc->param_container)) + { + axis2_desc_free(desc, env); + return NULL; + } + + desc->children = axutil_hash_make(env); + if(!(desc->children)) + { + axis2_desc_free(desc, env); + return NULL; + } + + desc->policy_include = axis2_policy_include_create_with_desc(env, desc); + + return desc; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_desc_free( + axis2_desc_t * desc, + const axutil_env_t * env) +{ + if(desc->children) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + for(hi = axutil_hash_first(desc->children, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &val); + + if(val) + { + axis2_msg_free((axis2_msg_t *)val, env); + } + } + + axutil_hash_free(desc->children, env); + } + + if(desc->param_container) + { + axutil_param_container_free(desc->param_container, env); + } + + if(desc->policy_include) + { + axis2_policy_include_free(desc->policy_include, env); + } + + if(desc) + { + AXIS2_FREE(env->allocator, desc); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_add_param( + axis2_desc_t * desc, + const axutil_env_t * env, + axutil_param_t * param) +{ + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE); + + return axutil_param_container_add_param(desc->param_container, env, param); +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, param_name, NULL); + return axutil_param_container_get_param(desc->param_container, env, param_name); +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_desc_get_all_params( + const axis2_desc_t * desc, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, desc->param_container, AXIS2_FALSE); + + return axutil_param_container_get_params(desc->param_container, env); +} + +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) +{ + axutil_param_t *param_l = NULL; + + AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE); + + param_l = axis2_desc_get_param(desc, env, param_name); + + return (param_l && axutil_param_is_locked(param_l, env)); +} + +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 axis2_msg_t *child) +{ + if(desc->children) + { + axis2_msg_t* msg = (axis2_msg_t *)axutil_hash_get(desc->children, key, + AXIS2_HASH_KEY_STRING); + if(msg != NULL) + { + axis2_msg_free(msg, env); + msg = NULL; + } + axutil_hash_set(desc->children, key, AXIS2_HASH_KEY_STRING, (void *)child); + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_desc_get_all_children( + const axis2_desc_t * desc, + const axutil_env_t * env) +{ + return desc->children; +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_desc_get_child( + const axis2_desc_t * desc, + const axutil_env_t * env, + const axis2_char_t * key) +{ + return axutil_hash_get(desc->children, key, AXIS2_HASH_KEY_STRING); +} + +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) +{ + if(desc->children) + { + axutil_hash_set(desc->children, key, AXIS2_HASH_KEY_STRING, NULL); + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_desc_get_parent( + const axis2_desc_t * desc, + const axutil_env_t * env) +{ + return desc->parent; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_set_parent( + axis2_desc_t * desc, + const axutil_env_t * env, + axis2_desc_t * parent) +{ + desc->parent = parent; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_set_policy_include( + axis2_desc_t * desc, + const axutil_env_t * env, + axis2_policy_include_t * policy_include) +{ + if(desc->policy_include) + { + axis2_policy_include_free(desc->policy_include, env); + desc->policy_include = NULL; + } + + desc->policy_include = policy_include; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL +axis2_desc_get_policy_include( + axis2_desc_t * desc, + const axutil_env_t * env) +{ + if(!desc->policy_include) + { + /*desc->policy_include = axis2_policy_include_create(env); */ + desc->policy_include = axis2_policy_include_create_with_desc(env, desc); + } + return desc->policy_include; +} + diff --git a/src/core/description/flow.c b/src/core/description/flow.c new file mode 100644 index 0000000..554d666 --- /dev/null +++ b/src/core/description/flow.c @@ -0,0 +1,130 @@ +/* + * 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. + */ + +#include + +struct axis2_flow +{ + axutil_array_list_t *list; +}; + +AXIS2_EXTERN axis2_flow_t *AXIS2_CALL +axis2_flow_create( + const axutil_env_t * env) +{ + axis2_flow_t *flow = NULL; + + flow = (axis2_flow_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_flow_t)); + + if(!flow) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + flow->list = NULL; + + flow->list = axutil_array_list_create(env, 20); + if(!(flow->list)) + { + axis2_flow_free(flow, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return flow; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_flow_free( + axis2_flow_t * flow, + const axutil_env_t * env) +{ + if(flow->list) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(flow->list, env); + for(i = 0; i < size; i++) + { + axis2_handler_desc_t *handler_desc = NULL; + + handler_desc = (axis2_handler_desc_t *)axutil_array_list_get(flow->list, env, i); + axis2_handler_desc_free(handler_desc, env); + } + axutil_array_list_free(flow->list, env); + } + + if(flow) + { + AXIS2_FREE(env->allocator, flow); + } + + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_flow_free_void_arg( + void *flow, + const axutil_env_t * env) +{ + axis2_flow_t *flow_l = NULL; + + flow_l = (axis2_flow_t *)flow; + axis2_flow_free(flow_l, env); + return; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE); + + if(!flow->list) + { + flow->list = axutil_array_list_create(env, 0); + if(!flow->list) + { + axis2_flow_free(flow, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + return axutil_array_list_add(flow->list, env, handler); +} + +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) +{ + return axutil_array_list_get(flow->list, env, index); +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_flow_get_handler_count( + const axis2_flow_t * flow, + const axutil_env_t * env) +{ + return axutil_array_list_size(flow->list, env); +} + diff --git a/src/core/description/flow_container.c b/src/core/description/flow_container.c new file mode 100644 index 0000000..e39be01 --- /dev/null +++ b/src/core/description/flow_container.c @@ -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. + */ + +#include +#include + +struct axis2_flow_container +{ + axis2_flow_t *in; + axis2_flow_t *out; + axis2_flow_t *in_fault; + axis2_flow_t *out_fault; +}; + +AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL +axis2_flow_container_create( + const axutil_env_t * env) +{ + axis2_flow_container_t *flow_container = NULL; + + flow_container = (axis2_flow_container_t *)AXIS2_MALLOC(env-> allocator, + sizeof(axis2_flow_container_t)); + + if(!flow_container) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + flow_container->in = NULL; + flow_container->out = NULL; + flow_container->in_fault = NULL; + flow_container->out_fault = NULL; + + return flow_container; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_flow_container_free( + axis2_flow_container_t * flow_container, + const axutil_env_t * env) +{ + if(flow_container->in) + { + axis2_flow_free(flow_container->in, env); + } + + if(flow_container->out) + { + axis2_flow_free(flow_container->out, env); + } + + if(flow_container->in_fault) + { + axis2_flow_free(flow_container->in_fault, env); + } + + if(flow_container->out_fault) + { + axis2_flow_free(flow_container->out_fault, env); + } + + if(flow_container) + { + AXIS2_FREE(env->allocator, flow_container); + } + + return; +} + +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) +{ + return flow_container->in; +} + +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) +{ + if(flow_container->in) + { + axis2_flow_free(flow_container->in, env); + } + flow_container->in = in_flow; + return AXIS2_SUCCESS; +} + +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) +{ + return flow_container->out; +} + +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) +{ + if(flow_container->out) + { + axis2_flow_free(flow_container->out, env); + } + flow_container->out = out_flow; + return AXIS2_SUCCESS; +} + +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) +{ + return flow_container->in_fault; +} + +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) +{ + if(flow_container->in_fault) + { + axis2_flow_free(flow_container->in_fault, env); + } + flow_container->in_fault = falut_in_flow; + return AXIS2_SUCCESS; +} + +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) +{ + return flow_container->out_fault; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE); + if(flow_container->out_fault) + { + axis2_flow_free(flow_container->out_fault, env); + } + flow_container->out_fault = fault_out_flow; + return AXIS2_SUCCESS; +} + diff --git a/src/core/description/handler_desc.c b/src/core/description/handler_desc.c new file mode 100644 index 0000000..c3281f5 --- /dev/null +++ b/src/core/description/handler_desc.c @@ -0,0 +1,333 @@ +/* + * 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. + */ + +#include +#include +#include +#include + +struct axis2_handler_desc +{ + + /** name */ + axutil_string_t *name; + + /** phase rules */ + axis2_phase_rule_t *rules; + + /** handler represented by meta information*/ + axis2_handler_t *handler; + + /** class name */ + axis2_char_t *class_name; + + /** parent param container */ + axutil_param_container_t *parent; + + /** parameter container */ + axutil_param_container_t *param_container; +}; + +AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL +axis2_handler_desc_create( + const axutil_env_t * env, + axutil_string_t * name) +{ + axis2_handler_desc_t *handler_desc = NULL; + + handler_desc = AXIS2_MALLOC(env->allocator, sizeof(axis2_handler_desc_t)); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + handler_desc->param_container = NULL; + handler_desc->name = NULL; + handler_desc->rules = NULL; + handler_desc->handler = NULL; + handler_desc->class_name = NULL; + handler_desc->parent = NULL; + + handler_desc->param_container = axutil_param_container_create(env); + if(!handler_desc->param_container) + { + + /** error code is already set by last param container create */ + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + handler_desc->rules = axis2_phase_rule_create(env, NULL); + if(!handler_desc->rules) + { + + /** error code is already set by last param container create */ + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + if(name) + { + handler_desc->name = axutil_string_clone(name, env); + } + + return handler_desc; +} + +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) +{ + return handler_desc->name; +} + +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) +{ + if(handler_desc->name) + { + axutil_string_free(handler_desc->name, env); + handler_desc->name = NULL; + } + + if(name) + { + handler_desc->name = axutil_string_clone(name, env); + } + + return AXIS2_SUCCESS; +} + +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) +{ + return handler_desc->rules; +} + +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) +{ + const axutil_string_t *str_name = axis2_handler_desc_get_name(handler_desc, env); + const axis2_char_t *name = axutil_string_get_buffer(str_name, env); + if(handler_desc->rules) + { + axis2_phase_rule_free(handler_desc->rules, env); + } + + if(phase_rule) + { + handler_desc->rules = axis2_phase_rule_clone(phase_rule, env); + if(!(handler_desc->rules)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Phase rule cloning failed for handler description %s", name); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + return axutil_param_container_get_param(handler_desc->param_container, env, name); +} + +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) +{ + const axutil_string_t *str_name = axis2_handler_desc_get_name(handler_desc, env); + const axis2_char_t *name = axutil_string_get_buffer(str_name, env); + axis2_char_t *param_name = axutil_param_get_name(param, env); + if(axutil_param_container_is_param_locked(handler_desc->parent, env, param_name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for handler %s", + param_name, name); + return AXIS2_FAILURE; + } + + return axutil_param_container_add_param(handler_desc->param_container, env, param); +} + +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) +{ + return axutil_param_container_get_params(handler_desc->param_container, env); +} + +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) +{ + /* See if it is locked in parent */ + if(axutil_param_container_is_param_locked(handler_desc->parent, env, param_name)) + { + return AXIS2_TRUE; + } + + return axutil_param_container_is_param_locked(handler_desc->param_container, env, param_name); +} + +AXIS2_EXTERN axis2_handler_t *AXIS2_CALL +axis2_handler_desc_get_handler( + const axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + return handler_desc->handler; +} + +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) +{ + /* Handler description is the place where the handler really lives. + Hence this is a deep copy and should be freed by the free function. */ + + if(handler_desc->handler && (handler_desc->handler != handler)) + { + axis2_handler_free(handler_desc->handler, env); + } + + if(handler) + handler_desc->handler = handler; /* Shallow copy, but free method + should free this */ + + return AXIS2_SUCCESS; +} + +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) +{ + return handler_desc->class_name; +} + +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) +{ + if(handler_desc->class_name) + { + AXIS2_FREE(env->allocator, handler_desc->class_name); + } + + if(class_name) + { + handler_desc->class_name = axutil_strdup(env, class_name); + if(!handler_desc->class_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + return handler_desc->parent; +} + +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) +{ + handler_desc->parent = parent; /* Shallow copy, because + the parent lives somewhere else */ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_handler_desc_free( + axis2_handler_desc_t * handler_desc, + const axutil_env_t * env) +{ + if(handler_desc->param_container) + { + axutil_param_container_free(handler_desc->param_container, env); + } + + if(handler_desc->name) + { + axutil_string_free(handler_desc->name, env); + } + + if(handler_desc->rules) + { + axis2_phase_rule_free(handler_desc->rules, env); + } + + if(handler_desc->handler) + { + axis2_handler_free(handler_desc->handler, env); + } + + if(handler_desc->class_name) + { + AXIS2_FREE(env->allocator, handler_desc->class_name); + } + if(handler_desc) + { + AXIS2_FREE(env->allocator, handler_desc); + } + + return; +} + +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) +{ + return handler_desc->param_container; +} + diff --git a/src/core/description/module_desc.c b/src/core/description/module_desc.c new file mode 100644 index 0000000..a5b27c7 --- /dev/null +++ b/src/core/description/module_desc.c @@ -0,0 +1,470 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_module_desc +{ + axis2_module_t *module; + axutil_qname_t *qname; + axis2_conf_t *parent; + + /** + * To store module operations , which are supposed to be added to a service + * the module is engaged to a service + */ + axutil_hash_t *ops; + + /** + * flow container that encapsulates the flows associated with the + * module + */ + axis2_flow_container_t *flow_container; + + /** + * parameter container that stores all the parameters associated with + * the module + */ + axutil_param_container_t *params; +}; + +AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL +axis2_module_desc_create( + const axutil_env_t * env) +{ + axis2_module_desc_t *module_desc = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + module_desc = (axis2_module_desc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_module_desc_t)); + + if(!module_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + module_desc->qname = NULL; + module_desc->module = NULL; + module_desc->parent = NULL; + module_desc->params = NULL; + module_desc->flow_container = NULL; + module_desc->ops = NULL; + + module_desc->params = axutil_param_container_create(env); + if(!module_desc->params) + { + axis2_module_desc_free(module_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + module_desc->flow_container = axis2_flow_container_create(env); + if(!module_desc->flow_container) + { + axis2_module_desc_free(module_desc, env); +AXIS2_ERROR_SET (env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE) + return NULL; +} + +module_desc->ops = axutil_hash_make(env); +if (!module_desc->ops) +{ + axis2_module_desc_free(module_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; +} + +return module_desc; +} + +AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL +axis2_module_desc_create_with_qname( + const axutil_env_t * env, + const axutil_qname_t * qname) +{ + axis2_module_desc_t *module_desc = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, qname, NULL); + + module_desc = axis2_module_desc_create(env); + if(!module_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + module_desc->qname = (axutil_qname_t *)qname; + + return module_desc; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_module_desc_free( + axis2_module_desc_t * module_desc, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(module_desc->module) + { + axis2_module_shutdown(module_desc->module, env); + } + + if(module_desc->params) + { + axutil_param_container_free(module_desc->params, env); + } + + if(module_desc->flow_container) + { + axis2_flow_container_free(module_desc->flow_container, env); + } + + module_desc->parent = NULL; + + if(module_desc->qname) + { + axutil_qname_free(module_desc->qname, env); + } + + if(module_desc->ops) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(module_desc->ops, env); hi; hi = axutil_hash_next(env, hi)) + { + struct axis2_op *op = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + op = (struct axis2_op *)val; + if(op) + axis2_op_free(op, env); + val = NULL; + op = NULL; + + } + axutil_hash_free(module_desc->ops, env); + } + + if(module_desc) + { + AXIS2_FREE(env->allocator, module_desc); + } + + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_module_desc_free_void_arg( + void *module_desc, + const axutil_env_t * env) +{ + axis2_module_desc_t *module_desc_l = NULL; + + AXIS2_ENV_CHECK(env, void); + module_desc_l = (axis2_module_desc_t *)module_desc; + axis2_module_desc_free(module_desc_l, env); + return; +} + +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) +{ + return axis2_flow_container_get_in_flow(module_desc->flow_container, env); +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, in_flow, AXIS2_FAILURE); + + return axis2_flow_container_set_in_flow(module_desc->flow_container, env, in_flow); +} + +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) +{ + return axis2_flow_container_get_out_flow(module_desc->flow_container, env); +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out_flow, AXIS2_FAILURE); + + return axis2_flow_container_set_out_flow(module_desc->flow_container, env, out_flow); +} + +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) +{ + return axis2_flow_container_get_fault_in_flow(module_desc->flow_container, env); +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, falut_in_flow, AXIS2_FAILURE); + + return axis2_flow_container_set_fault_in_flow(module_desc->flow_container, env, falut_in_flow); +} + +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) +{ + return axis2_flow_container_get_fault_out_flow(module_desc->flow_container, env); +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE); + + return axis2_flow_container_set_fault_out_flow(module_desc->flow_container, env, fault_out_flow); +} + +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) +{ + return module_desc->qname; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE); + + if(module_desc->qname) + { + axutil_qname_free(module_desc->qname, env); + } + + module_desc->qname = axutil_qname_clone((axutil_qname_t *)qname, env); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_module_desc_add_op( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axis2_op_t * op) +{ + const axutil_qname_t *op_qname = NULL; + axis2_char_t *op_name = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE); + + if(!(module_desc->ops)) + { + module_desc->ops = axutil_hash_make(env); + if(!module_desc->ops) + return AXIS2_FAILURE; + } + + op_qname = axis2_op_get_qname(op, env); + + if(!op_qname) + { + return AXIS2_FAILURE; + } + op_name = axutil_qname_to_string((axutil_qname_t *)op_qname, env); + axutil_hash_set(module_desc->ops, op_name, AXIS2_HASH_KEY_STRING, op); + + return AXIS2_SUCCESS; +} + +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) +{ + return module_desc->ops; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_module_desc_get_parent( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env) +{ + return module_desc->parent; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_module_desc_set_parent( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axis2_conf_t * parent) +{ + AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE); + + module_desc->parent = parent; + return AXIS2_SUCCESS; +} + +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) +{ + axis2_char_t *param_name_l = NULL; + axis2_status_t ret_status = AXIS2_FAILURE; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + param_name_l = axutil_param_get_name(param, env); + if(!param_name_l) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + if(AXIS2_TRUE == axis2_module_desc_is_param_locked(module_desc, env, param_name_l)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + else + { + ret_status = axutil_param_container_add_param(module_desc->params, env, param); + } + return ret_status; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, name, NULL); + + return axutil_param_container_get_param(module_desc->params, env, name); +} + +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) +{ + return axutil_param_container_get_params(module_desc->params, env); +} + +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) +{ + axis2_bool_t locked = AXIS2_FALSE; + axis2_bool_t ret_state = AXIS2_FALSE; + axutil_param_t *param_l = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE); + + /* checking the locked value of parent */ + if(!module_desc->parent) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MODULE_DESC, AXIS2_FAILURE); + return AXIS2_FALSE; + } + locked = axis2_conf_is_param_locked(module_desc->parent, env, param_name); + + if(AXIS2_TRUE == locked) + { + ret_state = AXIS2_TRUE; + } + else + { + param_l = axis2_module_desc_get_param(module_desc, env, param_name); + if(param_l && AXIS2_TRUE == axutil_param_is_locked(param_l, env)) + ret_state = AXIS2_TRUE; + else + ret_state = AXIS2_FALSE; + + } + return ret_state; +} + +AXIS2_EXTERN axis2_module_t *AXIS2_CALL +axis2_module_desc_get_module( + const axis2_module_desc_t * module_desc, + const axutil_env_t * env) +{ + return module_desc->module; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_module_desc_set_module( + axis2_module_desc_t * module_desc, + const axutil_env_t * env, + axis2_module_t * module) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module, AXIS2_FAILURE); + module_desc->module = module; + return AXIS2_SUCCESS; +} + +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) +{ + return module_desc->params; +} + +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) +{ + return module_desc->flow_container; +} diff --git a/src/core/description/msg.c b/src/core/description/msg.c new file mode 100644 index 0000000..241253a --- /dev/null +++ b/src/core/description/msg.c @@ -0,0 +1,407 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_msg +{ + + /** parent operation */ + axis2_op_t *parent; + + /** list of phases that represent the flow */ + axutil_array_list_t *flow; + + /** name of the message */ + axis2_char_t *name; + + /** XML schema element qname */ + axutil_qname_t *element_qname; + + /** direction of message */ + axis2_char_t *direction; + + /** parameter container to hold message parameters */ + struct axutil_param_container *param_container; + + /** base description struct */ + axis2_desc_t *base; + + /** reference count of this object*/ + int ref; + +}; + +AXIS2_EXTERN axis2_msg_t *AXIS2_CALL +axis2_msg_create( + const axutil_env_t * env) +{ + axis2_msg_t *msg = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + msg = (axis2_msg_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_t)); + + if(!msg) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + msg->param_container = NULL; + msg->parent = NULL; + msg->flow = NULL; + msg->name = NULL; + msg->element_qname = NULL; + msg->direction = NULL; + msg->base = NULL; + msg->ref = 1; + + msg->param_container = (axutil_param_container_t *)axutil_param_container_create(env); + if(!msg->param_container) + { + axis2_msg_free(msg, env); + return NULL; + } + + msg->flow = axutil_array_list_create(env, 0); + if(!msg->flow) + { + axis2_msg_free(msg, env); + return NULL; + } + + msg->base = axis2_desc_create(env); + if(!msg->base) + { + axis2_msg_free(msg, env); + return NULL; + } + + return msg; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_msg_free( + axis2_msg_t * msg, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(--(msg->ref) > 0) + { + return; + } + + if(msg->flow) + { + int i = 0, size = 0; + size = axutil_array_list_size(msg->flow, env); + for(i = 0; i < size; i++) + { + axis2_phase_t *phase = NULL; + phase = axutil_array_list_get(msg->flow, env, i); + if(phase) + axis2_phase_free(phase, env); + } + axutil_array_list_free(msg->flow, env); + } + + if(msg->name) + { + AXIS2_FREE(env->allocator, msg->name); + } + + if(msg->element_qname) + { + axutil_qname_free(msg->element_qname, env); + } + + if(msg->direction) + { + AXIS2_FREE(env->allocator, msg->direction); + } + + if(msg->param_container) + { + axutil_param_container_free(msg->param_container, env); + } + + if(msg->base) + { + axis2_desc_free(msg->base, env); + } + + msg->parent = NULL; + + if(msg) + { + AXIS2_FREE(env->allocator, msg); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_add_param( + axis2_msg_t * msg, + const axutil_env_t * env, + axutil_param_t * param) +{ + axis2_char_t *param_name = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE); + + param_name = axutil_param_get_name(param, env); + if(AXIS2_TRUE == axis2_msg_is_param_locked(msg, env, param_name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return axutil_param_container_add_param(msg->param_container, env, param); +} + +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 * param_name) +{ + AXIS2_PARAM_CHECK(env->error, param_name, NULL); + + return axutil_param_container_get_param(msg->param_container, env, param_name); +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_get_all_params( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, msg->param_container, AXIS2_FALSE); + + return axutil_param_container_get_params(msg->param_container, env); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_set_parent( + axis2_msg_t * msg, + const axutil_env_t * env, + axis2_op_t * op) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + msg->parent = op; + if(op) + { + axis2_desc_set_parent(msg->base, env, axis2_op_get_base(op, env)); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_msg_get_parent( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + return msg->parent; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_msg_get_flow( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + return msg->flow; +} + +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) +{ + axis2_op_t *parent_l = NULL; + axutil_param_t *param_l = NULL; + axis2_bool_t locked = AXIS2_FALSE; + + AXIS2_ENV_CHECK(env, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE); + + /* checking the locked status in parent */ + parent_l = axis2_msg_get_parent(msg, env); + if(parent_l) + { + locked = axis2_op_is_param_locked(parent_l, env, param_name); + } + if(AXIS2_TRUE == locked) + { + return AXIS2_TRUE; + } + else + { + param_l = axis2_msg_get_param(msg, env, param_name); + } + return (param_l && axutil_param_is_locked(param_l, env)); +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + if(msg->flow) + { + axutil_array_list_free(msg->flow, env); + msg->flow = NULL; + } + if(flow) + { + msg->flow = flow; + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_msg_get_direction( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + return msg->direction; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(msg->direction) + { + AXIS2_FREE(env->allocator, msg->direction); + msg->direction = NULL; + } + + if(direction) + { + msg->direction = axutil_strdup(env, direction); + if(!(msg->direction)) + { + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL +axis2_msg_get_element_qname( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + return msg->element_qname; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(msg->element_qname) + { + axutil_qname_free(msg->element_qname, env); + msg->element_qname = NULL; + } + + if(element_qname) + { + msg->element_qname = axutil_qname_clone((axutil_qname_t *)element_qname, env); + if(!(msg->element_qname)) + { + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_msg_get_name( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + return msg->name; +} + +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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(msg->name) + { + AXIS2_FREE(env->allocator, msg->name); + msg->name = NULL; + } + + if(name) + { + msg->name = axutil_strdup(env, name); + if(!(msg->name)) + { + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_msg_get_base( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + return msg->base; +} + +AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL +axis2_msg_get_param_container( + const axis2_msg_t * msg, + const axutil_env_t * env) +{ + return msg->param_container; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_msg_increment_ref( + axis2_msg_t * msg, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + msg->ref++; + return AXIS2_SUCCESS; +} diff --git a/src/core/description/op.c b/src/core/description/op.c new file mode 100644 index 0000000..0cf926c --- /dev/null +++ b/src/core/description/op.c @@ -0,0 +1,1383 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +struct axis2_op +{ + axis2_svc_t *parent; + axis2_desc_t *base; + axis2_msg_recv_t *msg_recv; + + int mep; + /* To store deploy time modules */ + axutil_array_list_t *module_qnames; + axutil_array_list_t *engaged_module_list; + axutil_array_list_t *wsamapping_list; + axis2_bool_t from_module; + axutil_qname_t *qname; + axis2_char_t *msg_exchange_pattern; + axis2_char_t *style; + + /* For REST support */ + axis2_char_t *rest_http_method; + axis2_char_t *rest_http_location; + + /** Parameter container to hold operation related parameters */ + struct axutil_param_container *param_container; +}; + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_op_create( + const axutil_env_t * env) +{ + axis2_op_t *op = NULL; + axis2_msg_t *msg = NULL; + + op = (axis2_op_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_op_t)); + + if(!op) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + + op->parent = NULL; + op->base = NULL; + op->msg_recv = NULL; + op->mep = AXIS2_MEP_CONSTANT_INVALID; + op->param_container = NULL; + op->module_qnames = axutil_array_list_create(env, 0); + op->engaged_module_list = NULL; + op->from_module = AXIS2_FALSE; + op->wsamapping_list = NULL; + op->qname = NULL; + op->msg_exchange_pattern = NULL; + op->style = NULL; + op->rest_http_method = NULL; + op->rest_http_location = NULL; + op->style = axutil_strdup(env, AXIS2_STYLE_DOC); + + op->param_container = (axutil_param_container_t *)axutil_param_container_create(env); + if(!op->param_container) + { + axis2_op_free(op, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Param container creation failed"); + return NULL; + } + + op->base = axis2_desc_create(env); + if(!op->base) + { + axis2_op_free(op, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation base creation failed"); + return NULL; + } + + /* Create and set up children messages */ + msg = axis2_msg_create(env); + if(!msg) + { + axis2_op_free(op, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed"); + return NULL; + } + axis2_msg_set_direction(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_IN); + axis2_msg_set_parent(msg, env, op); + axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg); + + msg = axis2_msg_create(env); + if(!msg) + { + axis2_op_free(op, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed"); + return NULL; + } + axis2_msg_set_direction(msg, env, AXIS2_WSDL_MESSAGE_DIRECTION_OUT); + axis2_msg_set_parent(msg, env, op); + axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg); + + msg = axis2_msg_create(env); + if(!msg) + { + axis2_op_free(op, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed"); + return NULL; + } + axis2_msg_set_parent(msg, env, op); + axis2_msg_set_flow(msg, env, NULL); + axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg); + + msg = axis2_msg_create(env); + if(!msg) + { + axis2_op_free(op, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Child message creation failed"); + return NULL; + } + axis2_msg_set_parent(msg, env, op); + axis2_msg_set_flow(msg, env, NULL); + axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg); + + axis2_op_set_msg_exchange_pattern(op, env, (axis2_char_t *)AXIS2_MEP_URI_IN_OUT); + + return op; +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_op_create_from_module( + const axutil_env_t * env) +{ + axis2_op_t *op = NULL; + + op = (axis2_op_t *)axis2_op_create(env); + op->from_module = AXIS2_TRUE; + return op; +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_op_create_with_qname( + const axutil_env_t * env, + const axutil_qname_t * qname) +{ + axis2_op_t *op = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, qname, NULL); + + op = (axis2_op_t *)axis2_op_create(env); + + if(!op) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation creation failed for %s", + axutil_qname_get_localpart(qname, env)); + return NULL; + } + + status = axis2_op_set_qname(op, env, qname); + if(AXIS2_SUCCESS != status) + { + axis2_op_free(op, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name failed for operation %s", + axutil_qname_get_localpart(qname, env)); + return NULL; + } + + return op; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_op_free( + axis2_op_t * op, + const axutil_env_t * env) +{ + if(op->base) + { + axis2_desc_free(op->base, env); + } + if(op->param_container) + { + axutil_param_container_free(op->param_container, env); + } + + op->parent = NULL; + + if(op->msg_recv) + { + axis2_msg_recv_free(op->msg_recv, env); + } + if(op->module_qnames) + { + int i = 0; + for(i = 0; i < axutil_array_list_size(op->module_qnames, env); i++) + { + axutil_qname_t *module_ref = NULL; + module_ref = axutil_array_list_get(op->module_qnames, env, i); + + if(module_ref) + { + axutil_qname_free(module_ref, env); + } + } + axutil_array_list_free(op->module_qnames, env); + } + if(op->engaged_module_list) + { + axutil_array_list_free(op->engaged_module_list, env); + } + if(op->wsamapping_list) + { + int i = 0; + int size = 0; + size = axutil_array_list_size(op->wsamapping_list, env); + for(i = 0; i < size; i++) + { + axis2_char_t *temp_str = axutil_array_list_get(op->wsamapping_list, env, i); + if(temp_str) + AXIS2_FREE(env->allocator, temp_str); + } + axutil_array_list_free(op->wsamapping_list, env); + } + + if(op->qname) + { + axutil_qname_free(op->qname, env); + } + + if(op->msg_exchange_pattern) + { + AXIS2_FREE(env->allocator, op->msg_exchange_pattern); + } + + if(op->style) + { + AXIS2_FREE(env->allocator, op->style); + } + + if(op->rest_http_method) + { + AXIS2_FREE(env->allocator, op->rest_http_method); + } + + if(op->rest_http_location) + { + AXIS2_FREE(env->allocator, op->rest_http_location); + } + + if(op) + { + AXIS2_FREE(env->allocator, op); + } + + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_op_free_void_arg( + void *op, + const axutil_env_t * env) +{ + axis2_op_t *op_l = NULL; + + op_l = (axis2_op_t *)op; + axis2_op_free(op_l, env); + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_add_param( + axis2_op_t * op, + const axutil_env_t * env, + axutil_param_t * param) +{ + axis2_char_t *param_name = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FALSE); + + param_name = axutil_param_get_name(param, env); + if(AXIS2_TRUE == axis2_op_is_param_locked(op, env, param_name)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked, cannot override", + param_name); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + else + { + status = axutil_param_container_add_param(op->param_container, env, param); + } + + return status; +} + +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 * param_name) +{ + axutil_param_t *param = NULL; + + AXIS2_PARAM_CHECK(env->error, param_name, NULL); + + param = axutil_param_container_get_param(op->param_container, env, param_name); + if(!param && op->parent) + { + param = axis2_svc_get_param(op->parent, env, param_name); + } + return param; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + status = axutil_param_container_delete_param(op->param_container, env, param_name); + return status; + + +} + + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_all_params( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return axutil_param_container_get_params(op->param_container, env); +} + +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) +{ + axis2_svc_t *parent = NULL; + axutil_param_t *param = NULL; + axis2_bool_t locked = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE); + + /* Checking the locked value of parent */ + parent = axis2_op_get_parent(op, env); + if(parent) + { + locked = axis2_svc_is_param_locked(parent, env, param_name); + } + if(locked) + { + return AXIS2_TRUE; + } + param = axis2_op_get_param(op, env, param_name); + return (param && AXIS2_TRUE == axutil_param_is_locked(param, env)); +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, rest_http_method, AXIS2_FAILURE); + + if(op->rest_http_method) + { + AXIS2_FREE(env->allocator, op->rest_http_method); + } + op->rest_http_method = NULL; + if(rest_http_method) + { + op->rest_http_method = axutil_strdup(env, rest_http_method); + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_op_get_rest_http_method( + const axis2_op_t * op, + const axutil_env_t * env) +{ + if(!op) + { + return NULL; + } + if(op->rest_http_method) + { + return op->rest_http_method; + } + else + { + axutil_param_t *param = NULL; + + param = axis2_op_get_param(op, env, AXIS2_DEFAULT_REST_HTTP_METHOD); + + if(!param) + { + return "POST"; /* Added hard-coded string to avoid inclusion of HTTP + * Transport header + */ + } + return (axis2_char_t *)axutil_param_get_value(param, env); + } +} + +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) +{ + axis2_char_t *opname = NULL; + AXIS2_PARAM_CHECK(env->error, rest_http_location, AXIS2_FAILURE); + opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + if(op->rest_http_location) + { + AXIS2_FREE(env->allocator, op->rest_http_location); + } + op->rest_http_location = NULL; + if(rest_http_location) + { + op->rest_http_location = axutil_strdup(env, rest_http_location); + return AXIS2_SUCCESS; + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting rest http location failed for operation %s", + opname); + return AXIS2_FAILURE; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_op_get_rest_http_location( + const axis2_op_t * op, + const axutil_env_t * env) +{ + if(!op) + { + return NULL; + } + return op->rest_http_location; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_set_parent( + axis2_op_t * op, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE); + + if(op->parent) + { + op->parent = NULL; + } + op->parent = svc; + if(svc) + { + axis2_desc_set_parent(op->base, env, axis2_svc_get_base(svc, env)); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_op_get_parent( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->parent; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, msg_recv, AXIS2_FAILURE); + + if(op->msg_recv == msg_recv) + { + return AXIS2_SUCCESS; + } + if(op->msg_recv) + { + axis2_msg_recv_free(op->msg_recv, env); + op->msg_recv = NULL; + } + + op->msg_recv = msg_recv; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL +axis2_op_get_msg_recv( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->msg_recv; +} + +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) +{ + if(op->qname) + { + axutil_qname_free(op->qname, env); + op->qname = NULL; + } + + if(qname) + { + op->qname = axutil_qname_clone((axutil_qname_t *)qname, env); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL +axis2_op_get_qname( + void *op, + const axutil_env_t * env) +{ + return ((axis2_op_t *)op)->qname; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, pattern, AXIS2_FAILURE); + + if(op->msg_exchange_pattern) + { + AXIS2_FREE(env->allocator, op->msg_exchange_pattern); + op->msg_exchange_pattern = NULL; + } + + op->msg_exchange_pattern = axutil_strdup(env, pattern); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_op_get_msg_exchange_pattern( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->msg_exchange_pattern; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_op_get_style( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->style; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, style, AXIS2_FAILURE); + + if(op->style) + { + AXIS2_FREE(env->allocator, op->style); + op->style = NULL; + } + + op->style = axutil_strdup(env, style); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_engage_module( + axis2_op_t * op, + const axutil_env_t * env, + axis2_module_desc_t * moduleref, + axis2_conf_t * conf) +{ + int index = 0; + int size = 0; + axutil_array_list_t *collection_module = NULL; + axis2_module_desc_t *module_desc = NULL; + axis2_phase_resolver_t *pr = NULL; + axis2_bool_t need_to_add = AXIS2_FALSE; + axis2_char_t *opname = NULL; + axis2_char_t *modname = NULL; + + AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + collection_module = op->engaged_module_list; + if(collection_module) + { + size = axutil_array_list_size(collection_module, env); + } + for(index = 0; index < size; index++) + { + const axutil_qname_t *qname1 = NULL; + const axutil_qname_t *qname2 = NULL; + + module_desc = (axis2_module_desc_t *)axutil_array_list_get(collection_module, env, index); + if(!module_desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving a module failed from operation %s engaged module" + " list", opname); + return AXIS2_FAILURE; + } + qname1 = axis2_module_desc_get_qname(module_desc, env); + qname2 = axis2_module_desc_get_qname(moduleref, env); + modname = axutil_qname_get_localpart(qname2, env); + if(axutil_qname_equals(qname1, env, qname2)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Module %s already engaged to operation %s", + modname, opname); + + need_to_add = AXIS2_FALSE; + return AXIS2_FAILURE; + } + + } + pr = axis2_phase_resolver_create_with_config(env, conf); + if(pr) + { + axis2_module_t *module = NULL; + axis2_status_t status = AXIS2_FAILURE; + + status = axis2_phase_resolver_engage_module_to_op(pr, env, op, moduleref); + if(AXIS2_SUCCESS != status) + { + /* Ignore the status */ + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_SUCCESS); + AXIS2_LOG_INFO(env->log, AXIS2_LOG_SI, + "Engaging module %s to operaion %s failed. But ignore this.", modname, opname); + } + module = axis2_module_desc_get_module(moduleref, env); + + if(need_to_add) + { + axutil_array_list_add(collection_module, env, moduleref); + } + } + else + { + return AXIS2_FAILURE; + } + axis2_phase_resolver_free(pr, env); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_add_to_engaged_module_list( + axis2_op_t * op, + const axutil_env_t * env, + axis2_module_desc_t * module_desc) +{ + axis2_module_desc_t *module_desc_l = NULL; + int size = 0; + int index = 0; + const axutil_qname_t *module_qname = NULL; + + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + + if(!op->engaged_module_list) + { + op->engaged_module_list = axutil_array_list_create(env, 0); + } + size = axutil_array_list_size(op->engaged_module_list, env); + + module_qname = axis2_module_desc_get_qname(module_desc, env); + for(index = 0; index < size; index++) + { + const axutil_qname_t *module_qname_l = NULL; + + module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(op-> engaged_module_list, env, + index); + module_qname_l = axis2_module_desc_get_qname(module_desc_l, env); + + if(axutil_qname_equals(module_qname, env, module_qname_l)) + { + return AXIS2_SUCCESS; + } + + } + + return axutil_array_list_add(op->engaged_module_list, env, module_desc); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_remove_from_engaged_module_list( + axis2_op_t * op, + const axutil_env_t * env, + axis2_module_desc_t * module_desc) +{ + axis2_module_desc_t *module_desc_l = NULL; + int size = 0; + int index = 0; + const axutil_qname_t *module_qname = NULL; + + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op->engaged_module_list, AXIS2_FAILURE); + + size = axutil_array_list_size(op->engaged_module_list, env); + + module_qname = axis2_module_desc_get_qname(module_desc, env); + for(index = 0; index < size; index++) + { + const axutil_qname_t *module_qname_l = NULL; + + module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(op-> engaged_module_list, env, + index); + module_qname_l = axis2_module_desc_get_qname(module_desc_l, env); + + if(axutil_qname_equals(module_qname, env, module_qname_l)) + { + axutil_array_list_remove(op->engaged_module_list, env, index); + return AXIS2_SUCCESS; + } + + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_all_modules( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->engaged_module_list; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_op_get_axis_specific_mep_const( + axis2_op_t * op, + const axutil_env_t * env) +{ + int temp = 0; + axis2_char_t *opname = NULL; + + opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + if(op->mep != AXIS2_MEP_CONSTANT_INVALID) + { + return op->mep; + } + + temp = AXIS2_MEP_CONSTANT_INVALID; + + if((axutil_strcmp(AXIS2_MEP_URI_IN_OUT, axis2_op_get_msg_exchange_pattern(op, env)) == 0) || + (axutil_strcmp(AXIS2_MEP_URI_IN_OUT_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0)) + { + temp = AXIS2_MEP_CONSTANT_IN_OUT; + } + else if((axutil_strcmp(AXIS2_MEP_URI_IN_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0) + || (axutil_strcmp(AXIS2_MEP_URI_IN_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0)) + { + temp = AXIS2_MEP_CONSTANT_IN_ONLY; + } + else if((axutil_strcmp(AXIS2_MEP_URI_IN_OPTIONAL_OUT, axis2_op_get_msg_exchange_pattern(op, env))== 0) || + (axutil_strcmp(AXIS2_MEP_URI_IN_OPTIONAL_OUT_WSDL2, axis2_op_get_msg_exchange_pattern(op, env))== 0)) + { + temp = AXIS2_MEP_CONSTANT_IN_OPTIONAL_OUT; + } + else if((axutil_strcmp(AXIS2_MEP_URI_OUT_IN, axis2_op_get_msg_exchange_pattern(op, env)) == 0) || + (axutil_strcmp(AXIS2_MEP_URI_OUT_IN_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0)) + { + temp = AXIS2_MEP_CONSTANT_OUT_IN; + } + else if((axutil_strcmp(AXIS2_MEP_URI_OUT_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0) || + (axutil_strcmp(AXIS2_MEP_URI_OUT_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0)) + { + temp = AXIS2_MEP_CONSTANT_OUT_ONLY; + } + else if((axutil_strcmp(AXIS2_MEP_URI_OUT_OPTIONAL_IN, axis2_op_get_msg_exchange_pattern(op, env)) == 0) || + (axutil_strcmp(AXIS2_MEP_URI_OUT_OPTIONAL_IN_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0)) + { + temp = AXIS2_MEP_CONSTANT_OUT_OPTIONAL_IN; + } + else if((axutil_strcmp(AXIS2_MEP_URI_ROBUST_IN_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0) || + (axutil_strcmp(AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0)) + { + temp = AXIS2_MEP_CONSTANT_ROBUST_IN_ONLY; + } + else if((axutil_strcmp(AXIS2_MEP_URI_ROBUST_OUT_ONLY, axis2_op_get_msg_exchange_pattern(op, env)) == 0) || + (axutil_strcmp(AXIS2_MEP_URI_ROBUST_OUT_ONLY_WSDL2, axis2_op_get_msg_exchange_pattern(op, env)) == 0)) + { + temp = AXIS2_MEP_CONSTANT_ROBUST_OUT_ONLY; + } + if(temp == AXIS2_MEP_CONSTANT_INVALID) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Could not map the MEP URI %s to an Axis2/C MEP constant value " + "in retrieving MEP for operation %s", axis2_op_get_msg_exchange_pattern(op, env), + opname); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_COULD_NOT_MAP_MEP_URI_TO_MEP_CONSTANT, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + op->mep = temp; + return op->mep; + +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_fault_in_flow( + const axis2_op_t * op, + const axutil_env_t * env) +{ + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN_FAULT); + if(msg) + { + return axis2_msg_get_flow(msg, env); + } + } + return NULL; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_fault_out_flow( + const axis2_op_t * op, + const axutil_env_t * env) +{ + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT_FAULT); + if(msg) + { + return axis2_msg_get_flow(msg, env); + } + } + return NULL; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_out_flow( + const axis2_op_t * op, + const axutil_env_t * env) +{ + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT); + if(msg) + { + return axis2_msg_get_flow(msg, env); + } + } + return NULL; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_in_flow( + const axis2_op_t * op, + const axutil_env_t * env) +{ + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN); + if(msg) + { + return axis2_msg_get_flow(msg, env); + } + } + return NULL; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE); + + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN_FAULT); + if(msg) + { + return axis2_msg_set_flow(msg, env, list); + } + } + return 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) +{ + AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE); + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT_FAULT); + if(msg) + { + return axis2_msg_set_flow(msg, env, list); + } + } + return 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) +{ + AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE); + + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_OUT); + if(msg) + { + return axis2_msg_set_flow(msg, env, list); + } + } + + return 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) +{ + AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE); + + if(op->base) + { + axis2_msg_t *msg = NULL; + msg = axis2_desc_get_child(op->base, env, AXIS2_MSG_IN); + if(msg) + { + return axis2_msg_set_flow(msg, env, list); + } + } + return 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) +{ + axutil_qname_t *module_qname_l = NULL; + + AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE); + module_qname_l = axutil_qname_clone((axutil_qname_t *)module_qname, env); + + return axutil_array_list_add(op->module_qnames, env, module_qname_l); +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_all_module_qnames( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->module_qnames; +} + +AXIS2_EXTERN axis2_op_ctx_t *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) +{ + axis2_op_ctx_t *op_ctx = NULL; + axis2_relates_to_t *relates_to = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *opname = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, svc_ctx, NULL); + + opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env); + if(!relates_to) + { + op_ctx = axis2_op_ctx_create(env, op, svc_ctx); + if(!op_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating operation context failed for operation %s", opname); + return NULL; + } + } + else + { + axis2_conf_ctx_t *conf_ctx = NULL; + const axis2_char_t *value = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + value = axis2_relates_to_get_value(relates_to, env); + op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, value); + if(!op_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Cannot correlate message to %s for operation %s", value, opname); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CANNOT_CORRELATE_MSG, AXIS2_FAILURE); + return NULL; + } + } + + status = axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx); + if(AXIS2_FAILURE == status) + { + axis2_op_ctx_free(op_ctx, env); + return NULL; + } + else + { + return op_ctx; + } +} + +AXIS2_EXTERN axis2_op_ctx_t *AXIS2_CALL +axis2_op_find_existing_op_ctx( + axis2_op_t * op, + const axutil_env_t * env, + const axis2_msg_ctx_t * msg_ctx) +{ + axis2_op_ctx_t *op_ctx = NULL; + axis2_relates_to_t *relates_to = NULL; + axis2_char_t *opname = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + return op_ctx; + } + + relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env); + if(!relates_to) + { + return NULL; + } + else + { + axis2_conf_ctx_t *conf_ctx = NULL; + const axis2_char_t *value = NULL; + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + value = axis2_relates_to_get_value(relates_to, env); + op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, value); + + if(!op_ctx) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "Cannot correlate message to %s for operation %s", value, opname); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CANNOT_CORRELATE_MSG, AXIS2_FAILURE); + return NULL; + } + } + + return op_ctx; + +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_register_op_ctx( + axis2_op_t * op, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_op_ctx_t * op_ctx) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + const axis2_char_t *msg_id = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *opname = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE); + + opname = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Configuration context not found for message context while " + "registering operation context for operation %s", opname); + return AXIS2_FAILURE; + } + + status = axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx); + + if(AXIS2_SUCCESS != status) + { + axutil_hash_t *op_ctx_map = NULL; + + msg_id = axis2_msg_ctx_get_msg_id(msg_ctx, env); + if(msg_id) + { + op_ctx_map = (axutil_hash_t *)axis2_conf_ctx_get_op_ctx_map(conf_ctx, env); + axutil_hash_set(op_ctx_map, msg_id, AXIS2_HASH_KEY_STRING, NULL); + } + else + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "Message id not found for message context while registering operation context " + "for operation %s. The reason could be that there is no addressing enabled for " + "communication", opname); + } + } + if(axis2_op_ctx_get_is_complete(op_ctx, env)) + { + axis2_op_ctx_cleanup(op_ctx, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_add_msg_ctx_in_only( + axis2_op_t * op, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_op_ctx_t * op_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE); + + if(!axis2_op_ctx_get_is_complete(op_ctx, env)) + { + axis2_msg_ctx_t **msg_ctxs = NULL; + msg_ctxs = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + msg_ctxs[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx; + axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid message; adding operation context for the " + "operation :%s is already completed", axutil_qname_get_localpart( + axis2_op_get_qname(op, env), env)); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_add_msg_ctx_out_only( + axis2_op_t * op, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_op_ctx_t * op_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE); + + if(!axis2_op_ctx_get_is_complete(op_ctx, env)) + { + axis2_msg_ctx_t **msg_ctxs = NULL; + msg_ctxs = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + msg_ctxs[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx; + axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid message; adding operation context for the " + "operation :%s is already completed", axutil_qname_get_localpart( + axis2_op_get_qname(op, env), env)); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_add_msg_ctx_in_out( + axis2_op_t * op, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_op_ctx_t * op_ctx) +{ + axis2_msg_ctx_t **mep = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t *out_msg_ctx = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE); + + mep = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + in_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_IN]; + out_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + + if(in_msg_ctx && out_msg_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid message; adding operation context for the " + "operation :%s is invalid", axutil_qname_get_localpart(axis2_op_get_qname(op, env), + env)); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + if(!in_msg_ctx) + { + mep[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx; + } + else + { + mep[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx; + axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_op_add_msg_ctx_out_in( + axis2_op_t * op, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_op_ctx_t * op_ctx) +{ + axis2_msg_ctx_t **mep = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t *out_msg_ctx = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op_ctx, AXIS2_FAILURE); + + mep = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + in_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_IN]; + out_msg_ctx = mep[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + if(in_msg_ctx && out_msg_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid message; adding operation context for the " + "operation :%s is invalid", axutil_qname_get_localpart(axis2_op_get_qname(op, env), + env)); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MESSAGE_ADDITION, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + if(!out_msg_ctx) + { + mep[AXIS2_WSDL_MESSAGE_LABEL_OUT] = msg_ctx; + } + else + { + mep[AXIS2_WSDL_MESSAGE_LABEL_IN] = msg_ctx; + axis2_op_ctx_set_complete(op_ctx, env, AXIS2_TRUE); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_msg_t *AXIS2_CALL +axis2_op_get_msg( + const axis2_op_t * op, + const axutil_env_t * env, + const axis2_char_t * label) +{ + AXIS2_PARAM_CHECK(env->error, label, NULL); + + return (axis2_msg_t *)axis2_desc_get_child(op->base, env, label); +} + +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 axis2_msg_t * msg) +{ + AXIS2_PARAM_CHECK(env->error, label, AXIS2_FAILURE); + + return axis2_desc_add_child(op->base, env, label, msg); +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_op_is_from_module( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->from_module; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, mapping_list, AXIS2_FAILURE); + + if(op->wsamapping_list) + { + int i = 0; + int size = 0; + size = axutil_array_list_size(op->wsamapping_list, env); + for(i = 0; i < size; i++) + { + axis2_char_t *temp_str = axutil_array_list_get(op->wsamapping_list, env, i); + if(temp_str) + AXIS2_FREE(env->allocator, temp_str); + } + axutil_array_list_free(op->wsamapping_list, env); + op->wsamapping_list = NULL; + } + op->wsamapping_list = mapping_list; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_op_get_wsamapping_list( + axis2_op_t * op, + const axutil_env_t * env) +{ + return op->wsamapping_list; +} + +AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL +axis2_op_get_param_container( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->param_container; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_op_get_base( + const axis2_op_t * op, + const axutil_env_t * env) +{ + return op->base; +} + diff --git a/src/core/description/phase_rule.c b/src/core/description/phase_rule.c new file mode 100644 index 0000000..bb4cfea --- /dev/null +++ b/src/core/description/phase_rule.c @@ -0,0 +1,254 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_phase_rule +{ + + /** name of phase or handler before */ + axis2_char_t *before; + + /** name of phase or handler after */ + axis2_char_t *after; + + /** phase name */ + axis2_char_t *name; + + /** Is this first in phase? */ + axis2_bool_t first; + + /** Is this last in phase? */ + axis2_bool_t last; + +}; + +AXIS2_EXTERN axis2_phase_rule_t *AXIS2_CALL +axis2_phase_rule_create( + const axutil_env_t * env, + const axis2_char_t * name) +{ + axis2_phase_rule_t *phase_rule = NULL; + + phase_rule = AXIS2_MALLOC(env->allocator, sizeof(axis2_phase_rule_t)); + if(!phase_rule) + { + AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY); + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE); + return NULL; + } + + phase_rule->before = NULL; + phase_rule->after = NULL; + phase_rule->name = NULL; + phase_rule->first = AXIS2_FALSE; + phase_rule->last = AXIS2_FALSE; + + if(name) + { + phase_rule->name = axutil_strdup(env, name); + } + + return phase_rule; +} + +const axis2_char_t *AXIS2_CALL +axis2_phase_rule_get_before( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env) +{ + return phase_rule->before; +} + +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) +{ + if(phase_rule->before) + { + AXIS2_FREE(env->allocator, phase_rule->before); + } + + if(before) + { + phase_rule->before = axutil_strdup(env, before); + if(!phase_rule->before) + { + AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY); + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_phase_rule_get_after( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env) +{ + return phase_rule->after; +} + +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) +{ + if(phase_rule->after) + { + AXIS2_FREE(env->allocator, phase_rule->after); + } + + if(after) + { + phase_rule->after = axutil_strdup(env, after); + if(!phase_rule->after) + { + AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY); + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_phase_rule_get_name( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env) +{ + return phase_rule->name; +} + +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) +{ + if(phase_rule->name) + { + AXIS2_FREE(env->allocator, phase_rule->name); + } + + if(name) + { + phase_rule->name = axutil_strdup(env, name); + if(!phase_rule->name) + { + AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY); + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_phase_rule_is_first( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env) +{ + return phase_rule->first; +} + +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) +{ + phase_rule->first = first; + return AXIS2_SUCCESS; +} + +axis2_bool_t AXIS2_CALL +axis2_phase_rule_is_last( + const axis2_phase_rule_t * phase_rule, + const axutil_env_t * env) +{ + return phase_rule->last; +} + +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) +{ + phase_rule->last = last; + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_phase_rule_free( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env) +{ + if(phase_rule->before) + { + AXIS2_FREE(env->allocator, phase_rule->before); + } + + if(phase_rule->after) + { + AXIS2_FREE(env->allocator, phase_rule->after); + } + + if(phase_rule->name) + { + AXIS2_FREE(env->allocator, phase_rule->name); + } + + AXIS2_FREE(env->allocator, phase_rule); + + return; +} + +axis2_phase_rule_t *AXIS2_CALL +axis2_phase_rule_clone( + axis2_phase_rule_t * phase_rule, + const axutil_env_t * env) +{ + axis2_phase_rule_t *phase_rule_new = NULL; + + phase_rule_new = axis2_phase_rule_create(env, NULL); + if(!phase_rule_new) + return NULL; + + axis2_phase_rule_set_before(phase_rule_new, env, axis2_phase_rule_get_before(phase_rule, env)); + + axis2_phase_rule_set_after(phase_rule_new, env, axis2_phase_rule_get_after(phase_rule, env)); + + axis2_phase_rule_set_name(phase_rule_new, env, axis2_phase_rule_get_name(phase_rule, env)); + + axis2_phase_rule_set_first(phase_rule_new, env, axis2_phase_rule_is_first(phase_rule, env)); + + axis2_phase_rule_set_last(phase_rule_new, env, axis2_phase_rule_is_last(phase_rule, env)); + + return phase_rule_new; +} + diff --git a/src/core/description/policy_include.c b/src/core/description/policy_include.c new file mode 100644 index 0000000..5ce93f8 --- /dev/null +++ b/src/core/description/policy_include.c @@ -0,0 +1,612 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_policy_include +{ + neethi_policy_t *policy; + + neethi_policy_t *effective_policy; + + neethi_registry_t *registry; + + axis2_desc_t *desc; + + axutil_hash_t *wrapper_elements; +}; + +typedef struct axis2_policy_wrapper +{ + int type; + void *value; +} axis2_policy_wrapper_t; + +AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL +axis2_policy_include_create( + const axutil_env_t * env) +{ + axis2_policy_include_t *policy_include = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + policy_include = (axis2_policy_include_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_policy_include_t)); + + if(!policy_include) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + policy_include->policy = NULL; + policy_include->effective_policy = NULL; + policy_include->registry = NULL; + policy_include->desc = NULL; + policy_include->wrapper_elements = NULL; + + policy_include->registry = neethi_registry_create(env); + if(!policy_include->registry) + { + axis2_policy_include_free(policy_include, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + policy_include->wrapper_elements = axutil_hash_make(env); + if(!policy_include->wrapper_elements) + { + axis2_policy_include_free(policy_include, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return policy_include; +} + +AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL +axis2_policy_include_create_with_desc( + const axutil_env_t * env, + axis2_desc_t * desc) +{ + axis2_policy_include_t *policy_include = NULL; + axis2_desc_t *parent_desc = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + policy_include = (axis2_policy_include_t *)axis2_policy_include_create(env); + + parent_desc = axis2_desc_get_parent(desc, env); + + if(policy_include->registry) + { + neethi_registry_free(policy_include->registry, env); + policy_include->registry = NULL; + } + + if(parent_desc) + { + axis2_policy_include_t *preant_policy_include = axis2_desc_get_policy_include(parent_desc, + env); + if(preant_policy_include) + { + policy_include->registry = neethi_registry_create_with_parent(env, + axis2_policy_include_get_registry(preant_policy_include, env)); + } + else + { + policy_include->registry = neethi_registry_create(env); + } + } + else + { + policy_include->registry = neethi_registry_create(env); + } + + policy_include->desc = desc; + + return policy_include; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_policy_include_free( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(policy_include->registry) + { + neethi_registry_free(policy_include->registry, env); + } + + if(policy_include->wrapper_elements) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi + = axutil_hash_next(env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + if(wrapper) + AXIS2_FREE(env->allocator, wrapper); + val = NULL; + wrapper = NULL; + } + axutil_hash_free(policy_include->wrapper_elements, env); + } + + if(policy_include) + { + AXIS2_FREE(env->allocator, policy_include); + } + + return; +} + +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_ENV_CHECK(env, AXIS2_FAILURE); + + if(policy_include->registry) + { + neethi_registry_free(policy_include->registry, env); + } + + policy_include->registry = registry; + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN neethi_registry_t *AXIS2_CALL +axis2_policy_include_get_registry( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + return policy_include->registry; +} + +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_ENV_CHECK(env, AXIS2_FAILURE); + + if(policy_include->wrapper_elements) + { + axutil_hash_free(policy_include->wrapper_elements, env); + policy_include->wrapper_elements = NULL; + } + + policy_include->wrapper_elements = axutil_hash_make(env); + + if(!neethi_policy_get_name(policy, env) && !neethi_policy_get_id(policy, env)) + { + neethi_policy_set_id(policy, env, axutil_uuid_gen(env)); + } + + if(policy_include->wrapper_elements) + { + axis2_policy_wrapper_t *wrapper = NULL; + + wrapper = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_policy_wrapper_t)); + if(wrapper) + { + axis2_char_t *policy_name = NULL; + wrapper->type = AXIS2_ANON_POLICY; + wrapper->value = policy; + + policy_name = neethi_policy_get_name(policy, env); + + if(policy_name) + { + axutil_hash_set(policy_include->wrapper_elements, policy_name, + AXIS2_HASH_KEY_STRING, wrapper); + } + else + { + axutil_hash_set(policy_include->wrapper_elements, + neethi_policy_get_id(policy, env), AXIS2_HASH_KEY_STRING, wrapper); + } + } + } + return AXIS2_SUCCESS; +} + +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_char_t *key; + axis2_policy_wrapper_t *wrapper = NULL; + + key = neethi_policy_get_name(policy, env); + if(!key) + key = neethi_policy_get_id(policy, env); + + if(!key) + { + return AXIS2_FAILURE; + } + + wrapper = axutil_hash_get(policy_include->wrapper_elements, key, AXIS2_HASH_KEY_STRING); + if(wrapper) + { + wrapper->value = policy; + return AXIS2_SUCCESS; + } + + return AXIS2_FAILURE; +} + +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) +{ + policy_include->effective_policy = effective_policy; + return AXIS2_SUCCESS; +} + +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) +{ + policy_include->desc = desc; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_policy_include_get_desc( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + return policy_include->desc; +} + +AXIS2_EXTERN axis2_policy_include_t *AXIS2_CALL +axis2_policy_include_get_parent( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + if(policy_include->desc) + { + axis2_desc_t *parent = NULL; + parent = axis2_desc_get_parent(policy_include->desc, env); + if(parent) + { + return axis2_desc_get_policy_include(parent, env); + } + } + + return NULL; +} + +static axis2_status_t +axis2_policy_include_calculate_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + neethi_policy_t *result = NULL; + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next( + env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + + if(wrapper) + { + neethi_policy_t *policy = NULL; + if(wrapper->type == AXIS2_POLICY_REF) + { + neethi_reference_t *reference = (neethi_reference_t *)wrapper->value; + if(reference) + { + /* TOOD add neethi_reference_normalize + policy = (neethi_policy_t*) neethi_reference_normalize( + reference, env, policy_include->registry, AXIS2_FALSE); + */ + } + } + else + { + policy = (neethi_policy_t *)wrapper->value; + } + + result = (result == NULL) ? (neethi_policy_t *)policy + : (neethi_policy_t *)neethi_engine_merge(env, result, policy); + } + } + + policy_include->policy = result; + return AXIS2_SUCCESS; +} + +static neethi_policy_t * +axis2_policy_include_calculate_effective_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + neethi_policy_t *result; + axis2_policy_include_t *parent = NULL; + + parent = axis2_policy_include_get_parent(policy_include, env); + + if(parent) + { + neethi_policy_t *parent_policy = axis2_policy_include_get_effective_policy(parent, env); + + if(!parent_policy) + { + result = axis2_policy_include_get_policy(policy_include, env); + + } + else + { + if(axis2_policy_include_get_policy(policy_include, env)) + { + neethi_policy_t *temp_policy = NULL; + parent_policy = (neethi_policy_t *)neethi_engine_get_normalize(env, AXIS2_FALSE, + parent_policy); + temp_policy = axis2_policy_include_get_policy(policy_include, env); + temp_policy = (neethi_policy_t *)neethi_engine_get_normalize(env, AXIS2_FALSE, + temp_policy); + /* result = (neethi_policy_t*) neethi_engine_merge(env, parent_policy, + axis2_policy_include_get_policy(policy_include, env)); */ + result = (neethi_policy_t *)neethi_engine_merge(env, parent_policy, temp_policy); + + } + else + { + result = parent_policy; + } + } + } + else + { + result = axis2_policy_include_get_policy(policy_include, env); + } + + return result; + /*policy_include->effective_policy = result; + return AXIS2_SUCCESS; */ +} + +AXIS2_EXTERN neethi_policy_t *AXIS2_CALL +axis2_policy_include_get_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + axis2_policy_include_calculate_policy(policy_include, env); + return policy_include->policy; +} + +AXIS2_EXTERN neethi_policy_t *AXIS2_CALL +axis2_policy_include_get_effective_policy( + axis2_policy_include_t * policy_include, + const axutil_env_t * env) +{ + /*if (policy_include->effective_policy) + return policy_include->effective_policy; + */ + return axis2_policy_include_calculate_effective_policy(policy_include, env); + /*return policy_include->effective_policy; */ +} + +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) +{ + axutil_array_list_t *policy_elements_list = NULL; + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + policy_elements_list = axutil_array_list_create(env, 10); + + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next( + env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + + if(wrapper) + { + axutil_array_list_add(policy_elements_list, env, wrapper->value); + } + } + return policy_elements_list; +} + +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) +{ + axutil_array_list_t *policy_elements_list = NULL; + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + policy_elements_list = axutil_array_list_create(env, 10); + + for(hi = axutil_hash_first(policy_include->wrapper_elements, env); hi; hi = axutil_hash_next( + env, hi)) + { + axis2_policy_wrapper_t *wrapper = NULL; + + axutil_hash_this(hi, NULL, NULL, &val); + wrapper = (axis2_policy_wrapper_t *)val; + + if(wrapper && wrapper->type == type) + { + axutil_array_list_add(policy_elements_list, env, wrapper->value); + } + } + return policy_elements_list; +} + +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 * policy) +{ + if(policy_include->registry) + { + return neethi_registry_register(policy_include->registry, env, key, policy); + } + return AXIS2_FAILURE; +} + +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) +{ + if(policy_include->registry) + { + return neethi_registry_lookup(policy_include->registry, env, key); + } + return NULL; +} + +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_ENV_CHECK(env, AXIS2_FAILURE); + + if(!neethi_policy_get_name(policy, env) && !neethi_policy_get_id(policy, env)) + { + axis2_char_t *uuid = axutil_uuid_gen(env); + neethi_policy_set_id(policy, env, uuid); + if(uuid) + { + AXIS2_FREE(env->allocator, uuid); + uuid = NULL; + } + } + + if(policy_include->wrapper_elements) + { + axis2_policy_wrapper_t *wrapper = NULL; + + wrapper = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_policy_wrapper_t)); + if(wrapper) + { + axis2_char_t *policy_name = NULL; + wrapper->type = type; + wrapper->value = policy; + + policy_name = neethi_policy_get_name(policy, env); + if(!policy_name) + policy_name = neethi_policy_get_id(policy, env); + + if(policy_name) + { + axutil_hash_set(policy_include->wrapper_elements, policy_name, + AXIS2_HASH_KEY_STRING, wrapper); + if(policy_include->registry) + { + neethi_registry_register(policy_include->registry, env, policy_name, policy); + } + return AXIS2_SUCCESS; + } + } + } + return AXIS2_FAILURE; +} + +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_policy_wrapper_t *wrapper = NULL; + + wrapper + = (axis2_policy_wrapper_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_policy_wrapper_t)); + if(wrapper) + { + wrapper->type = type; + wrapper->value = reference; + axutil_hash_set(policy_include->wrapper_elements, neethi_reference_get_uri(reference, env), + AXIS2_HASH_KEY_STRING, wrapper); + } + return AXIS2_SUCCESS; +} + +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) +{ + if(policy_include->wrapper_elements) + { + axutil_hash_set(policy_include->wrapper_elements, policy_uri, AXIS2_HASH_KEY_STRING, NULL); + } + if(policy_include->registry) + { + neethi_registry_register(policy_include->registry, env, policy_uri, NULL); + } + return AXIS2_SUCCESS; +} + +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) +{ + if(policy_include->wrapper_elements) + { + axutil_hash_free(policy_include->wrapper_elements, env); + } + return AXIS2_SUCCESS; +} diff --git a/src/core/description/svc.c b/src/core/description/svc.c new file mode 100644 index 0000000..72f4597 --- /dev/null +++ b/src/core/description/svc.c @@ -0,0 +1,1543 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include "../deployment/axis2_desc_builder.h" +#include +#include +#include + +struct axis2_svc +{ + axis2_svc_grp_t *parent; + axis2_char_t *axis_svc_name; + + /** To keep last update time of the service */ + long last_update; + axis2_char_t *filename; + + /** To store module descriptions at deploy time parsing */ + axutil_array_list_t *module_list; + + /** Service description */ + axis2_char_t *svc_desc; + + /** wsdl file path */ + axis2_char_t *wsdl_path; + + /** service folder path */ + axis2_char_t *folder_path; + + /** + * WSDL related stuff + */ + axutil_hash_t *ns_map; + /* Count of the entries in the namespace map */ + int ns_count; + /* To keep the XML scheama either from WSDL or + * C2WSDL(in the future) + */ + axutil_array_list_t *schema_list; + + /** + * A table that keeps a mapping of unique XSD names (Strings) + * against the schema objects. This is populated in the first + * instance the schemas are asked for and then used to serve + * the subsequent requests + */ + axutil_hash_t *schema_mapping_table; + + /** + * This is where operations are kept + */ + axutil_hash_t *op_alias_map; + + /** + * This is where action mappings are kept + */ + axutil_hash_t *op_action_map; + + /** + * This is where REST mappings are kept + */ + axutil_hash_t *op_rest_map; + + /** + * Keeps track whether the schema locations are adjusted + */ + axis2_bool_t schema_loc_adjusted; + + /** + * A custom schema name prefix. if set this will be used to + * modify the schema names + */ + axis2_char_t *custom_schema_name_prefix; + + /** + * A custom schema name suffix. will be attached to the + * schema file name when the files are uniquely named. + * A good place to add a file extension if needed + */ + axis2_char_t *custom_schema_name_suffix; + /* To store the target namespace for the schema */ + axis2_char_t *schema_target_ns; + axis2_char_t *schema_target_ns_prefix; + /* To keep the service target name space */ + axis2_char_t *target_ns; + axis2_char_t *target_ns_prefix; + /* Used for schema name calculations */ + int sc_calc_count; + + void *impl_class; + axutil_qname_t *qname; + axis2_char_t *style; + axutil_array_list_t *engaged_module_list; + + /** Parameter container to hold service related parameters */ + struct axutil_param_container *param_container; + + /** Flow container that encapsulates the flow related data */ + struct axis2_flow_container *flow_container; + + /** Base description struct */ + axis2_desc_t *base; + + /* Mutex to avoid loading the same service dll twice */ + axutil_thread_mutex_t *mutex; +}; + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_svc_create( + const axutil_env_t * env) +{ + axis2_svc_t *svc = NULL; + + svc = (axis2_svc_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_t)); + if(!svc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + svc->parent = NULL; + svc->axis_svc_name = NULL; + svc->filename = NULL; + svc->svc_desc = NULL; + svc->wsdl_path = NULL; + svc->folder_path = NULL; + svc->last_update = 0; + svc->param_container = NULL; + svc->flow_container = NULL; + svc->op_alias_map = NULL; + svc->op_action_map = NULL; + svc->op_rest_map = NULL; + svc->module_list = NULL; + svc->ns_map = NULL; + svc->ns_count = 0; + svc->schema_list = NULL; + svc->schema_mapping_table = NULL; + svc->schema_loc_adjusted = AXIS2_FALSE; + svc->custom_schema_name_prefix = NULL; + svc->custom_schema_name_suffix = NULL; + svc->schema_target_ns = NULL; + svc->schema_target_ns_prefix = NULL; + svc->target_ns = NULL; + svc->target_ns_prefix = NULL; + svc->sc_calc_count = 0; + svc->impl_class = NULL; + svc->qname = NULL; + svc->style = NULL; + svc->base = NULL; + + svc->param_container = axutil_param_container_create(env); + if(!svc->param_container) + { + axis2_svc_free(svc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service param container creation failed"); + return NULL; + } + + svc->flow_container = axis2_flow_container_create(env); + if(!svc->flow_container) + { + axis2_svc_free(svc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service flow container creation failed"); + return NULL; + } + + svc->op_alias_map = axutil_hash_make(env); + if(!svc->op_alias_map) + { + axis2_svc_free(svc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation alias map creation failed"); + return NULL; + } + + svc->op_action_map = axutil_hash_make(env); + if(!svc->op_action_map) + { + axis2_svc_free(svc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation action map creation failed"); + return NULL; + } + + svc->op_rest_map = axutil_hash_make(env); + if(!svc->op_rest_map) + { + axis2_svc_free(svc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service operation rest map creation failed"); + return NULL; + } + + /** Create module list of default size */ + svc->module_list = axutil_array_list_create(env, 0); + if(!svc->module_list) + { + axis2_svc_free(svc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service module list creation failed"); + return NULL; + } + + svc->schema_list = axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY); + if(!svc->schema_list) + { + axis2_svc_free(svc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service schema list creation failed"); + return NULL; + } + + svc->engaged_module_list = axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY); + if(!svc->engaged_module_list) + { + axis2_svc_free(svc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service engaged modules list creation failed"); + return NULL; + } + + svc->schema_loc_adjusted = AXIS2_FALSE; + if(svc->schema_target_ns_prefix) + { + AXIS2_FREE(env->allocator, svc->schema_target_ns_prefix); + svc->schema_target_ns_prefix = NULL; + } + svc->schema_target_ns_prefix = axutil_strdup(env, "ns"); + + if(svc->target_ns) + { + AXIS2_FREE(env->allocator, svc->target_ns); + svc->target_ns = NULL; + } + svc->target_ns = axutil_strdup(env, "http://ws.apache.org/axis2"); + + if(svc->target_ns_prefix) + { + AXIS2_FREE(env->allocator, svc->target_ns_prefix); + svc->target_ns_prefix = NULL; + } + svc->target_ns_prefix = axutil_strdup(env, "tns"); + svc->sc_calc_count = 0; + + svc->base = axis2_desc_create(env); + if(!svc->base) + { + axis2_svc_free(svc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service base creation failed"); + return NULL; + } + svc->mutex = axutil_thread_mutex_create(env->allocator, AXIS2_THREAD_MUTEX_DEFAULT); + if(!svc->mutex) + { + axis2_svc_free(svc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service mutex creation failed"); + return NULL; + } + return svc; +} + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_svc_create_with_qname( + const axutil_env_t * env, + const axutil_qname_t * qname) +{ + axis2_svc_t *svc = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, qname, NULL); + + svc = axis2_svc_create(env); + if(!svc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service creation failed for name %s", + axutil_qname_get_localpart(qname, env)); + return NULL; + } + + status = axis2_svc_set_qname(svc, env, qname); + if(AXIS2_FAILURE == status) + { + axis2_svc_free(svc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name %s to service failed", + axutil_qname_get_localpart(qname, env)); + return NULL; + } + + return svc; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_free( + axis2_svc_t * svc, + const axutil_env_t * env) +{ + if(svc->impl_class) + { + AXIS2_SVC_SKELETON_FREE((axis2_svc_skeleton_t *)svc->impl_class, env); + } + if(svc->param_container) + { + axutil_param_container_free(svc->param_container, env); + } + + if(svc->flow_container) + { + axis2_flow_container_free(svc->flow_container, env); + } + + if(svc->filename) + { + AXIS2_FREE(env->allocator, svc->filename); + svc->filename = NULL; + } + + if(svc->svc_desc) + { + AXIS2_FREE(env->allocator, svc->svc_desc); + svc->svc_desc = NULL; + } + + svc->parent = NULL; + + if(svc->module_list) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(svc->module_list, env); + for(i = 0; i < size; i++) + { + axutil_qname_t *qname = NULL; + qname = axutil_array_list_get(svc->module_list, env, i); + if(qname) + { + axutil_qname_free(qname, env); + } + } + axutil_array_list_free(svc->module_list, env); + } + + if(svc->schema_list) + { + axutil_array_list_free(svc->schema_list, env); + } + + if(svc->engaged_module_list) + { + axutil_array_list_free(svc->engaged_module_list, env); + } + + if(svc->axis_svc_name) + { + AXIS2_FREE(env->allocator, svc->axis_svc_name); + svc->axis_svc_name = NULL; + } + + if(svc->op_alias_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + for(hi = axutil_hash_first(svc->op_alias_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &val); + + if(val) + { + if(axis2_op_is_from_module((axis2_op_t *)val, env) == AXIS2_FALSE) + { + axis2_op_free((axis2_op_t *)val, env); + } + val = NULL; + } + } + + axutil_hash_free(svc->op_alias_map, env); + } + + if(svc->op_action_map) + { + axutil_hash_index_t *hi = NULL; + const void *key = NULL; + + for(hi = axutil_hash_first(svc->op_action_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, &key, NULL, NULL); + + if(key) + { + AXIS2_FREE(env->allocator, (axis2_char_t *)key); + key = NULL; + } + } + axutil_hash_free(svc->op_action_map, env); + } + + if(svc->op_rest_map) + { + axis2_core_utils_free_rest_map(env, svc->op_rest_map); + } + + if(svc->schema_target_ns_prefix) + { + AXIS2_FREE(env->allocator, svc->schema_target_ns_prefix); + svc->schema_target_ns_prefix = NULL; + } + + if(svc->target_ns) + { + AXIS2_FREE(env->allocator, svc->target_ns); + svc->target_ns = NULL; + } + + if(svc->wsdl_path) + { + AXIS2_FREE(env->allocator, svc->wsdl_path); + svc->wsdl_path = NULL; + } + + if(svc->folder_path) + { + AXIS2_FREE(env->allocator, svc->folder_path); + svc->folder_path = NULL; + } + + if(svc->target_ns_prefix) + { + AXIS2_FREE(env->allocator, svc->target_ns_prefix); + svc->target_ns_prefix = NULL; + } + + if(svc->qname) + { + axutil_qname_free(svc->qname, env); + } + + if(svc->style) + { + AXIS2_FREE(env->allocator, svc->style); + } + + if(svc->base) + { + axis2_desc_free(svc->base, env); + } + if(svc->mutex) + { + axutil_thread_mutex_destroy(svc->mutex); + } + if(svc) + { + AXIS2_FREE(env->allocator, svc); + svc = NULL; + } + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_add_op( + axis2_svc_t * svc, + const axutil_env_t * env, + axis2_op_t * op) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_msg_recv_t *msg_recv = NULL; + const axutil_qname_t *qname = NULL; + axis2_char_t *key = NULL; + const axis2_char_t *svcname = NULL; + axutil_array_list_t *mappings_list = NULL; + int size = 0; + int j = 0; + + AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE); + svcname = axis2_svc_get_name(svc, env); + qname = axis2_op_get_qname(op, env); + if(qname) + key = axutil_qname_get_localpart(qname, env); + mappings_list = axis2_op_get_wsamapping_list(op, env); + /* Adding action mappings into service */ + if(mappings_list) + size = axutil_array_list_size(mappings_list, env); + for(j = 0; j < size; j++) + { + axis2_char_t *mapping = NULL; + + mapping = (axis2_char_t *)axutil_array_list_get(mappings_list, env, j); + status = axis2_svc_add_mapping(svc, env, mapping, op); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding operation %s to service %s mapping list failed", svcname, key); + return status; + } + } + + status = axis2_op_set_parent(op, env, svc); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting service %s as operation %s parent failed", + svcname, key); + return status; + } + msg_recv = axis2_op_get_msg_recv(op, env); + if(msg_recv == NULL) + { + msg_recv = axis2_desc_builder_load_default_msg_recv(env); + axis2_op_set_msg_recv(op, env, msg_recv); + } + if(key) + { + /* If service defines the operation, then we should not override with module level + * operation. Module operations are global. If any setting to be modified, those operations + * can be defined in service */ + if(!axutil_hash_get(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING)) + { + axutil_hash_set(svc->op_alias_map, key, AXIS2_HASH_KEY_STRING, op); + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_svc_get_op_with_qname( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axutil_qname_t * op_qname) +{ + axis2_op_t *op = NULL; + axis2_char_t *nc_name = NULL; + + axis2_char_t *nc_tmp = NULL; + /* This is just for the sake of comparison, + * and must not be used to change the passed value + */ + axis2_bool_t is_matched = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, op_qname, NULL); + + nc_name = axutil_qname_get_localpart(op_qname, env); + nc_tmp = nc_name; + + op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING); + if(op) + { + return op; + } + op = axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING); + if(op) + { + return op; + } + + if(*nc_tmp && svc->op_action_map) + { + axutil_hash_index_t *hi = NULL; + const void *key = NULL; + + for(hi = axutil_hash_first(svc->op_action_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, &key, NULL, NULL); + + nc_tmp = nc_name; + + if(key) + { + axis2_char_t *search = NULL; + axis2_bool_t match_start = AXIS2_TRUE; + axis2_char_t *search_tmp = NULL; + + search = (axis2_char_t *)key; + + if(!axutil_strchr(search, '*')) + { + if(axutil_strstr(nc_tmp, search)) + { + axis2_char_t *comp_tmp = NULL; + + comp_tmp = axutil_strstr(nc_tmp, search); + if(strlen(comp_tmp) == strlen(search)) + { + nc_tmp = (axis2_char_t *)key; + is_matched = AXIS2_TRUE; + break; + } + } + continue; + } + + if(search[0] == '*') + { + search++; + if(!*search) + { + nc_tmp = (axis2_char_t *)key; + is_matched = AXIS2_TRUE; + break; + } + else if(axutil_strchr(search, '*')) + { + continue; + } + match_start = AXIS2_FALSE; + } + while(search && *search) + { + int length = 0; + axis2_char_t *loc_tmp = NULL; + + if(search_tmp) + { + AXIS2_FREE(env->allocator, search_tmp); + search_tmp = NULL; + } + loc_tmp = axutil_strchr(search, '*'); + if(loc_tmp && *loc_tmp) + { + if(!loc_tmp[1]) + { + is_matched = AXIS2_TRUE; + break; + } + length = (int)(loc_tmp - search); + /* We are sure that the difference lies within the int range */ + search_tmp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * (length + 1))); + strncpy(search_tmp, search, length); + search_tmp[length] = '\0'; + } + else if(axutil_strstr(nc_tmp, search)) + { + axis2_char_t *comp_tmp = NULL; + + comp_tmp = axutil_strstr(nc_tmp, search); + if(strlen(comp_tmp) == strlen(search)) + { + nc_tmp = (axis2_char_t *)key; + is_matched = AXIS2_TRUE; + break; + } + break; + } + else + { + break; + } + if(search_tmp && axutil_strstr(nc_tmp, search_tmp)) + { + if(match_start && !(axutil_strncmp(nc_tmp, search, length) == 0)) + { + break; + } + else if(!match_start) + { + match_start = AXIS2_TRUE; + } + } + else + { + break; + } + search += axutil_strlen(search_tmp) + 1; + nc_tmp = axutil_strstr(nc_tmp, search_tmp) + axutil_strlen(search_tmp); + } + if(search_tmp) + { + AXIS2_FREE(env->allocator, search_tmp); + search_tmp = NULL; + } + if(is_matched || !*search) + { + nc_tmp = (axis2_char_t *)key; + is_matched = AXIS2_TRUE; + break; + } + } + } + } + if(!is_matched) + { + nc_tmp = nc_name; + } + + op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING); + if(op) + { + return op; + } + return (axis2_op_t *)axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING); +} + +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 * method, + const axis2_char_t * location) +{ + axutil_array_list_t *op_list = NULL; + axis2_char_t *key = NULL; + axis2_char_t *loc_str = NULL; + axis2_char_t *loc_str_tmp = NULL; + axis2_char_t *rindex = NULL; + int plen; + + AXIS2_PARAM_CHECK(env->error, method, NULL); + AXIS2_PARAM_CHECK(env->error, location, NULL); + + loc_str_tmp = (axis2_char_t *)location; /* Casted to facilitate loop */ + if(loc_str_tmp[1] == '/') + { + loc_str_tmp++; + } /* ignore any '/' at the beginning */ + if(strchr(loc_str_tmp, '?')) + { + axis2_char_t *temp = NULL; + + temp = strchr(loc_str_tmp, '?'); + temp[0] = '\0'; + } /* ignore block after '?' */ + do + { + axis2_char_t *temp = NULL; + temp = strchr(loc_str_tmp, '{'); + if(temp) + { + loc_str_tmp = temp; + } + else + { + loc_str_tmp += strlen(loc_str_tmp); + break; + } + } + while(loc_str_tmp[1] && loc_str_tmp[1] == '{'); + + loc_str = (axis2_char_t *)axutil_strmemdup(location, (loc_str_tmp - location), env); + + rindex = axutil_rindex(loc_str, '/'); + if(rindex && *rindex) + { + loc_str_tmp = axutil_string_substring_ending_at(loc_str, (int)(rindex - loc_str)); + /* We are sure that the difference lies within the int range */ + } + else + { + loc_str_tmp = loc_str; + } + + plen = axutil_strlen(method) + axutil_strlen(loc_str_tmp) + 2; + key = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * plen)); + sprintf(key, "%s:%s", method, loc_str_tmp); + AXIS2_FREE(env->allocator, loc_str); + op_list = (axutil_array_list_t *)axutil_hash_get(svc->op_rest_map, key, AXIS2_HASH_KEY_STRING); + AXIS2_FREE(env->allocator, key); + return op_list; +} + +AXIS2_EXTERN axis2_op_t *AXIS2_CALL +axis2_svc_get_op_with_name( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * nc_name) +{ + AXIS2_PARAM_CHECK(env->error, nc_name, NULL); + + return (axis2_op_t *)axutil_hash_get(svc->op_alias_map, nc_name, AXIS2_HASH_KEY_STRING); +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_svc_get_all_ops( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->op_alias_map; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_set_parent( + axis2_svc_t * svc, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp) +{ + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + svc->parent = svc_grp; + if(svc_grp) + { + axis2_desc_set_parent(svc->base, env, axis2_svc_grp_get_base(svc_grp, env)); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL +axis2_svc_get_parent( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->parent; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE); + if(svc->qname) + { + axutil_qname_free(svc->qname, env); + } + + if(qname) + { + svc->qname = axutil_qname_clone((axutil_qname_t *)qname, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axutil_qname_t *AXIS2_CALL +axis2_svc_get_qname( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->qname; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_add_param( + axis2_svc_t * svc, + const axutil_env_t * env, + axutil_param_t * param) +{ + axis2_char_t *paramname = NULL; + const axis2_char_t *svcname = axis2_svc_get_name(svc, env); + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); + paramname = axutil_param_get_name(param, env); + + if(axis2_svc_is_param_locked(svc, env, axutil_param_get_name(param, env))) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for service %s", paramname, + svcname); + return AXIS2_FAILURE; + } + return axutil_param_container_add_param(svc->param_container, env, param); +} + +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) +{ + axutil_param_t *param = NULL; + AXIS2_PARAM_CHECK(env->error, name, NULL); + + param = axutil_param_container_get_param(svc->param_container, env, name); + if(!param && svc->parent) + { + param = axis2_svc_grp_get_param(svc->parent, env, name); + } + return param; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + status = axutil_param_container_delete_param(svc->param_container, env, param_name); + return status; +} + + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_svc_get_all_params( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return axutil_param_container_get_params(svc->param_container, env); +} + +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) +{ + axis2_bool_t locked = AXIS2_FALSE; + axutil_param_t *param = NULL; + axis2_svc_grp_t *parent = NULL; + axis2_bool_t ret = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE); + + /* Checking the locked value of parent */ + + parent = axis2_svc_get_parent(svc, env); + if(parent) + locked = axis2_svc_grp_is_param_locked(parent, env, param_name); + if(parent && locked) + { + return AXIS2_TRUE; + } + param = axis2_svc_get_param(svc, env, param_name); + if(param) + { + ret = axutil_param_is_locked(param, env); + } + return ret; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_engage_module( + axis2_svc_t * svc, + const axutil_env_t * env, + axis2_module_desc_t * module_desc, + axis2_conf_t * conf) +{ + axis2_phase_resolver_t *phase_resolver = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axis2_char_t *svcname = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_engage_module"); + + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + + svcname = axis2_svc_get_name(svc, env); + phase_resolver = axis2_phase_resolver_create_with_config(env, conf); + if(!phase_resolver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s", + svcname); + + return AXIS2_FAILURE; + } + + status = axis2_phase_resolver_engage_module_to_svc(phase_resolver, env, svc, module_desc); + if(status) + { + const axutil_qname_t *qname = NULL; + status = axutil_array_list_add(svc->engaged_module_list, env, module_desc); + qname = axis2_module_desc_get_qname(module_desc, env); + axis2_svc_add_module_qname(svc, env, qname); + } + + if(phase_resolver) + { + axis2_phase_resolver_free(phase_resolver, env); + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_engage_module"); + + return status; +} + +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) +{ + int i = 0, size = 0; + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_is_module_engaged"); + size = axutil_array_list_size(svc->engaged_module_list, env); + for(i = 0; i < size; i++) + { + const axutil_qname_t *module_qname_l = NULL; + axis2_module_desc_t *module_desc_l = NULL; + + module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(svc->engaged_module_list, env, + i); + module_qname_l = axis2_module_desc_get_qname(module_desc_l, env); + + if(axutil_qname_equals(module_qname, env, module_qname_l)) + { + return AXIS2_TRUE; + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_is_module_engaged"); + return AXIS2_FALSE; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_svc_get_engaged_module_list( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->engaged_module_list; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_disengage_module( + axis2_svc_t * svc, + const axutil_env_t * env, + axis2_module_desc_t * module_desc, + axis2_conf_t * conf) +{ + axis2_phase_resolver_t *phase_resolver = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axis2_char_t *svcname = NULL; + + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + svcname = axis2_svc_get_name(svc, env); + + phase_resolver = axis2_phase_resolver_create_with_config(env, conf); + if(!phase_resolver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s", + svcname); + return AXIS2_FAILURE; + } + status = axis2_phase_resolver_disengage_module_from_svc(phase_resolver, env, svc, module_desc); + + axis2_phase_resolver_free(phase_resolver, env); + + return status; +} + +/** + * Here we extract all operations defined in module.xml and built execution + * chains for them by calling axis2_phase_resolver_build_execution_chains_for_module_op() + * function. Within that function handlers of the modules defined for that + * operation are added to module operation chains appropriately. + */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_add_module_ops( + axis2_svc_t * svc, + const axutil_env_t * env, + axis2_module_desc_t * module_desc, + axis2_conf_t * conf) +{ + axutil_hash_t *map = NULL; + axutil_hash_index_t *index = NULL; + axis2_phase_resolver_t *phase_resolver = NULL; + axis2_op_t *op_desc = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axis2_char_t *svcname = NULL; + axis2_char_t *modname = NULL; + axis2_char_t *opname = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_add_module_ops"); + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + svcname = axis2_svc_get_name(svc, env); + modname = axutil_qname_get_localpart(axis2_module_desc_get_qname(module_desc, env), env); + map = axis2_module_desc_get_all_ops(module_desc, env); + phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc); + if(!phase_resolver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s", + svcname); + return AXIS2_FAILURE; + } + for(index = axutil_hash_first(map, env); index; index = axutil_hash_next(env, index)) + { + void *v = NULL; + axutil_hash_this(index, NULL, NULL, &v); + op_desc = (axis2_op_t *)v; + opname = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env); + status = axis2_phase_resolver_build_execution_chains_for_module_op(phase_resolver, env, + op_desc); + + if(AXIS2_SUCCESS != status) + { + if(phase_resolver) + { + axis2_phase_resolver_free(phase_resolver, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Builidng module operation %s failed for module %s", opname, modname); + return status; + } + + status = axis2_svc_add_op(svc, env, op_desc); + if(AXIS2_SUCCESS != status) + { + if(phase_resolver) + { + axis2_phase_resolver_free(phase_resolver, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding operation %s to service %s failed", + opname, svcname); + return status; + } + + } + + if(phase_resolver) + { + axis2_phase_resolver_free(phase_resolver, env); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_add_module_ops"); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_get_name( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + if(svc->qname) + { + return axutil_qname_get_localpart(svc->qname, env); + } + + return NULL; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_set_name( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * axis_svc_name) +{ + AXIS2_PARAM_CHECK(env->error, axis_svc_name, AXIS2_FAILURE); + + if(svc->axis_svc_name) + { + AXIS2_FREE(env->allocator, svc->axis_svc_name); + svc->axis_svc_name = NULL; + } + svc->axis_svc_name = axutil_strdup(env, axis_svc_name); + if(!svc->axis_svc_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_set_last_update( + axis2_svc_t * svc, + const axutil_env_t * env) +{ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN long AXIS2_CALL +axis2_svc_get_last_update( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->last_update; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_get_file_name( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->filename; +} + +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 * filename) +{ + AXIS2_PARAM_CHECK(env->error, filename, AXIS2_FAILURE); + + if(svc->filename) + { + AXIS2_FREE(env->allocator, svc->filename); + svc->filename = NULL; + } + svc->filename = (axis2_char_t *)axutil_strdup(env, filename); + if(!svc->filename) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_get_svc_desc( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->svc_desc; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, svc_desc, AXIS2_FAILURE); + + if(svc->svc_desc) + { + AXIS2_FREE(env->allocator, svc->svc_desc); + svc->svc_desc = NULL; + } + svc->svc_desc = (axis2_char_t *)axutil_strdup(env, svc_desc); + if(!svc->svc_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_add_mapping( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * mapping_key, + axis2_op_t * op_desc) +{ + AXIS2_PARAM_CHECK(env->error, mapping_key, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); + + axutil_hash_set(svc->op_action_map, axutil_strdup(env, mapping_key), AXIS2_HASH_KEY_STRING, + op_desc); + return AXIS2_SUCCESS; +} + +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, + axis2_op_t * op_desc) +{ + + axis2_char_t *mapping_url = NULL; + int key_len = 0; + axis2_char_t* question_char = NULL; + axis2_char_t* local_location_str = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + local_location_str = (axis2_char_t *)location; /* Casted to facilitate loop */ + + /* skip the beginning '/' */ + if(*local_location_str == '/') + { + local_location_str++; + } + question_char = axutil_strchr(local_location_str, '?'); + if(question_char) + { + *question_char = '\0'; + } + + key_len = axutil_strlen(method) + axutil_strlen(local_location_str) + 2; + + mapping_url = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * key_len)); + if(!mapping_url) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create the rest mapping url"); + return AXIS2_FAILURE; + } + + sprintf(mapping_url, "%s:%s", method, local_location_str); + + status = axis2_core_utils_prepare_rest_mapping(env, mapping_url, svc->op_rest_map, op_desc); + + if(mapping_url) + { + AXIS2_FREE(env->allocator, mapping_url); + } + + /* restore the question character */ + if(question_char) + { + *question_char = '?'; + } + + return status; +} + +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) +{ + axutil_qname_t *qmodule_qname_l = NULL; + + AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE); + + qmodule_qname_l = axutil_qname_clone((axutil_qname_t *)module_qname, env); + return axutil_array_list_add(svc->module_list, env, qmodule_qname_l); +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_svc_get_all_module_qnames( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->module_list; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_get_target_ns( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->target_ns; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_set_target_ns( + axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * ns) +{ + AXIS2_PARAM_CHECK(env->error, ns, AXIS2_FAILURE); + + if(svc->target_ns) + { + AXIS2_FREE(env->allocator, svc->target_ns); + svc->target_ns = NULL; + } + svc->target_ns = axutil_strdup(env, ns); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_get_target_ns_prefix( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->target_ns_prefix; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, prefix, AXIS2_FAILURE); + + if(svc->target_ns_prefix) + { + AXIS2_FREE(env->allocator, svc->target_ns_prefix); + svc->target_ns_prefix = NULL; + } + svc->target_ns_prefix = axutil_strdup(env, prefix); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_svc_get_ns_map( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->ns_map; +} + +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) +{ + axutil_hash_index_t *hi = NULL; + + AXIS2_PARAM_CHECK(env->error, ns_map, AXIS2_FAILURE); + + if(svc->ns_map) + { + for(hi = axutil_hash_first(svc->ns_map, env); hi; hi = axutil_hash_next(env, hi)) + { + void *value = NULL; + void *key = NULL; + axutil_hash_this(hi, (const void **)&key, NULL, (void **)&value); + if(key) + { + AXIS2_FREE(env->allocator, key); + key = NULL; + } + if(value) + { + AXIS2_FREE(env->allocator, value); + value = NULL; + } + } + axutil_hash_free(svc->ns_map, env); + } + svc->ns_map = ns_map; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_svc_swap_mapping_table( + axis2_svc_t * svc, + const axutil_env_t * env, + axutil_hash_t * orig_table) +{ + axutil_hash_t *new_table = NULL; + axutil_hash_index_t *hi = NULL; + + AXIS2_PARAM_CHECK(env->error, orig_table, NULL); + + new_table = axutil_hash_make(env); + + for(hi = axutil_hash_first(orig_table, env); env; hi = axutil_hash_next(env, hi)) + { + void *value = NULL; + void *key = NULL; + + axutil_hash_this(hi, (const void **)&key, NULL, (void **)&value); + axutil_hash_set(new_table, value, AXIS2_HASH_KEY_STRING, key); + } + return new_table; +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_svc_get_impl_class( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->impl_class; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_set_impl_class( + axis2_svc_t * svc, + const axutil_env_t * env, + void *impl_class) +{ + svc->impl_class = impl_class; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL +axis2_svc_get_param_container( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->param_container; +} + +AXIS2_EXTERN axis2_flow_container_t *AXIS2_CALL +axis2_svc_get_flow_container( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->flow_container; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_get_svc_wsdl_path( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->wsdl_path; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, wsdl_path, AXIS2_FAILURE); + svc->wsdl_path = (axis2_char_t *)axutil_strdup(env, wsdl_path); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_svc_get_svc_folder_path( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->folder_path; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, folder_path, AXIS2_FAILURE); + svc->folder_path = (axis2_char_t *)axutil_strdup(env, folder_path); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_svc_get_base( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->base; +} + +AXIS2_EXTERN axutil_thread_mutex_t * AXIS2_CALL +axis2_svc_get_mutex( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->mutex; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_svc_get_rest_map( + const axis2_svc_t * svc, + const axutil_env_t * env) +{ + return svc->op_rest_map; +} + diff --git a/src/core/description/svc_grp.c b/src/core/description/svc_grp.c new file mode 100644 index 0000000..157b77a --- /dev/null +++ b/src/core/description/svc_grp.c @@ -0,0 +1,600 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_svc_grp +{ + + /** service group name */ + axis2_char_t *svc_grp_name; + + /** map of services */ + axutil_hash_t *svcs; + + /** to store service group modules QNames */ + axutil_array_list_t *module_qname_list; + + /** to store module ref at deploy time parsing */ + axis2_conf_t *parent; + + /** list of module references */ + axutil_array_list_t *module_list; + + /** parameter container to hold service related parameters */ + axutil_param_container_t *param_container; + + /** base description struct */ + axis2_desc_t *base; +}; + +AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL +axis2_svc_grp_create( + const axutil_env_t * env) +{ + axis2_svc_grp_t *svc_grp = NULL; + svc_grp = (axis2_svc_grp_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_grp_t)); + + if(!svc_grp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + svc_grp->param_container = NULL; + svc_grp->module_qname_list = NULL; + svc_grp->svcs = NULL; + svc_grp->parent = NULL; + svc_grp->svc_grp_name = NULL; + svc_grp->module_list = NULL; + svc_grp->base = NULL; + + svc_grp->param_container = axutil_param_container_create(env); + if(!svc_grp->param_container) + { + axis2_svc_grp_free(svc_grp, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating parameter container failed"); + return NULL; + } + + svc_grp->module_qname_list = axutil_array_list_create(env, 20); + if(!svc_grp->module_qname_list) + { + axis2_svc_grp_free(svc_grp, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating module qnames list failed"); + return NULL; + } + + svc_grp->module_list = axutil_array_list_create(env, 0); + if(!svc_grp->module_list) + { + axis2_svc_grp_free(svc_grp, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating modules list failed"); + return NULL; + } + + svc_grp->svcs = axutil_hash_make(env); + if(!svc_grp->svcs) + { + axis2_svc_grp_free(svc_grp, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating services map failed"); + return NULL; + } + + svc_grp->base = axis2_desc_create(env); + if(!svc_grp->base) + { + axis2_svc_grp_free(svc_grp, env); + return NULL; + } + + return svc_grp; +} + +AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL +axis2_svc_grp_create_with_conf( + const axutil_env_t * env, + axis2_conf_t * conf) +{ + axis2_svc_grp_t *svc_grp = NULL; + + AXIS2_PARAM_CHECK(env->error, conf, NULL); + + svc_grp = (axis2_svc_grp_t *)axis2_svc_grp_create(env); + if(svc_grp) + svc_grp->parent = conf; + if(conf) + { + axis2_desc_set_parent(svc_grp->base, env, axis2_conf_get_base(conf, env)); + } + + return svc_grp; + +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_grp_free( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env) +{ + if(svc_grp->param_container) + { + axutil_param_container_free(svc_grp->param_container, env); + } + + if(svc_grp->svc_grp_name) + { + AXIS2_FREE(env->allocator, svc_grp->svc_grp_name); + } + + if(svc_grp->svcs) + { + /* services are freed by arch_file_data */ + axutil_hash_free(svc_grp->svcs, env); + } + + if(svc_grp->module_qname_list) + { + axutil_array_list_free(svc_grp->module_qname_list, env); + } + + if(svc_grp->module_list) + { + axutil_array_list_free(svc_grp->module_list, env); + } + + if(svc_grp->base) + { + axis2_desc_free(svc_grp->base, env); + } + + if(svc_grp) + { + AXIS2_FREE(env->allocator, svc_grp); + } + return; +} + +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 * name) +{ + if(svc_grp->svc_grp_name) + AXIS2_FREE(env->allocator, svc_grp->svc_grp_name); + svc_grp->svc_grp_name = axutil_strdup(env, name); + if(!svc_grp->svc_grp_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No Memory"); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + return svc_grp->svc_grp_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_add_svc( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + axis2_status_t status = AXIS2_FAILURE; + const axutil_qname_t *svc_qname = NULL; + axis2_char_t *svc_name = NULL; + + AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE); + + if(!svc_grp->svcs) + { + svc_grp->svcs = axutil_hash_make(env); + if(!svc_grp->svcs) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating services list failed"); + return AXIS2_FAILURE; + } + } + + svc_qname = axis2_svc_get_qname(svc, env); + svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env); + axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, svc); + + status = axis2_svc_set_last_update(svc, env); + + if(AXIS2_SUCCESS != status) + { + /* remove the previously added service */ + axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting last update failed for service %s", + svc_name); + + return status; + } + + status = axis2_svc_set_parent(svc, env, svc_grp); + if(AXIS2_SUCCESS != status) + { + /* remove the previously added service */ + axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting parent failed for service %s", svc_name); + + return status; + } + + return status; +} + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_svc_grp_get_svc( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + const axutil_qname_t * qname) +{ + axis2_char_t *name = NULL; + + AXIS2_PARAM_CHECK(env->error, qname, NULL); + + name = axutil_qname_to_string((axutil_qname_t *)qname, env); + return (axis2_svc_t *)axutil_hash_get(svc_grp->svcs, name, AXIS2_HASH_KEY_STRING); +} + +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) +{ + return svc_grp->svcs; +} + +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) +{ + axis2_svc_t *svc = NULL; + axis2_char_t *svc_name = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_name, AXIS2_FAILURE); + + svc = axis2_svc_grp_get_svc(svc_grp, env, svc_qname); + + svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env); + axutil_hash_set(svc_grp->svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL); + + return AXIS2_SUCCESS; +} + +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) +{ + const axis2_char_t *svc_grp_name = axis2_svc_grp_get_name(svc_grp, env); + axis2_char_t *param_name = axutil_param_get_name(param, env); + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); + if(axis2_svc_grp_is_param_locked(svc_grp, env, param_name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for service group %s", + param_name, svc_grp_name); + return AXIS2_FAILURE; + } + return axutil_param_container_add_param(svc_grp->param_container, env, param); +} + +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) +{ + axutil_param_t *param = NULL; + AXIS2_PARAM_CHECK(env->error, name, NULL); + + param = axutil_param_container_get_param(svc_grp->param_container, env, name); + if(!param && svc_grp->parent) + { + param = axis2_conf_get_param(svc_grp->parent, env, name); + } + return param; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + status = axutil_param_container_delete_param(svc_grp->param_container, env, param_name); + return status; +} + +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) +{ + return axutil_param_container_get_params(svc_grp->param_container, env); +} + +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) +{ + axis2_bool_t locked = AXIS2_FALSE; + axis2_conf_t *parent = NULL; + axutil_param_t *param = NULL; + axis2_bool_t ret = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE); + + parent = axis2_svc_grp_get_parent(svc_grp, env); + /* Checking the locked value of parent */ + if(parent) + { + locked = axis2_conf_is_param_locked(parent, env, param_name); + } + if(locked) + { + ret = AXIS2_TRUE; + } + param = axis2_svc_grp_get_param(svc_grp, env, param_name); + if(param && axutil_param_is_locked(param, env)) + { + ret = AXIS2_TRUE; + } + else + { + ret = AXIS2_FALSE; + } + return ret; +} + +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) +{ + return axutil_array_list_add(svc_grp->module_qname_list, env, module_qname); +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_svc_grp_get_parent( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env) +{ + return svc_grp->parent; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_set_parent( + axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + axis2_conf_t * parent) +{ + AXIS2_PARAM_CHECK(env->error, parent, AXIS2_FAILURE); + + if(svc_grp->parent) + axis2_conf_free(svc_grp->parent, env); + svc_grp->parent = parent; + if(parent) + { + axis2_desc_set_parent(svc_grp->base, env, axis2_conf_get_base(parent, env)); + } + return AXIS2_SUCCESS; +} + +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_name) +{ + int i = 0; + axis2_status_t status = AXIS2_FAILURE; + axutil_qname_t *modu = NULL; + axis2_char_t *modu_local = NULL; + axis2_char_t *module_name_local = NULL; + axutil_hash_t *svc_map = NULL; + axis2_phase_resolver_t *phase_resolver = NULL; + axis2_module_desc_t *module = NULL; + const axis2_char_t *svc_grp_name = axis2_svc_grp_get_name(svc_grp, env); + + int size = 0; + + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + + size = axutil_array_list_size(svc_grp->module_qname_list, env); + for(i = 0; size; i++) + { + modu = axutil_array_list_get(svc_grp->module_qname_list, env, i); + modu_local = axutil_qname_get_localpart(modu, env); + module_name_local = axutil_qname_get_localpart(module_name, env); + if(!axutil_strcmp(modu_local, module_name_local)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_ALREADY_ENGAGED_TO_SVC_GRP, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module %s is already engaged to service group %s", module_name_local, svc_grp_name); + + return AXIS2_FAILURE; + } + } + + svc_map = axis2_svc_grp_get_all_svcs(svc_grp, env); + if(!svc_map) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service map not found for service group %s", + svc_grp_name); + + return AXIS2_FAILURE; + } + + phase_resolver = axis2_phase_resolver_create_with_config(env, svc_grp->parent); + + if(!phase_resolver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating phase resolver failed for service group %s", svc_grp_name); + + return AXIS2_FAILURE; + } + + module = axis2_conf_get_module(svc_grp->parent, env, module_name); + if(module) + { + axis2_svc_t *axis_svc = NULL; + axutil_hash_index_t *index = NULL; + + index = axutil_hash_first(svc_map, env); + while(index) + { + const axis2_char_t *svc_name = NULL; + void *v = NULL; + /* engage in per each service */ + axutil_hash_this(index, NULL, NULL, &v); + axis_svc = (axis2_svc_t *)v; + svc_name = axis2_svc_get_name(axis_svc, env); + status = axis2_phase_resolver_engage_module_to_svc(phase_resolver, env, axis_svc, + module); + + if(!status) + { + if(phase_resolver) + { + axis2_phase_resolver_free(phase_resolver, env); + } + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Engaging module %s to service %s failed", + module_name_local, svc_name); + + return status; + } + + index = axutil_hash_next(env, index); + } + } + + if(phase_resolver) + { + axis2_phase_resolver_free(phase_resolver, env); + } + + return axis2_svc_grp_add_module_qname(svc_grp, env, module_name); +} + +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) +{ + return svc_grp->module_qname_list; +} + +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) +{ + const axis2_char_t *svc_grp_name = NULL; + + AXIS2_PARAM_CHECK(env->error, moduleref, AXIS2_FAILURE); + svc_grp_name = axis2_svc_grp_get_name(svc_grp, env); + + if(!svc_grp->module_list) + { + svc_grp->module_list = axutil_array_list_create(env, 0); + if(!svc_grp->module_list) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating module list failed for service group %s", svc_grp_name); + return AXIS2_FAILURE; + } + } + + return axutil_array_list_add(svc_grp->module_list, env, moduleref); +} + +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) +{ + return svc_grp->module_list; +} + +AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL +axis2_svc_grp_get_svc_grp_ctx( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env, + axis2_conf_ctx_t * parent) +{ + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + const axis2_char_t *svc_grp_name = NULL; + + AXIS2_PARAM_CHECK(env->error, parent, NULL); + svc_grp_name = axis2_svc_grp_get_name(svc_grp, env); + + svc_grp_ctx = axis2_svc_grp_ctx_create(env, (axis2_svc_grp_t *)svc_grp, parent); + if(!svc_grp_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating service group context failed for service group %s", svc_grp_name); + return NULL; + } + + return svc_grp_ctx; +} + +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) +{ + return svc_grp->param_container; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_svc_grp_get_base( + const axis2_svc_grp_t * svc_grp, + const axutil_env_t * env) +{ + return svc_grp->base; +} + diff --git a/src/core/description/transport_in_desc.c b/src/core/description/transport_in_desc.c new file mode 100644 index 0000000..85885b6 --- /dev/null +++ b/src/core/description/transport_in_desc.c @@ -0,0 +1,305 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_transport_in_desc +{ + axis2_flow_t *in_flow; + axis2_flow_t *fault_in_flow; + AXIS2_TRANSPORT_ENUMS trans_enum; + + /** + * transport receiver will have a shallow copy, but will be freed by + * free function. + */ + axis2_transport_receiver_t *recv; + axis2_phase_t *in_phase; + axis2_phase_t *fault_phase; + + /** parameter container to hold transport in related parameters */ + axutil_param_container_t *param_container; +}; + +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) +{ + axis2_transport_in_desc_t *transport_in = NULL; + + transport_in = (axis2_transport_in_desc_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_transport_in_desc_t)); + + if(!transport_in) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + transport_in->trans_enum = trans_enum; + transport_in->in_phase = NULL; + transport_in->fault_phase = NULL; + transport_in->in_flow = NULL; + transport_in->fault_in_flow = NULL; + transport_in->recv = NULL; + transport_in->param_container = NULL; + + transport_in->param_container = axutil_param_container_create(env); + if(!transport_in->param_container) + { + axis2_transport_in_desc_free(transport_in, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return transport_in; +} + +void AXIS2_CALL +axis2_transport_in_desc_free( + axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env) +{ + if(transport_in->recv) + { + axis2_transport_receiver_free(transport_in->recv, env); + } + + if(transport_in->param_container) + { + axutil_param_container_free(transport_in->param_container, env); + } + + if(transport_in->in_flow) + { + axis2_flow_free(transport_in->in_flow, env); + } + + if(transport_in->fault_in_flow) + { + axis2_flow_free(transport_in->fault_in_flow, env); + } + + if(transport_in->in_phase) + { + axis2_phase_free(transport_in->in_phase, env); + } + + if(transport_in->fault_phase) + { + axis2_phase_free(transport_in->fault_phase, env); + } + + AXIS2_FREE(env->allocator, transport_in); + + return; +} + +void AXIS2_CALL +axis2_transport_in_desc_free_void_arg( + void *transport_in, + const axutil_env_t * env) +{ + axis2_transport_in_desc_t *transport_in_l = NULL; + + transport_in_l = (axis2_transport_in_desc_t *)transport_in; + axis2_transport_in_desc_free(transport_in_l, env); + return; +} + +AXIS2_TRANSPORT_ENUMS AXIS2_CALL +axis2_transport_in_desc_get_enum( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env) +{ + return transport_in->trans_enum; +} + +axis2_status_t AXIS2_CALL +axis2_transport_in_desc_set_enum( + axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum) +{ + transport_in->trans_enum = trans_enum; + return AXIS2_SUCCESS; +} + +axis2_flow_t *AXIS2_CALL +axis2_transport_in_desc_get_in_flow( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env) +{ + return transport_in->in_flow; +} + +axis2_status_t AXIS2_CALL +axis2_transport_in_desc_set_in_flow( + axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env, + axis2_flow_t * in_flow) +{ + AXIS2_PARAM_CHECK(env->error, in_flow, AXIS2_FAILURE); + + if(transport_in->in_flow) + { + axis2_flow_free(transport_in->in_flow, env); + } + transport_in->in_flow = in_flow; + return AXIS2_SUCCESS; +} + +axis2_flow_t *AXIS2_CALL +axis2_transport_in_desc_get_fault_in_flow( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env) +{ + return transport_in->fault_in_flow; +} + +axis2_status_t AXIS2_CALL +axis2_transport_in_desc_set_fault_in_flow( + axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env, + axis2_flow_t * fault_in_flow) +{ + AXIS2_PARAM_CHECK(env->error, fault_in_flow, AXIS2_FAILURE); + + if(transport_in->fault_in_flow) + { + axis2_flow_free(transport_in->fault_in_flow, env); + } + transport_in->fault_in_flow = fault_in_flow; + return AXIS2_SUCCESS; +} + +axis2_transport_receiver_t *AXIS2_CALL +axis2_transport_in_desc_get_recv( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env) +{ + return transport_in->recv; +} + +axis2_status_t AXIS2_CALL +axis2_transport_in_desc_set_recv( + axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env, + axis2_transport_receiver_t * recv) +{ + AXIS2_PARAM_CHECK(env->error, recv, AXIS2_FAILURE); + + if(transport_in->recv) + { + axis2_transport_receiver_free(transport_in->recv, env); + } + + transport_in->recv = recv; + return AXIS2_SUCCESS; +} + +axis2_phase_t *AXIS2_CALL +axis2_transport_in_desc_get_in_phase( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env) +{ + return transport_in->in_phase; +} + +axis2_status_t AXIS2_CALL +axis2_transport_in_desc_set_in_phase( + axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env, + axis2_phase_t * in_phase) +{ + AXIS2_PARAM_CHECK(env->error, in_phase, AXIS2_FAILURE); + + if(transport_in->in_phase) + { + axis2_phase_free(transport_in->in_phase, env); + } + transport_in->in_phase = in_phase; + return AXIS2_SUCCESS; +} + +axis2_phase_t *AXIS2_CALL +axis2_transport_in_desc_get_fault_phase( + const axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env) +{ + return transport_in->fault_phase; +} + +axis2_status_t AXIS2_CALL +axis2_transport_in_desc_set_fault_phase( + axis2_transport_in_desc_t * transport_in, + const axutil_env_t * env, + axis2_phase_t * fault_phase) +{ + AXIS2_PARAM_CHECK(env->error, fault_phase, AXIS2_FAILURE); + + if(transport_in->fault_phase) + { + axis2_phase_free(transport_in->fault_phase, env); + } + transport_in->fault_phase = fault_phase; + return AXIS2_SUCCESS; + +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); + + return axutil_param_container_add_param(transport_in_desc-> param_container, env, param); +} + +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) +{ + return axutil_param_container_get_param(transport_in_desc->param_container, env, param_name); +} + +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_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE); + + return axutil_param_container_is_param_locked(transport_in_desc-> param_container, env, + 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) +{ + return transport_in_desc->param_container; +} + diff --git a/src/core/description/transport_out_desc.c b/src/core/description/transport_out_desc.c new file mode 100644 index 0000000..ec69f56 --- /dev/null +++ b/src/core/description/transport_out_desc.c @@ -0,0 +1,299 @@ +/* + * 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. + */ + +#include + +struct axis2_transport_out_desc +{ + axis2_flow_t *out_flow; + axis2_flow_t *fault_out_flow; + AXIS2_TRANSPORT_ENUMS trans_enum; + axis2_transport_sender_t *sender; + axis2_phase_t *out_phase; + axis2_phase_t *fault_phase; + + /** parameter container that holds parameter */ + axutil_param_container_t *param_container; +}; + +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) +{ + axis2_transport_out_desc_t *transport_out = NULL; + + transport_out = (axis2_transport_out_desc_t *)AXIS2_MALLOC(env-> allocator, + sizeof(axis2_transport_out_desc_t)); + + if(!transport_out) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + transport_out->trans_enum = trans_enum; + transport_out->out_phase = NULL; + transport_out->fault_phase = NULL; + transport_out->out_flow = NULL; + transport_out->fault_out_flow = NULL; + transport_out->sender = NULL; + transport_out->param_container = NULL; + + transport_out->param_container = axutil_param_container_create(env); + if(!transport_out->param_container) + { + axis2_transport_out_desc_free(transport_out, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return transport_out; +} + +void AXIS2_CALL +axis2_transport_out_desc_free( + axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env) +{ + if(transport_out->sender) + { + AXIS2_TRANSPORT_SENDER_FREE(transport_out->sender, env); + } + + if(transport_out->param_container) + { + axutil_param_container_free(transport_out->param_container, env); + } + + if(transport_out->out_flow) + { + axis2_flow_free(transport_out->out_flow, env); + } + + if(transport_out->fault_out_flow) + { + axis2_flow_free(transport_out->fault_out_flow, env); + } + + if(transport_out->out_phase) + { + axis2_phase_free(transport_out->out_phase, env); + } + + if(transport_out->fault_phase) + { + axis2_phase_free(transport_out->fault_phase, env); + } + + AXIS2_FREE(env->allocator, transport_out); + + return; +} + +void AXIS2_CALL +axis2_transport_out_desc_free_void_arg( + void *transport_out, + const axutil_env_t * env) +{ + axis2_transport_out_desc_t *transport_out_l = NULL; + + transport_out_l = (axis2_transport_out_desc_t *)transport_out; + axis2_transport_out_desc_free(transport_out_l, env); + return; +} + +AXIS2_TRANSPORT_ENUMS AXIS2_CALL +axis2_transport_out_desc_get_enum( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env) +{ + return transport_out->trans_enum; +} + +axis2_status_t AXIS2_CALL +axis2_transport_out_desc_set_enum( + axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env, + const AXIS2_TRANSPORT_ENUMS trans_enum) +{ + transport_out->trans_enum = trans_enum; + return AXIS2_SUCCESS; +} + +axis2_flow_t *AXIS2_CALL +axis2_transport_out_desc_get_out_flow( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env) +{ + return transport_out->out_flow; +} + +axis2_status_t AXIS2_CALL +axis2_transport_out_desc_set_out_flow( + axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env, + axis2_flow_t * out_flow) +{ + AXIS2_PARAM_CHECK(env->error, out_flow, AXIS2_FAILURE); + + if(transport_out->out_flow) + { + axis2_flow_free(transport_out->out_flow, env); + } + transport_out->out_flow = out_flow; + return AXIS2_SUCCESS; +} + +axis2_flow_t *AXIS2_CALL +axis2_transport_out_desc_get_fault_out_flow( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env) +{ + return transport_out->fault_out_flow; +} + +axis2_status_t AXIS2_CALL +axis2_transport_out_desc_set_fault_out_flow( + axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env, + axis2_flow_t * fault_out_flow) +{ + AXIS2_PARAM_CHECK(env->error, fault_out_flow, AXIS2_FAILURE); + + if(transport_out->fault_out_flow) + { + axis2_flow_free(transport_out->fault_out_flow, env); + } + transport_out->fault_out_flow = fault_out_flow; + return AXIS2_SUCCESS; +} + +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) +{ + return transport_out->sender; +} + +axis2_status_t AXIS2_CALL +axis2_transport_out_desc_set_sender( + axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env, + axis2_transport_sender_t * sender) +{ + AXIS2_PARAM_CHECK(env->error, sender, AXIS2_FAILURE); + + if(transport_out->sender) + { + AXIS2_TRANSPORT_SENDER_FREE(transport_out->sender, env); + } + + transport_out->sender = sender; + return AXIS2_SUCCESS; +} + +axis2_phase_t *AXIS2_CALL +axis2_transport_out_desc_get_out_phase( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env) +{ + return transport_out->out_phase; +} + +axis2_status_t AXIS2_CALL +axis2_transport_out_desc_set_out_phase( + axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env, + axis2_phase_t * out_phase) +{ + AXIS2_PARAM_CHECK(env->error, out_phase, AXIS2_FAILURE); + + if(transport_out->out_phase) + { + axis2_phase_free(transport_out->out_phase, env); + } + transport_out->out_phase = out_phase; + return AXIS2_SUCCESS; +} + +axis2_phase_t *AXIS2_CALL +axis2_transport_out_desc_get_fault_phase( + const axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env) +{ + return transport_out->fault_phase; +} + +axis2_status_t AXIS2_CALL +axis2_transport_out_desc_set_fault_phase( + axis2_transport_out_desc_t * transport_out, + const axutil_env_t * env, + axis2_phase_t * fault_phase) +{ + AXIS2_PARAM_CHECK(env->error, fault_phase, AXIS2_FAILURE); + + if(transport_out->fault_phase) + { + axis2_phase_free(transport_out->fault_phase, env); + } + transport_out->fault_phase = fault_phase; + return AXIS2_SUCCESS; + +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); + + return axutil_param_container_add_param(transport_out_desc-> param_container, env, param); +} + +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) +{ + return axutil_param_container_get_param(transport_out_desc->param_container, env, param_name); +} + +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_PARAM_CHECK(env->error, param_name, AXIS2_FAILURE); + + return axutil_param_container_is_param_locked(transport_out_desc-> param_container, env, + 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) +{ + return transport_out_desc->param_container; +} + diff --git a/src/core/engine/Makefile.am b/src/core/engine/Makefile.am new file mode 100644 index 0000000..7b9598c --- /dev/null +++ b/src/core/engine/Makefile.am @@ -0,0 +1,47 @@ +lib_LTLIBRARIES=libaxis2_engine.la + +libaxis2_engine_la_SOURCES= ../transport/transport_receiver.c handler.c \ + conf.c \ + phase.c \ + disp_checker.c \ + addr_disp.c \ + rest_disp.c \ + req_uri_disp.c \ + disp.c \ + soap_action_disp.c \ + soap_body_disp.c \ + ctx_handler.c \ + engine.c + +libaxis2_engine_la_LDFLAGS = -version-info $(VERSION_NO) + +libaxis2_engine_la_LIBADD=$(top_builddir)/src/core/description/libaxis2_description.la \ + $(top_builddir)/src/core/receivers/libaxis2_receivers.la \ + $(top_builddir)/src/core/deployment/libaxis2_deployment.la \ + $(top_builddir)/src/core/context/libaxis2_context.la \ + $(top_builddir)/src/core/addr/libaxis2_addr.la \ + $(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \ + $(top_builddir)/src/core/phaseresolver/libaxis2_phaseresolver.la \ + $(top_builddir)/src/core/util/libaxis2_core_utils.la \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/neethi/src/libneethi.la \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la +libaxis2_engine_la_LIBADD+=$(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la \ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la + + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/wsdl \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/util \ + -I$(top_builddir)/src/core/clientapi \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/neethi/include \ + -I$(top_builddir)/axiom/include + +EXTRA_DIST=axis2_disp_checker.h + diff --git a/src/core/engine/addr_disp.c b/src/core/engine/addr_disp.c new file mode 100644 index 0000000..a928e7a --- /dev/null +++ b/src/core/engine/addr_disp.c @@ -0,0 +1,255 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const axis2_char_t *AXIS2_ADDR_DISP_NAME = "addressing_based_dispatcher"; + +static axis2_status_t AXIS2_CALL axis2_addr_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + +static axis2_svc_t *AXIS2_CALL axis2_addr_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + +static axis2_op_t *AXIS2_CALL axis2_addr_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc); + +axis2_disp_t *AXIS2_CALL +axis2_addr_disp_create( + const axutil_env_t * env) +{ + axis2_disp_t *disp = NULL; + axis2_handler_t *handler = NULL; + axutil_string_t *name = NULL; + + name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_ADDR_DISP_NAME); + if(!name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + disp = axis2_disp_create(env, name); + if(!disp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axutil_string_free(name, env); + return NULL; + } + + handler = axis2_disp_get_base(disp, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + axutil_string_free(name, env); + return NULL; + } + + axis2_handler_set_invoke(handler, env, axis2_addr_disp_invoke); + + axutil_string_free(name, env); + + return disp; +} + +static axis2_svc_t *AXIS2_CALL +axis2_addr_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *endpoint_ref = NULL; + axis2_svc_t *svc = NULL; + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); + + if(endpoint_ref) + { + const axis2_char_t *address = NULL; + + address = axis2_endpoint_ref_get_address(endpoint_ref, env); + if(address) + { + axis2_char_t **url_tokens = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Checking for service using WSA enpoint address : %s", address); + + if((axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL, address) == 0) || (axutil_strcmp( + AXIS2_WSA_NAMESPACE_SUBMISSION, address) == 0)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Endpoint address cannot be the same as WSA namespace : %s", address); + return NULL; + } + + url_tokens = axutil_parse_request_url_for_svc_and_op(env, address); + + if(url_tokens) + { + if(url_tokens[0]) + { + axis2_conf_ctx_t *conf_ctx = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axis2_conf_t *conf = NULL; + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + svc = axis2_conf_get_svc(conf, env, url_tokens[0]); + + if(svc) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Service found using WSA enpoint address"); + } + } + } + AXIS2_FREE(env->allocator, url_tokens[0]); + } + if(url_tokens[1]) + { + AXIS2_FREE(env->allocator, url_tokens[1]); + } + AXIS2_FREE(env->allocator, url_tokens); + url_tokens = NULL; + } + } + } + + return svc; +} + +static axis2_op_t *AXIS2_CALL +axis2_addr_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + const axis2_char_t *action = NULL; + axutil_qname_t *name = NULL; + axis2_op_t *op = NULL; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, svc, NULL); + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + action = axis2_msg_ctx_get_wsa_action(msg_ctx, env); + + if(action) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Checking for operation using WSA Action : %s", + action); + + name = axutil_qname_create(env, action, NULL, NULL); + op = axis2_svc_get_op_with_qname(svc, env, name); + if(op) + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Operation found using WSA Action"); + axutil_qname_free(name, env); + } + + return op; +} + +static axis2_status_t AXIS2_CALL +axis2_addr_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx) +{ + axis2_relates_to_t *relates_to = NULL; + + relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env); + + /** first check if we can dispatch using the relates_to */ + if(relates_to) + { + const axis2_char_t *relates_to_value = NULL; + relates_to_value = axis2_relates_to_get_value(relates_to, env); + if(relates_to_value && axutil_strcmp(relates_to_value, "") != 0) + { + axis2_conf_ctx_t *conf_ctx = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axis2_op_ctx_t *op_ctx = NULL; + const axis2_char_t *msg_id = axis2_msg_ctx_get_msg_id(msg_ctx, env); + op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, msg_id); + if(op_ctx) + { + axis2_op_t *op = NULL; + op = axis2_op_ctx_get_op(op_ctx, env); + if(op) + { + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx); + axis2_msg_ctx_set_op(msg_ctx, env, op); + axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx); + + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + if(svc_ctx) + { + axis2_svc_t *svc = NULL; + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx); + svc = axis2_svc_ctx_get_svc(svc_ctx, env); + if(svc) + { + axis2_msg_ctx_set_svc(msg_ctx, env, svc); + } + svc_grp_ctx = axis2_svc_ctx_get_parent(svc_ctx, env); + if(svc_grp_ctx) + { + axutil_string_t *svc_grp_ctx_id_str = axutil_string_create(env, + axis2_svc_grp_ctx_get_id(svc_grp_ctx, env)); + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); + axutil_string_free(svc_grp_ctx_id_str, env); + } + return AXIS2_SUCCESS; + } + } + } + } + } + + } + + axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_addr_disp_find_svc); + axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_addr_disp_find_op); + + return axis2_disp_find_svc_and_op(handler, env, msg_ctx); +} + diff --git a/src/core/engine/axis2_disp_checker.h b/src/core/engine/axis2_disp_checker.h new file mode 100644 index 0000000..a93ac51 --- /dev/null +++ b/src/core/engine/axis2_disp_checker.h @@ -0,0 +1,105 @@ + +/* +* 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_CHECKER_H +#define AXIS2_DISP_CHECKER_H + +/** + * @defgroup axis2_disp_checker dispatcher checker + * @ingroup axis2_engine + * dispatcher checker is responsible of checking the status of the dispatchers. + * @{ + */ + +/** + * @file axis2_disp_checker.h + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_disp_checker */ + typedef struct axis2_disp_checker axis2_disp_checker_t; + + /** + * Gets the base handler. + * @param disp_checker pointer to dispatcher checker + * @param env pointer to environment struct + * @return pointer to base handler, returns a reference not a cloned copy + */ + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axis2_disp_checker_get_base( + const axis2_disp_checker_t * disp_checker, + const axutil_env_t * env); + + /** + * Gets QName. + * @param disp_checker pointer to dispatcher checker + * @param env pointer to environment struct + * @return returns a pointer to the QName, returns a reference not a + * cloned copy + */ + AXIS2_EXTERN axutil_string_t *AXIS2_CALL + axis2_disp_checker_get_name( + const axis2_disp_checker_t * disp_checker, + const axutil_env_t * env); + + /** + * Sets QName. + * @param disp_checker pointer to dispatcher checker + * @param env pointer to environment struct + * @param name pointer to QName. A clone would be created within the method + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_disp_checker_set_name( + axis2_disp_checker_t * disp_checker, + const axutil_env_t * env, + const axutil_string_t * name); + + /** + * Frees dispatcher checker. + * @param disp_checker pointer to dispatcher checker + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_disp_checker_free( + axis2_disp_checker_t * disp_checker, + const axutil_env_t * env); + + /** + * Creates a dispatcher checker struct instance. + * @param env pointer to environment struct + * @return pointer to newly created dispatcher checker struct + */ + AXIS2_EXTERN axis2_disp_checker_t *AXIS2_CALL + axis2_disp_checker_create( + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_DISP_CHECKER_H */ diff --git a/src/core/engine/conf.c b/src/core/engine/conf.c new file mode 100644 index 0000000..6e81392 --- /dev/null +++ b/src/core/engine/conf.c @@ -0,0 +1,1835 @@ +/* + * 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. + */ + +#include +#include +#include "axis2_disp_checker.h" +#include +#include +#include +#include +#include + +struct axis2_conf +{ + axutil_hash_t *svc_grps; + axis2_transport_in_desc_t *transports_in[AXIS2_TRANSPORT_ENUM_MAX]; + axis2_transport_out_desc_t *transports_out[AXIS2_TRANSPORT_ENUM_MAX]; + + /** + * All the modules already engaged can be found here. + */ + axutil_array_list_t *engaged_module_list; + + /*To store all the available modules (including version) */ + axutil_hash_t *all_modules; + + /*To store mapping between default version to module name */ + axutil_hash_t *name_to_version_map; + axutil_array_list_t *out_phases; + axutil_array_list_t *in_fault_phases; + axutil_array_list_t *out_fault_phases; + + /* All the system specific phases are stored here */ + axutil_array_list_t *in_phases_upto_and_including_post_dispatch; + + axis2_phases_info_t *phases_info; + axutil_hash_t *all_svcs; + axutil_hash_t *all_init_svcs; + axutil_hash_t *msg_recvs; + axutil_hash_t *faulty_svcs; + axutil_hash_t *faulty_modules; + axis2_char_t *axis2_repo; + axis2_char_t *axis2_xml; + axis2_dep_engine_t *dep_engine; + axutil_array_list_t *handlers; + axis2_bool_t enable_mtom; + /*This is used in rampart */ + axis2_bool_t enable_security; + + /** Configuration parameter container */ + axutil_param_container_t *param_container; + + /** Base description struct */ + axis2_desc_t *base; + + /** Mark whether conf is built using axis2 XML*/ + axis2_bool_t axis2_flag; + +#if 0 +/* this seemed to be not used after 1.6.0 */ +/* This is a hack to keep rampart_context at client side */ +void *security_context; +#endif +}; + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_conf_create( + const axutil_env_t * env) +{ + axis2_conf_t *conf = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_phase_t *phase = NULL; + int i = 0; + + AXIS2_ENV_CHECK(env, NULL); + + conf = (axis2_conf_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_conf_t)); + if(!conf) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + memset((void *)conf, 0, sizeof(axis2_conf_t)); + + conf->param_container = (axutil_param_container_t *)axutil_param_container_create(env); + if(!conf->param_container) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating parameter container failed"); + return NULL; + } + + conf->svc_grps = axutil_hash_make(env); + if(!conf->svc_grps) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating service group map failed"); + return NULL; + } + + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + conf->transports_in[i] = NULL; + } + + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + conf->transports_out[i] = NULL; + } + + conf->engaged_module_list = axutil_array_list_create(env, 0); + if(!conf->engaged_module_list) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating engaged module list failed"); + return NULL; + } + + conf->handlers = axutil_array_list_create(env, 0); + if(!conf->handlers) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating handler list failed"); + return NULL; + } + + conf->in_phases_upto_and_including_post_dispatch = axutil_array_list_create(env, 0); + if(!conf->in_phases_upto_and_including_post_dispatch) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating in phases list upto and including post dispatch failed"); + return NULL; + } + else + { + axis2_disp_t *uri_dispatch = NULL; + axis2_disp_t *addr_dispatch = NULL; + + phase = axis2_phase_create(env, AXIS2_PHASE_TRANSPORT_IN); + if(!phase) + { + axis2_conf_free(conf, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase %s failed", + AXIS2_PHASE_TRANSPORT_IN); + return NULL; + } + + /* In case of using security we need to find the service/operation parameters before the + * dispatch phase. This is required to give parameters to the security inflow.*/ + uri_dispatch = axis2_req_uri_disp_create(env); + if(uri_dispatch) + { + axis2_handler_t *handler = NULL; + handler = axis2_disp_get_base(uri_dispatch, env); + axis2_disp_free(uri_dispatch, env); + axis2_phase_add_handler_at(phase, env, 0, handler); + axutil_array_list_add(conf->handlers, env, axis2_handler_get_handler_desc(handler, env)); + } + + addr_dispatch = axis2_addr_disp_create(env); + if(addr_dispatch) + { + axis2_handler_t *handler = NULL; + handler = axis2_disp_get_base(addr_dispatch, env); + axis2_disp_free(addr_dispatch, env); + axis2_phase_add_handler_at(phase, env, 1, handler); + axutil_array_list_add(conf->handlers, env, axis2_handler_get_handler_desc(handler, env)); + } + + status + = axutil_array_list_add(conf->in_phases_upto_and_including_post_dispatch, env, phase); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(conf, env); + axis2_phase_free(phase, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding phase %s into in phases upto and including post dispatch list failed", + AXIS2_PHASE_TRANSPORT_IN); + return NULL; + } + + phase = axis2_phase_create(env, AXIS2_PHASE_PRE_DISPATCH); + if(!phase) + { + axis2_conf_free(conf, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase %s failed", + AXIS2_PHASE_PRE_DISPATCH); + return NULL; + } + + status + = axutil_array_list_add(conf->in_phases_upto_and_including_post_dispatch, env, phase); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(conf, env); + axis2_phase_free(phase, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding phase %s into in phases upto and including post dispatch list failed", + AXIS2_PHASE_PRE_DISPATCH); + return NULL; + } + } + + conf->all_svcs = axutil_hash_make(env); + if(!conf->all_svcs) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating all services map failed"); + return NULL; + } + + conf->all_init_svcs = axutil_hash_make(env); + if(!conf->all_init_svcs) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating all init services map failed"); + return NULL; + } + + conf->msg_recvs = axutil_hash_make(env); + if(!conf->msg_recvs) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating message receivers map failed."); + return NULL; + } + + conf->faulty_svcs = axutil_hash_make(env); + if(!conf->faulty_svcs) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating fault services map failed"); + return NULL; + } + + conf->faulty_modules = axutil_hash_make(env); + if(!conf->faulty_modules) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating fault modules map failed"); + return NULL; + } + + conf->all_modules = axutil_hash_make(env); + if(!conf->all_modules) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating all modules map failed"); + return NULL; + } + + conf->name_to_version_map = axutil_hash_make(env); + if(!conf->name_to_version_map) + { + axis2_conf_free(conf, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating name to version map failed"); + return NULL; + } + + conf->base = axis2_desc_create(env); + if(!conf->base) + { + axis2_conf_free(conf, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating Axis2 configuration base description failed"); + return NULL; + } + + return conf; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_conf_free( + axis2_conf_t * conf, + const axutil_env_t * env) +{ + int i = 0; + + if(!conf) + { + /* nothing to free */ + return; + } + + if(conf->param_container) + { + axutil_param_container_free(conf->param_container, env); + } + + if(conf->svc_grps) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf->svc_grps, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_svc_grp_t *svc_grp = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + svc_grp = (axis2_svc_grp_t *)val; + if(svc_grp) + { + axis2_svc_grp_free(svc_grp, env); + } + } + axutil_hash_free(conf->svc_grps, env); + } + + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + if(conf->transports_in[i]) + { + axis2_transport_in_desc_free(conf->transports_in[i], env); + } + } + + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + if(conf->transports_out[i]) + { + axis2_transport_out_desc_free(conf->transports_out[i], env); + } + } + + if(conf->dep_engine) + { + axis2_dep_engine_free(conf->dep_engine, env); + } + + if(conf->all_modules) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf->all_modules, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_module_desc_t *module_desc = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + module_desc = (axis2_module_desc_t *)val; + if(module_desc) + { + axis2_module_desc_free(module_desc, env); + } + } + axutil_hash_free(conf->all_modules, env); + } + + if(conf->name_to_version_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf->name_to_version_map, env); hi; hi = axutil_hash_next(env, + hi)) + { + axis2_char_t *module_ver = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + module_ver = (axis2_char_t *)val; + if(module_ver) + { + AXIS2_FREE(env->allocator, module_ver); + } + } + axutil_hash_free(conf->name_to_version_map, env); + } + + if(conf->engaged_module_list) + { + for(i = 0; i < axutil_array_list_size(conf->engaged_module_list, env); i++) + { + axutil_qname_t *module_desc_qname = NULL; + module_desc_qname = (axutil_qname_t *)axutil_array_list_get(conf->engaged_module_list, + env, i); + if(module_desc_qname) + { + axutil_qname_free(module_desc_qname, env); + } + } + axutil_array_list_free(conf->engaged_module_list, env); + } + + if(conf->out_phases) + { + for(i = 0; i < axutil_array_list_size(conf->out_phases, env); i++) + { + axis2_phase_t *phase = NULL; + phase = (axis2_phase_t *)axutil_array_list_get(conf->out_phases, env, i); + if(phase) + { + axis2_phase_free(phase, env); + } + } + axutil_array_list_free(conf->out_phases, env); + } + + if(conf->in_fault_phases) + { + for(i = 0; i < axutil_array_list_size(conf->in_fault_phases, env); i++) + { + axis2_phase_t *phase = NULL; + phase = (axis2_phase_t *)axutil_array_list_get(conf->in_fault_phases, env, i); + if(phase) + { + axis2_phase_free(phase, env); + } + } + axutil_array_list_free(conf->in_fault_phases, env); + } + + if(conf->out_fault_phases) + { + for(i = 0; i < axutil_array_list_size(conf->out_fault_phases, env); i++) + { + axis2_phase_t *phase = NULL; + phase = (axis2_phase_t *)axutil_array_list_get(conf->out_fault_phases, env, i); + if(phase) + { + axis2_phase_free(phase, env); + } + } + axutil_array_list_free(conf->out_fault_phases, env); + } + + if(conf->in_phases_upto_and_including_post_dispatch) + { + for(i = 0; i < axutil_array_list_size(conf-> in_phases_upto_and_including_post_dispatch, + env); i++) + { + axis2_phase_t *phase = NULL; + phase = (axis2_phase_t *)axutil_array_list_get( + conf-> in_phases_upto_and_including_post_dispatch, env, i); + if(phase) + { + axis2_phase_free(phase, env); + } + } + axutil_array_list_free(conf-> in_phases_upto_and_including_post_dispatch, env); + } + + if(conf->all_svcs) + { + axutil_hash_free(conf->all_svcs, env); + } + + if(conf->all_init_svcs) + { + axutil_hash_free(conf->all_init_svcs, env); + } + + if(conf->msg_recvs) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf->msg_recvs, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_msg_recv_t *msg_recv = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + msg_recv = (axis2_msg_recv_t *)val; + if(msg_recv) + { + axis2_msg_recv_free(msg_recv, env); + msg_recv = NULL; + } + } + axutil_hash_free(conf->msg_recvs, env); + } + + if(conf->faulty_svcs) + { + axutil_hash_free(conf->faulty_svcs, env); + } + + if(conf->faulty_modules) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + for(hi = axutil_hash_first(conf->faulty_modules, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_module_desc_t *module_desc = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + module_desc = (axis2_module_desc_t *)val; + if(module_desc) + { + axis2_module_desc_free(module_desc, env); + } + } + axutil_hash_free(conf->faulty_modules, env); + } + + if(conf->handlers) + { + int i = 0; + for(i = 0; i < axutil_array_list_size(conf->handlers, env); i++) + { + axis2_handler_desc_t *handler_desc = NULL; + handler_desc = (axis2_handler_desc_t *)axutil_array_list_get(conf->handlers, env, i); + if(handler_desc) + { + axis2_handler_desc_free(handler_desc, env); + } + } + axutil_array_list_free(conf->handlers, env); + } + + if(conf->axis2_repo) + { + AXIS2_FREE(env->allocator, conf->axis2_repo); + } + + if(conf->base) + { + axis2_desc_free(conf->base, env); + } + + if(conf->axis2_xml) + { + AXIS2_FREE(env->allocator, conf->axis2_xml); + } + + AXIS2_FREE(env->allocator, conf); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_add_svc_grp( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp) +{ + axutil_hash_t *svcs = NULL; + axutil_hash_index_t *index_i = NULL; + axis2_char_t *svc_name = NULL; + const axis2_char_t *svc_grp_name = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + svcs = axis2_svc_grp_get_all_svcs(svc_grp, env); + if(!conf->all_svcs) + { + conf->all_svcs = axutil_hash_make(env); + if(!conf->all_svcs) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating all services map failed"); + return AXIS2_FAILURE; + } + } + + index_i = axutil_hash_first(svcs, env); + while(index_i) + { + void *value = NULL; + axis2_svc_t *desc = NULL; + axis2_svc_t *temp_svc = NULL; + const axutil_qname_t *svc_qname = NULL; + + axutil_hash_this(index_i, NULL, NULL, &value); + desc = (axis2_svc_t *)value; + svc_qname = axis2_svc_get_qname(desc, env); + svc_name = axutil_qname_get_localpart(svc_qname, env); + temp_svc = axutil_hash_get(conf->all_svcs, svc_name, AXIS2_HASH_KEY_STRING); + + /* No two service names deployed in the engine can be same */ + if(temp_svc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_TWO_SVCS_CANNOT_HAVE_SAME_NAME, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "There is already a service called %s in the " + "all services list of axis2 configuration.", svc_name); + return AXIS2_FAILURE; + } + + index_i = axutil_hash_next(env, index_i); + } + + svcs = axis2_svc_grp_get_all_svcs(svc_grp, env); + index_i = axutil_hash_first(svcs, env); + + while(index_i) + { + void *value = NULL; + axis2_svc_t *desc = NULL; + + axutil_hash_this(index_i, NULL, NULL, &value); + desc = (axis2_svc_t *)value; + svc_name = axutil_qname_get_localpart(axis2_svc_get_qname(desc, env), env); + axutil_hash_set(conf->all_svcs, svc_name, AXIS2_HASH_KEY_STRING, desc); + index_i = axutil_hash_next(env, index_i); + } + + svc_grp_name = axis2_svc_grp_get_name(svc_grp, env); + if(!conf->svc_grps) + { + conf->svc_grps = axutil_hash_make(env); + if(!conf->svc_grps) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating service group map failed"); + return AXIS2_FAILURE; + } + } + + axutil_hash_set(conf->svc_grps, svc_grp_name, AXIS2_HASH_KEY_STRING, svc_grp); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_svc_grp_t *AXIS2_CALL +axis2_conf_get_svc_grp( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * svc_grp_name) +{ + AXIS2_PARAM_CHECK(env->error, svc_grp_name, NULL); + + if(!conf->svc_grps) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_CONF, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Axis2 configuration does not contain a service group map"); + return NULL; + } + return (axis2_svc_grp_t *)(axutil_hash_get(conf->svc_grps, svc_grp_name, AXIS2_HASH_KEY_STRING)); +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_get_all_svc_grps( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->svc_grps; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_add_svc( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + axis2_phase_resolver_t *phase_resolver = NULL; + axis2_svc_grp_t *svc_grp = NULL; + const axis2_char_t *svc_grp_name = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE); + + /* We need to first create a service group with the same name as the + * service and make it the parent of service */ + svc_grp_name = axis2_svc_get_name(svc, env); + if(!svc_grp_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service has no name set"); + return AXIS2_FAILURE; + } + + svc_grp = axis2_svc_grp_create(env); + if(!svc_grp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating service group as parent of service %s failed", svc_grp_name); + return AXIS2_FAILURE; + } + + status = axis2_svc_grp_set_name(svc_grp, env, svc_grp_name); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name to service group failed"); + return status; + } + + status = axis2_svc_grp_set_parent(svc_grp, env, conf); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting parent to service group %s failed", + svc_grp_name); + return status; + } + + phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc); + if(!phase_resolver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s", + axis2_svc_get_name(svc, env)); + return AXIS2_FAILURE; + } + + status = axis2_phase_resolver_build_execution_chains_for_svc(phase_resolver, env); + axis2_phase_resolver_free(phase_resolver, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Building chains failed within phase resolver " + "for service %s", axis2_svc_get_name(svc, env)); + return status; + } + + status = axis2_svc_grp_add_svc(svc_grp, env, svc); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding service %s to service group %s failed", + svc_grp_name, svc_grp_name); + return status; + } + + status = axis2_conf_add_svc_grp(conf, env, svc_grp); + return status; +} + +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_conf_get_svc( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * svc_name) +{ + AXIS2_PARAM_CHECK(env->error, svc_name, NULL); + + return axutil_hash_get(conf->all_svcs, svc_name, AXIS2_HASH_KEY_STRING); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_remove_svc( + axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * svc_name) +{ + AXIS2_PARAM_CHECK(env->error, svc_name, AXIS2_FAILURE); + + axutil_hash_set(conf->all_svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_add_param( + axis2_conf_t * conf, + const axutil_env_t * env, + axutil_param_t * param) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *param_name = axutil_param_get_name(param, env); + + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); + + if(axis2_conf_is_param_locked(conf, env, param_name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PARAMETER_LOCKED_CANNOT_OVERRIDE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked for Axis2 configuration", + param_name); + return AXIS2_FAILURE; + } + else + { + status = axutil_param_container_add_param(conf->param_container, env, param); + } + return status; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, name, NULL); + + if(!conf->param_container) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM_CONTAINER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Param container is not set in axis2 configuraion"); + return NULL; + } + + return axutil_param_container_get_param(conf->param_container, env, name); + +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_conf_get_all_params( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return axutil_param_container_get_params(conf->param_container, env); + +} + +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) +{ + axutil_param_t *param = NULL; + + AXIS2_PARAM_CHECK(env->error, param_name, AXIS2_FALSE); + + param = axis2_conf_get_param(conf, env, param_name); + return (param && axutil_param_is_locked(param, env)); +} + +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) +{ + return (axis2_transport_in_desc_t *)conf->transports_in[trans_enum]; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, transport, AXIS2_FAILURE); + + conf->transports_in[trans_enum] = transport; + + return AXIS2_SUCCESS; + +} + +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) +{ + return conf->transports_out[trans_enum]; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, transport, AXIS2_FAILURE); + + conf->transports_out[trans_enum] = transport; + + return AXIS2_SUCCESS; +} + +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) +{ + return (axis2_transport_in_desc_t **)conf->transports_in; +} + +AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL +axis2_conf_get_module( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axutil_qname_t * qname) +{ + axis2_char_t *name = NULL; + axis2_module_desc_t *ret = NULL; + axis2_char_t *module_name = NULL; + axutil_qname_t *mod_qname = NULL; + const axis2_char_t *def_mod_ver = NULL; + + AXIS2_PARAM_CHECK(env->error, qname, NULL); + + name = axutil_qname_to_string((axutil_qname_t *)qname, env); + ret = (axis2_module_desc_t *)axutil_hash_get(conf->all_modules, name, AXIS2_HASH_KEY_STRING); + if(ret) + { + return ret; + } + module_name = axutil_qname_get_localpart(qname, env); + if(!module_name) + { + return NULL; + } + def_mod_ver = axis2_conf_get_default_module_version(conf, env, module_name); + mod_qname = axis2_core_utils_get_module_qname(env, name, def_mod_ver); + if(!mod_qname) + { + return NULL; + } + name = axutil_qname_to_string(mod_qname, env); + ret = (axis2_module_desc_t *)axutil_hash_get(conf->all_modules, name, AXIS2_HASH_KEY_STRING); + axutil_qname_free(mod_qname, env); + mod_qname = NULL; + return ret; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_conf_get_all_engaged_modules( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->engaged_module_list; +} + +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) +{ + return conf->in_phases_upto_and_including_post_dispatch; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_conf_get_out_flow( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->out_phases; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_conf_get_in_fault_flow( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->in_fault_phases; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_conf_get_out_fault_flow( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->out_fault_phases; +} + +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) +{ + return (axis2_transport_out_desc_t **)conf->transports_out; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_get_all_faulty_svcs( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->faulty_svcs; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_get_all_faulty_modules( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->faulty_modules; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_get_all_svcs( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + /*axutil_hash_t *sgs = NULL; + axutil_hash_index_t *index_i = NULL; + axutil_hash_index_t *index_j = NULL; + void *value = NULL; + void *value2 = NULL; + axis2_svc_grp_t *axis_svc_grp = NULL; + axutil_hash_t *svcs = NULL; + axis2_svc_t *svc = NULL; + axis2_char_t *svc_name = NULL; + */ + + /* Do we need to do all the following of retrieving all service groups and + * then add all services from each group to conf->all_svcs and then finally + * return conf->all_svcs?. We have already done this when + * adding each service group to the conf, so just returning conf->all_svcs + * here would be enough - Damitha */ + /*sgs = axis2_conf_get_all_svc_grps(conf, env); + index_i = axutil_hash_first(sgs, env); + while(index_i) + { + axutil_hash_this(index_i, NULL, NULL, &value); + axis_svc_grp = (axis2_svc_grp_t *)value; + svcs = axis2_svc_grp_get_all_svcs(axis_svc_grp, env); + index_j = axutil_hash_first(svcs, env); + while(index_j) + { + axutil_hash_this(index_j, NULL, NULL, &value2); + svc = (axis2_svc_t *)value2; + svc_name = axutil_qname_get_localpart(axis2_svc_get_qname(svc, env), env); + axutil_hash_set(conf->all_svcs, svc_name, AXIS2_HASH_KEY_STRING, svc); + + index_j = axutil_hash_next(env, index_j); + } + + index_i = axutil_hash_next(env, index_i); + }*/ + return conf->all_svcs; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_get_all_svcs_to_load( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + axutil_hash_t *sgs = NULL; + axutil_hash_index_t *index_i = NULL; + axutil_hash_index_t *index_j = NULL; + void *value = NULL; + void *value2 = NULL; + axis2_svc_grp_t *axis_svc_grp = NULL; + axutil_hash_t *svcs = NULL; + axis2_svc_t *svc = NULL; + axis2_char_t *svc_name = NULL; + + sgs = axis2_conf_get_all_svc_grps(conf, env); + index_i = axutil_hash_first(sgs, env); + while(index_i) + { + axutil_hash_this(index_i, NULL, NULL, &value); + axis_svc_grp = (axis2_svc_grp_t *)value; + svcs = axis2_svc_grp_get_all_svcs(axis_svc_grp, env); + index_j = axutil_hash_first(svcs, env); + while(index_j) + { + axutil_param_t *param = NULL; + axutil_hash_this(index_j, NULL, NULL, &value2); + svc = (axis2_svc_t *)value2; + svc_name = axutil_qname_get_localpart(axis2_svc_get_qname(svc, env), env); + param = axis2_svc_get_param(svc, env, AXIS2_LOAD_SVC_STARTUP); + if(param) + { + axutil_hash_set(conf->all_init_svcs, svc_name, AXIS2_HASH_KEY_STRING, svc); + } + + index_j = axutil_hash_next(env, index_j); + } + + index_i = axutil_hash_next(env, index_i); + } + return conf->all_init_svcs; +} + +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) +{ + const axutil_qname_t *def_mod_qname = NULL; + axis2_module_desc_t *def_mod = NULL; + int i = 0; + int size = 0; + + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FALSE); + + def_mod + = axis2_conf_get_default_module(conf, env, axutil_qname_get_localpart(module_name, env)); + if(def_mod) + { + def_mod_qname = axis2_module_desc_get_qname(def_mod, env); + } + + size = axutil_array_list_size(conf->engaged_module_list, env); + for(i = 0; i < size; i++) + { + axutil_qname_t *qname = NULL; + qname = (axutil_qname_t *)axutil_array_list_get(conf->engaged_module_list, env, i); + if(axutil_qname_equals(module_name, env, qname) || (def_mod_qname && axutil_qname_equals( + def_mod_qname, env, qname))) + { + return AXIS2_TRUE; + } + } + + return AXIS2_FALSE; +} + +AXIS2_EXTERN axis2_phases_info_t *AXIS2_CALL +axis2_conf_get_phases_info( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->phases_info; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_set_phases_info( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_phases_info_t * phases_info) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(conf->phases_info) + { + axis2_phases_info_free(phases_info, env); + conf->phases_info = NULL; + } + conf->phases_info = phases_info; + return AXIS2_SUCCESS; +} + +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, + axis2_msg_recv_t * msg_recv) +{ + AXIS2_PARAM_CHECK(env->error, key, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_recv, AXIS2_FAILURE); + if(!conf->msg_recvs) + { + conf->msg_recvs = axutil_hash_make(env); + if(!conf->msg_recvs) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating message receiver map failed"); + return AXIS2_FAILURE; + } + } + axutil_hash_set(conf->msg_recvs, key, AXIS2_HASH_KEY_STRING, msg_recv); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL +axis2_conf_get_msg_recv( + const axis2_conf_t * conf, + const axutil_env_t * env, + axis2_char_t * key) +{ + return (axis2_msg_recv_t *)axutil_hash_get(conf->msg_recvs, key, AXIS2_HASH_KEY_STRING); +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, out_phases, AXIS2_FAILURE); + + if(conf->out_phases) + { + axutil_array_list_free(conf->out_phases, env); + conf->out_phases = NULL; + } + conf->out_phases = out_phases; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_conf_get_out_phases( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->out_phases; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE); + + if(conf->in_fault_phases) + { + axutil_array_list_free(conf->in_fault_phases, env); + conf->in_fault_phases = NULL; + } + conf->in_fault_phases = list; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, list, AXIS2_FAILURE); + + if(conf->out_fault_phases) + { + axutil_array_list_free(conf->out_fault_phases, env); + conf->out_fault_phases = NULL; + } + conf->out_fault_phases = list; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_conf_get_all_modules( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->all_modules; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_add_module( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_module_desc_t * module) +{ + const axutil_qname_t *module_qname = NULL; + + AXIS2_PARAM_CHECK(env->error, module, AXIS2_FAILURE); + + axis2_module_desc_set_parent(module, env, conf); + + module_qname = axis2_module_desc_get_qname(module, env); + if(module_qname) + { + axis2_char_t *module_name = NULL; + module_name = axutil_qname_to_string((axutil_qname_t *)module_qname, env); + axutil_hash_set(conf->all_modules, module_name, AXIS2_HASH_KEY_STRING, module); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_set_default_dispatchers( + axis2_conf_t * conf, + const axutil_env_t * env) +{ + axis2_phase_t *dispatch = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_disp_t *rest_dispatch = NULL; + axis2_disp_t *soap_action_based_dispatch = NULL; + axis2_disp_t *soap_msg_body_based_dispatch = NULL; + axis2_handler_t *handler = NULL; + axis2_phase_t *post_dispatch = NULL; + axis2_disp_checker_t *disp_checker = NULL; + + dispatch = axis2_phase_create(env, AXIS2_PHASE_DISPATCH); + if(!dispatch) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase %s failed", AXIS2_PHASE_DISPATCH); + return AXIS2_FAILURE; + } + + rest_dispatch = axis2_rest_disp_create(env); + if(!rest_dispatch) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating rest dispatcher failed"); + return AXIS2_FAILURE; + } + + handler = axis2_disp_get_base(rest_dispatch, env); + axis2_disp_free(rest_dispatch, env); + axis2_phase_add_handler_at(dispatch, env, 0, handler); + axutil_array_list_add(conf->handlers, env, axis2_handler_get_handler_desc(handler, env)); + + soap_msg_body_based_dispatch = axis2_soap_body_disp_create(env); + if(!soap_msg_body_based_dispatch) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating soap body based dispatcher failed"); + return AXIS2_FAILURE; + } + + handler = axis2_disp_get_base(soap_msg_body_based_dispatch, env); + axis2_disp_free(soap_msg_body_based_dispatch, env); + axis2_phase_add_handler_at(dispatch, env, 1, handler); + axutil_array_list_add(conf->handlers, env, axis2_handler_get_handler_desc(handler, env)); + + soap_action_based_dispatch = axis2_soap_action_disp_create(env); + if(!soap_action_based_dispatch) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating soap action based dispatcher failed"); + return AXIS2_FAILURE; + } + + handler = axis2_disp_get_base(soap_action_based_dispatch, env); + axis2_disp_free(soap_action_based_dispatch, env); + axis2_phase_add_handler_at(dispatch, env, 2, handler); + axutil_array_list_add(conf->handlers, env, axis2_handler_get_handler_desc(handler, env)); + + status + = axutil_array_list_add(conf-> in_phases_upto_and_including_post_dispatch, env, dispatch); + if(AXIS2_SUCCESS != status) + { + axis2_phase_free(dispatch, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding dispatcher into in phases upto and including post dispatch list failed"); + return status; + } + + post_dispatch = axis2_phase_create(env, AXIS2_PHASE_POST_DISPATCH); + if(!post_dispatch) + { + axis2_phase_free(dispatch, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase %s failed", + AXIS2_PHASE_POST_DISPATCH); + return AXIS2_FAILURE; + } + + disp_checker = axis2_disp_checker_create(env); + handler = axis2_disp_checker_get_base(disp_checker, env); + axis2_disp_checker_free(disp_checker, env); + axis2_phase_add_handler_at(post_dispatch, env, 0, handler); + axutil_array_list_add(conf->handlers, env, axis2_handler_get_handler_desc(handler, env)); + handler = axis2_ctx_handler_create(env, NULL); + axis2_phase_add_handler_at(post_dispatch, env, 1, handler); + axutil_array_list_add(conf->handlers, env, axis2_handler_get_handler_desc(handler, env)); + + status = axutil_array_list_add(conf-> in_phases_upto_and_including_post_dispatch, env, + post_dispatch); + if(AXIS2_SUCCESS != status) + { + axis2_phase_free(dispatch, env); + axis2_phase_free(post_dispatch, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding post dispatcher into in phases upto and including post dispatch list failed"); + return status; + } + return AXIS2_SUCCESS; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_handler_t *handler = NULL; + axis2_phase_t *post_dispatch = NULL; + axis2_disp_checker_t *disp_checker = NULL; + + AXIS2_PARAM_CHECK(env->error, dispatch, AXIS2_FAILURE); + + status + = axutil_array_list_add(conf-> in_phases_upto_and_including_post_dispatch, env, dispatch); + if(AXIS2_FAILURE == status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding dispatcher into in phases upto and including post dispatch list failed"); + return AXIS2_FAILURE; + } + + post_dispatch = axis2_phase_create(env, AXIS2_PHASE_POST_DISPATCH); + if(!post_dispatch) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase %s failed", + AXIS2_PHASE_POST_DISPATCH); + axis2_phase_free(dispatch, env); + return AXIS2_FAILURE; + } + + disp_checker = axis2_disp_checker_create(env); + + handler = axis2_disp_checker_get_base(disp_checker, env); + axis2_phase_add_handler_at(post_dispatch, env, 0, handler); + + status = axutil_array_list_add(conf-> in_phases_upto_and_including_post_dispatch, env, + post_dispatch); + if(AXIS2_FAILURE == status) + { + axis2_phase_free(dispatch, env); + axis2_phase_free(post_dispatch, env); + axis2_disp_checker_free(disp_checker, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding post dispatcher into in phases upto and including post dispatch list failed"); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +/** + * For each module reference qname stored in dep_engine this function is called. + * All module_desc instances are stored in axis2_conf. So each module_desc + * is retrieved from there by giving module_qname and engaged globally by + * calling phase_resolvers engage_module_globally function. Modules are added + * to axis2_conf's engaged module list. + */ +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) +{ + axis2_module_desc_t *module_desc = NULL; + axis2_bool_t is_new_module = AXIS2_FALSE; + axis2_bool_t to_be_engaged = AXIS2_TRUE; + axis2_dep_engine_t *dep_engine = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *file_name = NULL; + + AXIS2_PARAM_CHECK(env->error, module_ref, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + + module_desc = axis2_conf_get_module(conf, env, module_ref); + if(!module_desc) + { + axutil_file_t *file = NULL; + const axis2_char_t *repos_path = NULL; + axis2_arch_file_data_t *file_data = NULL; + axis2_char_t *temp_path1 = NULL; + axis2_char_t *temp_path2 = NULL; + axis2_char_t *temp_path3 = NULL; + axis2_char_t *path = NULL; + axutil_param_t *module_dir_param = NULL; + axis2_char_t *module_dir = NULL; + axis2_bool_t flag; + axis2_char_t *axis2_xml = NULL; + + file_name = axutil_qname_get_localpart(module_ref, env); + file = (axutil_file_t *)axis2_arch_reader_create_module_arch(env, file_name); + /* This flag is to check whether conf is built using axis2 + * xml configuration file instead of a repository. */ + flag = axis2_conf_get_axis2_flag(conf, env); + + if(!flag) + { + repos_path = axis2_conf_get_repo(conf, env); + temp_path1 = axutil_stracat(env, repos_path, AXIS2_PATH_SEP_STR); + temp_path2 = axutil_stracat(env, temp_path1, AXIS2_MODULE_FOLDER); + temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR); + path = axutil_stracat(env, temp_path3, file_name); + AXIS2_FREE(env->allocator, temp_path1); + AXIS2_FREE(env->allocator, temp_path2); + AXIS2_FREE(env->allocator, temp_path3); + } + else + { + /** + * This case is to obtain module path from the axis2.xml + */ + axis2_xml = (axis2_char_t *)axis2_conf_get_axis2_xml(conf, env); + module_dir_param = axis2_conf_get_param(conf, env, AXIS2_MODULE_DIR); + + if(module_dir_param) + { + module_dir = (axis2_char_t *)axutil_param_get_value(module_dir_param, env); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "moduleDir parameter not available in axis2.xml."); + + return AXIS2_FAILURE; + } + + temp_path1 = axutil_strcat(env, module_dir, AXIS2_PATH_SEP_STR, NULL); + path = axutil_strcat(env, temp_path1, file_name, NULL); + } + + axutil_file_set_path(file, env, path); + file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_MODULE, file); + if(!flag) + { + dep_engine = axis2_dep_engine_create_with_repos_name(env, repos_path); + } + else + { + dep_engine = axis2_dep_engine_create_with_axis2_xml(env, axis2_xml); + } + + axis2_dep_engine_set_current_file_item(dep_engine, env, file_data); + + /* this module_dir set the path of the module directory + * Pertaining to this module. This value will use inside the + * axis2_dep_engine_build_module function + */ + + axis2_dep_engine_set_module_dir(dep_engine, env, path); + + if(path) + { + AXIS2_FREE(env->allocator, path); + } + + if(file_data) + { + axis2_arch_file_data_free(file_data, env); + } + + module_desc = axis2_dep_engine_build_module(dep_engine, env, file, conf); + axutil_file_free(file, env); + is_new_module = AXIS2_TRUE; + } + + if(module_desc) + { + int size = 0; + int i = 0; + const axutil_qname_t *module_qname = NULL; + + size = axutil_array_list_size(conf->engaged_module_list, env); + module_qname = axis2_module_desc_get_qname(module_desc, env); + for(i = 0; i < size; i++) + { + axutil_qname_t *qname = NULL; + + qname = (axutil_qname_t *)axutil_array_list_get(conf->engaged_module_list, env, i); + if(axutil_qname_equals(module_qname, env, qname)) + { + to_be_engaged = AXIS2_FALSE; + } + } + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Either module description not set or building" + "module description failed for module %s", file_name); + + return AXIS2_FAILURE; + } + + if(to_be_engaged) + { + axis2_phase_resolver_t *phase_resolver = NULL; + axutil_qname_t *module_qref_l = NULL; + const axutil_qname_t *module_qname = NULL; + axis2_char_t *module_name = NULL; + + module_qname = axis2_module_desc_get_qname(module_desc, env); + module_name = axutil_qname_get_localpart(module_qname, env); + phase_resolver = axis2_phase_resolver_create_with_config(env, conf); + if(!phase_resolver) + { + return AXIS2_FAILURE; + } + + status = axis2_phase_resolver_engage_module_globally(phase_resolver, env, module_desc); + axis2_phase_resolver_free(phase_resolver, env); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Engaging module %s globally failed", + module_name); + return status; + } + module_qref_l = axutil_qname_clone((axutil_qname_t *)module_qname, env); + status = axutil_array_list_add(conf->engaged_module_list, env, module_qref_l); + } + + if(is_new_module) + { + status = axis2_conf_add_module(conf, env, module_desc); + } + + return status; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_conf_get_repo( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->axis2_repo; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_set_repo( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_char_t * repos_path) +{ + if(conf->axis2_repo) + { + AXIS2_FREE(env->allocator, conf->axis2_repo); + conf->axis2_repo = NULL; + } + conf->axis2_repo = axutil_strdup(env, repos_path); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_conf_get_axis2_xml( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return axutil_strdup(env, conf->axis2_xml); +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, axis2_xml, AXIS2_FAILURE); + conf->axis2_xml = axutil_strdup(env, axis2_xml); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_set_dep_engine( + axis2_conf_t * conf, + const axutil_env_t * env, + axis2_dep_engine_t * dep_engine) +{ + conf->dep_engine = dep_engine; + return AXIS2_SUCCESS; +} + +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) +{ + axutil_hash_t *def_ver_map = NULL; + AXIS2_PARAM_CHECK(env->error, module_name, NULL); + + def_ver_map = conf->name_to_version_map; + if(!def_ver_map) + { + return NULL; + } + return axutil_hash_get(def_ver_map, module_name, AXIS2_HASH_KEY_STRING); +} + +AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL +axis2_conf_get_default_module( + const axis2_conf_t * conf, + const axutil_env_t * env, + const axis2_char_t * module_name) +{ + axis2_module_desc_t *ret_mod = NULL; + axis2_char_t *mod_name = NULL; + const axis2_char_t *mod_ver = NULL; + axutil_hash_t *all_modules = NULL; + axutil_qname_t *mod_qname = NULL; + + AXIS2_PARAM_CHECK(env->error, module_name, NULL); + + all_modules = conf->all_modules; + mod_ver = axis2_conf_get_default_module_version(conf, env, module_name); + + if(!mod_ver) + { + mod_name = axutil_strdup(env, module_name); + } + else + { + axis2_char_t *tmp_name = NULL; + tmp_name = axutil_stracat(env, module_name, "-"); + mod_name = axutil_stracat(env, tmp_name, mod_ver); + AXIS2_FREE(env->allocator, tmp_name); + } + mod_qname = axutil_qname_create(env, mod_name, NULL, NULL); + AXIS2_FREE(env->allocator, mod_name); + mod_name = NULL; + + if(!mod_qname) + { + return NULL; + } + ret_mod = (axis2_module_desc_t *)axutil_hash_get(all_modules, axutil_qname_to_string(mod_qname, + env), AXIS2_HASH_KEY_STRING); + + return ret_mod; +} + +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) +{ + axutil_hash_t *name_to_ver_map = NULL; + + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_version, AXIS2_FAILURE); + /* + * If we already have a default module version we don't put + * it again + */ + name_to_ver_map = conf->name_to_version_map; + + if(!axutil_hash_get(name_to_ver_map, module_name, AXIS2_HASH_KEY_STRING)) + { + axis2_char_t *new_entry = axutil_strdup(env, module_version); + if(!new_entry) + { + return AXIS2_FAILURE; + } + axutil_hash_set(name_to_ver_map, module_name, AXIS2_HASH_KEY_STRING, new_entry); + return AXIS2_SUCCESS; + } + return 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) +{ + axutil_qname_t *module_qname = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + + module_qname = axis2_core_utils_get_module_qname(env, module_name, version_id); + if(!module_qname) + { + return AXIS2_FAILURE; + } + status = axis2_conf_engage_module(conf, env, module_qname); + axutil_qname_free(module_qname, env); + return status; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_conf_get_enable_mtom( + axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->enable_mtom; +} + +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) +{ + conf->enable_mtom = enable_mtom; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_conf_get_axis2_flag( + axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->axis2_flag; +} + +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) +{ + conf->axis2_flag = axis2_flag; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_conf_get_enable_security( + axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->enable_security; +} + +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_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + + conf->enable_security = enable_security; + return AXIS2_SUCCESS; +} + +#if 0 +/* this seemed to be not used after 1.6.0 */ +AXIS2_EXTERN void *AXIS2_CALL +axis2_conf_get_security_context( + axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->security_context; +} + +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_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + + conf->security_context = (void *) security_context; + return AXIS2_SUCCESS; +} +#endif + +AXIS2_EXTERN axutil_param_container_t *AXIS2_CALL +axis2_conf_get_param_container( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->param_container; +} + +AXIS2_EXTERN axis2_desc_t *AXIS2_CALL +axis2_conf_get_base( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->base; +} + +AXIS2_EXTERN axutil_array_list_t * AXIS2_CALL +axis2_conf_get_handlers( + const axis2_conf_t * conf, + const axutil_env_t * env) +{ + return conf->handlers; +} + diff --git a/src/core/engine/ctx_handler.c b/src/core/engine/ctx_handler.c new file mode 100644 index 0000000..4cafaf5 --- /dev/null +++ b/src/core/engine/ctx_handler.c @@ -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. + */ + +#include +#include +#include +#include + +const axis2_char_t *AXIS2_CTX_HANDLER_NAME = "context_handler"; + +/** + * By the time the control comes to this handler, the dispatching must have + * happened so that the message context contains the service group, service and + * operation. This will then try to find the contexts for service group, service + * and the operation. + */ + +axis2_status_t AXIS2_CALL +axis2_ctx_handler_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + +axis2_handler_t *AXIS2_CALL +axis2_ctx_handler_create( + const axutil_env_t * env, + const axutil_string_t * string) +{ + axis2_handler_t *handler = NULL; + axis2_handler_desc_t *handler_desc = NULL; + axutil_string_t *handler_string = NULL; + + if(string) + { + handler_string = axutil_string_clone((axutil_string_t *)string, env); + if(!(handler_string)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + } + else + { + /* create default string */ + handler_string = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_CTX_HANDLER_NAME); + if(!handler_string) + { + return NULL; + } + } + + handler = axis2_handler_create(env); + if(!handler) + { + return NULL; + } + + /* handler desc of base handler */ + handler_desc = axis2_handler_desc_create(env, handler_string); + axutil_string_free(handler_string, env); + if(!handler_desc) + { + axis2_handler_free(handler, env); + return NULL; + } + + axis2_handler_init(handler, env, handler_desc); + + /* set the base struct's invoke op */ + axis2_handler_set_invoke(handler, env, axis2_ctx_handler_invoke); + + return handler; +} + +axis2_status_t AXIS2_CALL +axis2_ctx_handler_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axis2_op_t *op = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_ctx_handler_invoke"); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + svc_ctx = axis2_msg_ctx_get_svc_ctx(msg_ctx, env); + + if(op_ctx && svc_ctx) + { + svc_grp_ctx = axis2_svc_ctx_get_parent(svc_ctx, env); + if(svc_grp_ctx) + { + axutil_string_t *svc_grp_ctx_id_str = axutil_string_create(env, + axis2_svc_grp_ctx_get_id(svc_grp_ctx, env)); + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); + axutil_string_free(svc_grp_ctx_id_str, env); + } + return AXIS2_SUCCESS; + } + + op = axis2_msg_ctx_get_op(msg_ctx, env); + if(op) + { + op_ctx = axis2_op_find_existing_op_ctx(op, env, msg_ctx); + } + + if(op_ctx) + { + axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx); + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + if(svc_ctx) + { + axutil_string_t *svc_grp_ctx_id_str = NULL; + const axis2_char_t *grp_ctx_id = NULL; + + svc_grp_ctx = axis2_svc_ctx_get_parent(svc_ctx, env); + axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx); + axis2_msg_ctx_set_svc_grp_ctx(msg_ctx, env, svc_grp_ctx); + grp_ctx_id = axis2_svc_grp_ctx_get_id(svc_grp_ctx, env); + svc_grp_ctx_id_str = axutil_string_create(env, grp_ctx_id); + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); + axutil_string_free(svc_grp_ctx_id_str, env); + } + + return AXIS2_SUCCESS; + } + else if(op) /* 2. if no op_ctx, create new op_ctx */ + { + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_bool_t use_pools = AXIS2_FALSE; + axutil_param_t *param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_PERSIST_OP_CTX); + + use_pools = (param && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, axutil_param_get_value(param, + env))); + + if(use_pools) + { + axutil_allocator_switch_to_global_pool(env->allocator); + } + op_ctx = axis2_op_ctx_create(env, op, NULL); + if(!op_ctx) + { + axis2_char_t *op_name = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Could not create Operation context for operatoin %s", op_name); + + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx); + + axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + if(!use_pools) + { + axutil_allocator_switch_to_global_pool(env->allocator); + } + + svc_grp_ctx = axis2_conf_ctx_fill_ctxs(conf_ctx, env, msg_ctx); + + if(!use_pools) + { + axutil_allocator_switch_to_local_pool(env->allocator); + } + } + + if(use_pools) + { + axutil_allocator_switch_to_local_pool(env->allocator); + } + } + + if(!svc_grp_ctx && (axis2_msg_ctx_get_server_side(msg_ctx, env))) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service group context not found"); + return AXIS2_FAILURE; + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_ctx_handler_invoke"); + + return AXIS2_SUCCESS; +} + diff --git a/src/core/engine/disp.c b/src/core/engine/disp.c new file mode 100644 index 0000000..51cb56d --- /dev/null +++ b/src/core/engine/disp.c @@ -0,0 +1,185 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +const axis2_char_t *AXIS2_DISP_NAME = "abstract_dispatcher"; + +struct axis2_disp +{ + + /** base class, inherits from handler */ + axis2_handler_t *base; + + /** phase name */ + axutil_string_t *name; + + /** derived struct */ + void *derived; /* deep copy */ + int derived_type; +}; + +axis2_disp_t *AXIS2_CALL +axis2_disp_create( + const axutil_env_t * env, + const axutil_string_t * name) +{ + axis2_disp_t *disp = NULL; + axis2_handler_desc_t *handler_desc = NULL; + + disp = AXIS2_MALLOC(env->allocator, sizeof(axis2_disp_t)); + if(!disp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + disp->name = NULL; + disp->base = NULL; + + if(name) + { + disp->name = axutil_string_clone((axutil_string_t *)name, env); + if(!(disp->name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_disp_free(disp, env); + return NULL; + } + } + else + { + /* create default name */ + disp->name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_DISP_NAME); + if(!(disp->name)) + { + axis2_disp_free(disp, env); + return NULL; + } + } + + disp->base = axis2_handler_create(env); + if(!disp->base) + { + axis2_disp_free(disp, env); + return NULL; + } + + /* handler desc of base handler */ + handler_desc = axis2_handler_desc_create(env, disp->name); + if(!handler_desc) + { + axis2_disp_free(disp, env); + return NULL; + } + + axis2_handler_init(disp->base, env, handler_desc); + + return disp; +} + +axis2_handler_t *AXIS2_CALL +axis2_disp_get_base( + const axis2_disp_t * disp, + const axutil_env_t * env) +{ + return disp->base; +} + +axutil_string_t *AXIS2_CALL +axis2_disp_get_name( + const axis2_disp_t * disp, + const axutil_env_t * env) +{ + return disp->name; +} + +axis2_status_t AXIS2_CALL +axis2_disp_set_name( + struct axis2_disp * disp, + const axutil_env_t * env, + axutil_string_t * name) +{ + if(disp->name) + { + axutil_string_free(disp->name, env); + } + + if(name) + { + disp->name = axutil_string_clone(name, env); + if(!(disp->name)) + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + axis2_svc_t *axis_service = NULL; + axis2_op_t *op = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + axis_service = axis2_msg_ctx_get_svc(msg_ctx, env); + + if(!axis_service) + { + axis_service = axis2_msg_ctx_find_svc(msg_ctx, env); + if(axis_service) + { + axis2_msg_ctx_set_svc(msg_ctx, env, axis_service); + } + } + op = axis2_msg_ctx_get_op(msg_ctx, env); + if(!op) + { + op = axis2_msg_ctx_find_op(msg_ctx, env, axis_service); + + if(op) + { + axis2_msg_ctx_set_op(msg_ctx, env, op); + } + } + + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_disp_free( + struct axis2_disp *disp, + const axutil_env_t * env) +{ + if(disp->name) + { + axutil_string_free(disp->name, env); + } + AXIS2_FREE(env->allocator, disp); + return; +} + diff --git a/src/core/engine/disp_checker.c b/src/core/engine/disp_checker.c new file mode 100644 index 0000000..b668a9a --- /dev/null +++ b/src/core/engine/disp_checker.c @@ -0,0 +1,284 @@ +/* + * 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. + */ + +#include "axis2_disp_checker.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const axis2_char_t *AXIS2_DISP_CHECKER_NAME = "dispatch_post_conditions_evaluator"; + +struct axis2_disp_checker +{ + + /** base class, inherits from handler */ + axis2_handler_t *base; + + /** phase name */ + axutil_string_t *name; +}; + +axis2_status_t AXIS2_CALL +axis2_disp_checker_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +axis2_disp_checker_t *AXIS2_CALL +axis2_disp_checker_create( + const axutil_env_t * env) +{ + axis2_disp_checker_t *disp_checker = NULL; + axis2_handler_desc_t *handler_desc = NULL; + + disp_checker = AXIS2_MALLOC(env->allocator, sizeof(axis2_disp_checker_t)); + if(!disp_checker) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + disp_checker->name = NULL; + disp_checker->base = NULL; + + /* create default name */ + disp_checker->name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_DISP_CHECKER_NAME); + + if(!(disp_checker->name)) + { + axis2_disp_checker_free(disp_checker, env); + return NULL; + } + + disp_checker->base = axis2_handler_create(env); + if(!disp_checker->base) + { + axis2_disp_checker_free(disp_checker, env); + return NULL; + } + axis2_handler_set_invoke(disp_checker->base, env, axis2_disp_checker_invoke); + + /* handler desc of base handler */ + handler_desc = axis2_handler_desc_create(env, disp_checker->name); + if(!handler_desc) + { + axis2_disp_checker_free(disp_checker, env); + return NULL; + } + + axis2_handler_init(disp_checker->base, env, handler_desc); + return disp_checker; +} + +axis2_handler_t *AXIS2_CALL +axis2_disp_checker_get_base( + const axis2_disp_checker_t * disp_checker, + const axutil_env_t * env) +{ + return disp_checker->base; +} + +axutil_string_t *AXIS2_CALL +axis2_disp_checker_get_name( + const axis2_disp_checker_t * disp_checker, + const axutil_env_t * env) +{ + return disp_checker->name; +} + +axis2_status_t AXIS2_CALL +axis2_disp_checker_set_name( + axis2_disp_checker_t * disp_checker, + const axutil_env_t * env, + const axutil_string_t * name) +{ + if(disp_checker->name) + { + axutil_string_free(disp_checker->name, env); + disp_checker->name = NULL; + } + + if(name) + { + disp_checker->name = axutil_string_clone((axutil_string_t *)name, env); + if(!(disp_checker->name)) + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +void AXIS2_CALL +axis2_disp_checker_free( + axis2_disp_checker_t * disp_checker, + const axutil_env_t * env) +{ + if(disp_checker->name) + { + axutil_string_free(disp_checker->name, env); + } + + AXIS2_FREE(env->allocator, disp_checker); + + return; +} + +axis2_status_t AXIS2_CALL +axis2_disp_checker_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_op_t *op = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_svc_t *svc = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_endpoint_ref_t *endpoint_ref = NULL; + const axis2_char_t *address = NULL; + axiom_soap_fault_t *soap_fault; + axiom_soap_envelope_t *soap_envelope; + axiom_soap_body_t *soap_body; + int soap_version = AXIOM_SOAP12; + axis2_char_t *fault_code = NULL; + + axis2_char_t exception[1024]; + axis2_char_t *wsa_action; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + /*if is client side, no point in proceeding */ + if(!(axis2_msg_ctx_get_server_side(msg_ctx, env))) + return AXIS2_SUCCESS; + + op = axis2_msg_ctx_get_op(msg_ctx, env); + + if(!op) + { + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); + if(op) + axis2_msg_ctx_set_op(msg_ctx, env, op); + } + } + + svc = axis2_msg_ctx_get_svc(msg_ctx, env); + + if(!svc) + { + svc_ctx = axis2_msg_ctx_get_svc_ctx(msg_ctx, env); + if(svc_ctx) + { + axis2_svc_t *tsvc = axis2_svc_ctx_get_svc(svc_ctx, env); + if(tsvc) + axis2_msg_ctx_set_svc(msg_ctx, env, tsvc); + } + } + endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); + + if(endpoint_ref) + { + address = axis2_endpoint_ref_get_address(endpoint_ref, env); + } + + svc = axis2_msg_ctx_get_svc(msg_ctx, env); + if(!svc) + { + AXIS2_LOG_INFO(env->log, "Service Not found. Endpoint reference is : %s", + (address) ? address : "NULL"); + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + soap_version = AXIOM_SOAP11; +fault_code = + AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP11_FAULT_CODE_RECEIVER; + } + else + { + fault_code = + AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER; + + } + + soap_envelope = + axiom_soap_envelope_create_default_soap_envelope(env, soap_version); + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + soap_fault = + axiom_soap_fault_create_default_fault(env, soap_body, fault_code, + "Service Not Found", + soap_version); + + wsa_action = (axis2_char_t *)axis2_msg_ctx_get_wsa_action (msg_ctx, + env); + sprintf (exception, "Service Not Found, Endpoint referance address is %s and wsa\ + actions is %s", address, wsa_action); + + axiom_soap_fault_set_exception (soap_fault, env, exception); + axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, soap_envelope); + return AXIS2_FAILURE; +} + +op = axis2_msg_ctx_get_op(msg_ctx, env); +if (!op) +{ + AXIS2_LOG_INFO(env->log, + "Operation Not found. Endpoint reference is : %s", + (address) ? address : "NULL"); + if (axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + soap_version = AXIOM_SOAP11; + fault_code = + AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP11_FAULT_CODE_RECEIVER; + } + else + { + fault_code = + AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER; + } + + soap_envelope = + axiom_soap_envelope_create_default_soap_envelope(env, soap_version); + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + soap_fault = + axiom_soap_fault_create_default_fault(env, soap_body, fault_code, + "Operation Not Found", + soap_version); + + wsa_action = (axis2_char_t *)axis2_msg_ctx_get_wsa_action (msg_ctx, + env); + sprintf (exception, "Operation Not Found, Endpoint referance address is %s and wsa\ + actions is %s", address, wsa_action); + + axiom_soap_fault_set_exception (soap_fault, env, exception); + axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, soap_envelope); + return AXIS2_FAILURE; +} +return AXIS2_SUCCESS; +} + diff --git a/src/core/engine/engine.c b/src/core/engine/engine.c new file mode 100644 index 0000000..a098ea1 --- /dev/null +++ b/src/core/engine/engine.c @@ -0,0 +1,915 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_engine +{ + /** Configuration context */ + axis2_conf_ctx_t *conf_ctx; +}; + +axis2_status_t +axis2_engine_check_must_understand_headers( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +AXIS2_EXTERN axis2_engine_t * AXIS2_CALL +axis2_engine_create( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_engine_t *engine = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + engine = AXIS2_MALLOC(env->allocator, sizeof(axis2_engine_t)); + if(!engine) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + engine->conf_ctx = NULL; + + if(conf_ctx) + { + engine->conf_ctx = conf_ctx; + } + + return engine; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_engine_free( + axis2_engine_t * engine, + const axutil_env_t * env) +{ + AXIS2_FREE(env->allocator, engine); + return; +} + +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) +{ + axis2_status_t status = AXIS2_SUCCESS; + axis2_op_ctx_t *op_ctx = NULL; + axutil_array_list_t *phases = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_engine_send start"); + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + /* Find and invoke the phases */ + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); + if(op) + { + phases = axis2_op_get_out_flow(op, env); + } + } + + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + /* Message has paused, so rerun it from the position it stopped. + The handler which paused the message will be the first one to resume + invocation + */ + status = axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Resuming invocation of phases failed"); + return status; + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axutil_array_list_t *global_out_phase = axis2_conf_get_out_phases(conf, env); + if(global_out_phase) + { + axis2_engine_invoke_phases(engine, env, global_out_phase, msg_ctx); + } + } + } + } + else + { + status = axis2_engine_invoke_phases(engine, env, phases, msg_ctx); + if(status != AXIS2_SUCCESS) + { + return status; + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axutil_array_list_t *global_out_phase = axis2_conf_get_out_phases(conf, env); + if(global_out_phase) + { + axis2_engine_invoke_phases(engine, env, global_out_phase, msg_ctx); + } + } + } + } + + if(!(axis2_msg_ctx_is_paused(msg_ctx, env))) + { + /* Write the message to wire */ + axis2_transport_sender_t *transport_sender = NULL; + axis2_transport_out_desc_t *transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx, + env); + + if(transport_out) + { + transport_sender = axis2_transport_out_desc_get_sender(transport_out, env); + if(!transport_sender) + return AXIS2_FAILURE; + + status = AXIS2_TRANSPORT_SENDER_INVOKE(transport_sender, env, msg_ctx); + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport sender invoke failed"); + return status; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport out is not set in message context"); + return AXIS2_FAILURE; + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_engine_send end successfully"); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_op_t *op = NULL; + axutil_array_list_t *pre_calculated_phases = NULL; + axutil_array_list_t *op_specific_phases = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_receive"); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + + pre_calculated_phases = axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env); + + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + /* The message has paused, so re-run them from the position they stopped. */ + axis2_engine_resume_invocation_phases(engine, env, pre_calculated_phases, msg_ctx); + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return here."); + return AXIS2_SUCCESS; + } + + /* Resume op specific phases */ + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + op = axis2_op_ctx_get_op(op_ctx, env); + op_specific_phases = axis2_op_get_in_flow(op, env); + axis2_engine_resume_invocation_phases(engine, env, op_specific_phases, msg_ctx); + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Message context is paused. So return here."); + return AXIS2_SUCCESS; + } + } + } + else + { + status = axis2_engine_invoke_phases(engine, env, pre_calculated_phases, msg_ctx); + if(status != AXIS2_SUCCESS) + { + if(axis2_msg_ctx_get_server_side(msg_ctx, env)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking pre-calculated phases failed"); + return status; + } + } + + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Message context is paused. So return here."); + return AXIS2_SUCCESS; + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + op = axis2_op_ctx_get_op(op_ctx, env); + op_specific_phases = axis2_op_get_in_flow(op, env); + status = axis2_engine_invoke_phases(engine, env, op_specific_phases, msg_ctx); + if(status != AXIS2_SUCCESS) + { + axis2_char_t *op_name = NULL; + op_name = axutil_qname_get_localpart(axis2_op_get_qname(op, env), env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invoking operation specific phases failed for operation %s", op_name); + return status; + } + + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Message context is paused. So return here."); + return AXIS2_SUCCESS; + } + } + } + + if((axis2_msg_ctx_get_server_side(msg_ctx, env)) && !(axis2_msg_ctx_is_paused(msg_ctx, env))) + { + axis2_msg_recv_t *receiver = NULL; + + status = axis2_engine_check_must_understand_headers(env, msg_ctx); + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Check for must understand headers failed"); + return status; + } + + /* Invoke the message receivers */ + if(!op) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation not found"); + return AXIS2_FAILURE; + } + receiver = axis2_op_get_msg_recv(op, env); + if(!receiver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Message receiver not set in operation description"); + return AXIS2_FAILURE; + } + status = axis2_msg_recv_receive(receiver, env, msg_ctx, axis2_msg_recv_get_derived( + receiver, env)); + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_receive"); + + return status; +} + +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) +{ + axis2_op_ctx_t *op_ctx = NULL; + axis2_status_t status = AXIS2_SUCCESS; + axutil_array_list_t *phases = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); + if(op) + { + phases = axis2_op_get_fault_out_flow(op, env); + } + } + + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + /* Message has paused, so rerun it from the position it stopped. + The handler which paused the message will be the first one to resume + invocation + */ + status = axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Resuming invoking the phases failed"); + return status; + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axutil_array_list_t *global_out_fault_phase = axis2_conf_get_out_fault_flow(conf, + env); + if(global_out_fault_phase) + { + axis2_engine_invoke_phases(engine, env, global_out_fault_phase, msg_ctx); + } + } + } + } + else + { + status = axis2_engine_invoke_phases(engine, env, phases, msg_ctx); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axutil_array_list_t *global_out_fault_phase = axis2_conf_get_out_fault_flow(conf, + env); + if(global_out_fault_phase) + { + axis2_engine_invoke_phases(engine, env, global_out_fault_phase, msg_ctx); + } + } + } + } + + if(!(axis2_msg_ctx_is_paused(msg_ctx, env))) + { + /* Write the message to wire */ + axis2_transport_sender_t *transport_sender = NULL; + axis2_transport_out_desc_t *transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx, + env); + + if(transport_out) + { + transport_sender = axis2_transport_out_desc_get_sender(transport_out, env); + + if(transport_sender) + { + AXIS2_TRANSPORT_SENDER_INVOKE(transport_sender, env, msg_ctx); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport sender not found"); + return AXIS2_FAILURE; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport out is not set in message context"); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + axis2_op_ctx_t *op_ctx = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_receive_fault"); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + + if(!op_ctx) + { + /* If we do not have an op context that means this may be an incoming + dual channel response. So try to dispatch the service */ + axis2_conf_ctx_t *conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axis2_conf_t *conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axutil_array_list_t *phases = + axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env); + if(phases) + { + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); + } + else + { + axis2_engine_invoke_phases(engine, env, phases, msg_ctx); + } + } + } + } + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + /* Find and execute the fault in flow handlers */ + if(op_ctx) + { + axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); + axutil_array_list_t *phases = axis2_op_get_fault_in_flow(op, env); + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); + } + else + { + axis2_engine_invoke_phases(engine, env, phases, msg_ctx); + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_receive_fault"); + return AXIS2_SUCCESS; +} + +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) +{ + axis2_msg_ctx_t *fault_ctx = NULL; + axis2_endpoint_ref_t *fault_to = NULL; + axis2_endpoint_ref_t *reply_to = NULL; + axutil_stream_t *stream = NULL; + axiom_soap_envelope_t *envelope = NULL; + const axis2_char_t *wsa_action = NULL; + const axis2_char_t *msg_id = NULL; + axis2_relates_to_t *relates_to = NULL; + axis2_char_t *msg_uuid = NULL; + axis2_msg_info_headers_t *msg_info_headers = NULL; + axis2_bool_t doing_rest = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, processing_context, NULL); + + if(axis2_msg_ctx_get_process_fault(processing_context, env)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PROCESSING_FAULT_ALREADY, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating fault message contex failed"); + return NULL; + } + + fault_ctx = axis2_msg_ctx_create(env, engine->conf_ctx, axis2_msg_ctx_get_transport_in_desc( + processing_context, env), axis2_msg_ctx_get_transport_out_desc(processing_context, env)); + + axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE); + + fault_to = axis2_msg_ctx_get_fault_to(processing_context, env); + if(fault_to) + { + const axis2_char_t *address = axis2_endpoint_ref_get_address(fault_to, env); + if(!address) + { + fault_to = NULL; + } + else if(axutil_strcmp(AXIS2_WSA_NONE_URL, address) == 0 || axutil_strcmp( + AXIS2_WSA_NONE_URL_SUBMISSION, address) == 0) + { + reply_to = axis2_msg_ctx_get_reply_to(processing_context, env); + if(reply_to) + { + axis2_msg_ctx_set_fault_to(fault_ctx, env, reply_to); + } + else + { + axis2_msg_ctx_set_fault_to(fault_ctx, env, fault_to); + } + } + else + { + axis2_msg_ctx_set_fault_to(fault_ctx, env, fault_to); + } + + } + + stream = axis2_msg_ctx_get_transport_out_stream(processing_context, env); + + if(stream) + { + axis2_msg_ctx_set_transport_out_stream(fault_ctx, env, stream); + } + + if(!fault_to && !stream) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NOWHERE_TO_SEND_FAULT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap fault target destination not found"); + return NULL; + } + + /* Set WSA action */ + msg_info_headers = axis2_msg_ctx_get_msg_info_headers(processing_context, env); + if(msg_info_headers) + { + wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env); + if(wsa_action) + { + /* + We have to use the action set by user, + cannot use the default always. + wsa_action = "http://www.w3.org/2005/08/addressing/fault"; */ + axis2_msg_ctx_set_wsa_action(fault_ctx, env, wsa_action); + } + } + + /* Set relates to */ + msg_id = axis2_msg_ctx_get_msg_id(processing_context, env); + + /* we can create with default Relates to namespace. + Actual namespace based on addressing version will be created in addressing out handler */ + relates_to = axis2_relates_to_create(env, msg_id, + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE); + axis2_msg_ctx_set_relates_to(fault_ctx, env, relates_to); + + /* Set msg id */ + msg_uuid = axutil_uuid_gen(env); + axis2_msg_ctx_set_message_id(fault_ctx, env, msg_uuid); + if(msg_uuid) + { + AXIS2_FREE(env->allocator, msg_uuid); + msg_uuid = NULL; + } + + /** Copy the property map from the current message context to the newly created fault message + context. */ + { + axis2_ctx_t *ctx = axis2_msg_ctx_get_base(processing_context, env); + axis2_ctx_t *fault_base_ctx = axis2_msg_ctx_get_base(fault_ctx, env); + + if(ctx && fault_ctx) + { + axis2_ctx_set_property_map(fault_base_ctx, env, axis2_ctx_get_property_map(ctx, env)); + } + + } + + + axis2_msg_ctx_set_op_ctx(fault_ctx, env, axis2_msg_ctx_get_op_ctx(processing_context, env)); + axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_server_side(fault_ctx, env, AXIS2_TRUE); + + envelope = axis2_msg_ctx_get_fault_soap_envelope(processing_context, env); + + if(!envelope) + { + if(axis2_msg_ctx_get_is_soap_11(processing_context, env)) + { + envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value, + reason_text, AXIOM_SOAP11, NULL, NULL); + + } + else + { + envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value, + reason_text, AXIOM_SOAP12, NULL, NULL); + } + + if(!envelope) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Creating default soap envelope failed"); + return NULL; + } + } + + doing_rest = axis2_msg_ctx_get_doing_rest(processing_context, env); + axis2_msg_ctx_set_doing_rest(fault_ctx, env, doing_rest); + + axis2_msg_ctx_set_soap_envelope(fault_ctx, env, envelope); + axis2_msg_ctx_set_out_transport_info(fault_ctx, env, axis2_msg_ctx_get_out_transport_info( + processing_context, env)); + return fault_ctx; +} + +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) +{ + int i = 0; + int count = 0; + axis2_status_t status = AXIS2_SUCCESS; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_invoke_phases"); + AXIS2_PARAM_CHECK(env->error, phases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(phases) + count = axutil_array_list_size(phases, env); + for(i = 0; (i < count && !(axis2_msg_ctx_is_paused(msg_ctx, env))); i++) + { + axis2_phase_t *phase = (axis2_phase_t *)axutil_array_list_get(phases, env, i); + + status = axis2_phase_invoke(phase, env, msg_ctx); + + if(status != AXIS2_SUCCESS) + { + const axis2_char_t *phase_name = axis2_phase_get_name(phase, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking phase %s failed", phase_name); + return status; + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "End:axis2_engine_invoke_phases"); + return AXIS2_SUCCESS; +} + +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) +{ + int i = 0; + int count = 0; + axis2_bool_t found_match = AXIS2_FALSE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_invocation_phases"); + AXIS2_PARAM_CHECK(env->error, phases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_FALSE); + + count = axutil_array_list_size(phases, env); + + for(i = 0; i < count && !(axis2_msg_ctx_is_paused(msg_ctx, env)); i++) + { + axis2_phase_t *phase = (axis2_phase_t *)axutil_array_list_get(phases, env, i); + const axis2_char_t *phase_name = axis2_phase_get_name(phase, env); + const axis2_char_t *paused_phase_name = axis2_msg_ctx_get_paused_phase_name(msg_ctx, env); + /* Skip invoking handlers until we find the paused phase */ + if(phase_name && paused_phase_name && 0 == axutil_strcmp(phase_name, paused_phase_name)) + { + int paused_handler_i = -1; + found_match = AXIS2_TRUE; + + paused_handler_i = axis2_msg_ctx_get_current_handler_index(msg_ctx, env); + /* Invoke the paused handler and rest of the handlers of the paused + * phase */ + axis2_phase_invoke_start_from_handler(phase, env, paused_handler_i, msg_ctx); + } + else + { + /* Now we have found the paused phase and invoked the rest of the + * handlers of that phase, invoke all the phases after that */ + if(found_match) + { + axis2_phase_invoke(phase, env, msg_ctx); + } + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "End:axis2_engine_resume_invocation_phases"); + return AXIS2_SUCCESS; +} + +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) +{ + if(axutil_strcmp(AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI, soap_namespace)) + return AXIOM_SOAP12_FAULT_CODE_RECEIVER; + return AXIOM_SOAP11_FAULT_CODE_RECEIVER; +} + +axis2_status_t +axis2_engine_check_must_understand_headers( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_header_t *soap_header = NULL; + axutil_hash_t *header_block_ht = NULL; + axutil_hash_index_t *hash_index = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + if(!soap_envelope) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap envelope not found in message context"); + return AXIS2_FAILURE; + } + + soap_header = axiom_soap_envelope_get_header(soap_envelope, env); + if(!soap_header) + return AXIS2_SUCCESS; + + header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env); + if(!header_block_ht) + return AXIS2_SUCCESS; + + for(hash_index = axutil_hash_first(header_block_ht, env); hash_index; hash_index + = axutil_hash_next(env, hash_index)) + { + void *hb = NULL; + axiom_soap_header_block_t *header_block = NULL; + axis2_char_t *role = NULL; + + axutil_hash_this(hash_index, NULL, NULL, &hb); + header_block = (axiom_soap_header_block_t *)hb; + + if(header_block) + { + if(axiom_soap_header_block_is_processed(header_block, env) + || !axiom_soap_header_block_get_must_understand(header_block, env)) + { + continue; + } + + /* If this header block is not targeted to me then its not my + problem. Currently this code only supports the "next" role; we + need to fix this to allow the engine/service to be in one or more + additional roles and then to check that any headers targeted for + that role too have been dealt with. */ + role = axiom_soap_header_block_get_role(header_block, env); + + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env) != AXIS2_TRUE) + { + /* SOAP 1.2 */ + if(!role || axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NEXT) != 0) + { + axiom_soap_envelope_t *temp_env = + axiom_soap_envelope_create_default_soap_fault_envelope(env, + "soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP12, NULL, + NULL); + axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env); + axis2_msg_ctx_set_wsa_action(msg_ctx, env, + "http://www.w3.org/2005/08/addressing/fault"); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault occured"); + return AXIS2_FAILURE; + } + } + else + { + /* SOAP 1.1 */ + if(!role || axutil_strcmp(role, AXIOM_SOAP11_SOAP_ACTOR_NEXT) != 0) + { + axiom_soap_envelope_t *temp_env = + axiom_soap_envelope_create_default_soap_fault_envelope(env, + "soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP11, NULL, + NULL); + axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env); + axis2_msg_ctx_set_wsa_action(msg_ctx, env, + "http://www.w3.org/2005/08/addressing/fault"); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault occured"); + return AXIS2_FAILURE; + } + + } + + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axutil_array_list_t *phases = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_receive"); + /* Find and invoke the phases */ + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + phases = axis2_conf_get_in_phases_upto_and_including_post_dispatch(conf, env); + + axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); + /* Invoking the message receiver */ + if(axis2_msg_ctx_get_server_side(msg_ctx, env) && !axis2_msg_ctx_is_paused(msg_ctx, env)) + { + /* Invoke the message receivers */ + axis2_op_ctx_t *op_ctx = NULL; + + status = axis2_engine_check_must_understand_headers(env, msg_ctx); + + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Checking for must understand headers failed"); + return status; + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); + if(op) + { + axis2_msg_recv_t *receiver = NULL; + receiver = axis2_op_get_msg_recv(op, env); + if(!receiver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Message receiver not set in operation description"); + return AXIS2_FAILURE; + } + status = axis2_msg_recv_receive(receiver, env, msg_ctx, axis2_msg_recv_get_derived( + receiver, env)); + } + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_resume_receive"); + return status; +} + +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) +{ + axis2_op_ctx_t *op_ctx = NULL; + axutil_array_list_t *phases = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_resume_send"); + /* Invoke the phases */ + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_op_t *op = axis2_op_ctx_get_op(op_ctx, env); + if(op) + { + phases = axis2_op_get_out_flow(op, env); + } + } + axis2_engine_resume_invocation_phases(engine, env, phases, msg_ctx); + + /* Invoking transport sender */ + if(!axis2_msg_ctx_is_paused(msg_ctx, env)) + { + /* Write the message to the wire */ + axis2_transport_out_desc_t *transport_out = NULL; + axis2_transport_sender_t *sender = NULL; + transport_out = axis2_msg_ctx_get_transport_out_desc(msg_ctx, env); + if(transport_out) + { + sender = axis2_transport_out_desc_get_sender(transport_out, env); + if(sender) + { + status = AXIS2_TRANSPORT_SENDER_INVOKE(sender, env, msg_ctx); + } + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_engine_resume_send"); + return status; +} + diff --git a/src/core/engine/handler.c b/src/core/engine/handler.c new file mode 100644 index 0000000..e9edf24 --- /dev/null +++ b/src/core/engine/handler.c @@ -0,0 +1,133 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_handler +{ + + /** handler description. This is a reference, hence a shallow copy. */ + axis2_handler_desc_t *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. + * @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_status_t(AXIS2_CALL * invoke)( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); +}; + +AXIS2_EXTERN axis2_handler_t *AXIS2_CALL +axis2_handler_create( + const axutil_env_t * env) +{ + axis2_handler_t *handler = NULL; + + handler = AXIS2_MALLOC(env->allocator, sizeof(axis2_handler_t)); + if(!handler) + { + AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_NO_MEMORY); + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_FAILURE); + return NULL; + } + + handler->handler_desc = NULL; + + return handler; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_handler_free( + axis2_handler_t * handler, + const axutil_env_t * env) +{ + AXIS2_FREE(env->allocator, handler); + return; +} + +AXIS2_EXTERN const axutil_string_t *AXIS2_CALL +axis2_handler_get_name( + const axis2_handler_t * handler, + const axutil_env_t * env) +{ + if(!(handler->handler_desc)) + return NULL; + + return axis2_handler_desc_get_name(handler->handler_desc, env); +} + +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) +{ + return handler->invoke(handler, env, msg_ctx); +} + +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) +{ + if(!(handler->handler_desc)) + return NULL; + + return axis2_handler_desc_get_param(handler->handler_desc, env, name); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_init( + axis2_handler_t * handler, + const axutil_env_t * env, + axis2_handler_desc_t * handler_desc) +{ + handler->handler_desc = handler_desc; + axis2_handler_desc_set_handler(handler_desc, env, handler); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL +axis2_handler_get_handler_desc( + const axis2_handler_t * handler, + const axutil_env_t * env) +{ + return handler->handler_desc; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_handler_set_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + AXIS2_HANDLER_INVOKE func) +{ + handler->invoke = func; + return AXIS2_SUCCESS; +} + diff --git a/src/core/engine/phase.c b/src/core/engine/phase.c new file mode 100644 index 0000000..a37ff95 --- /dev/null +++ b/src/core/engine/phase.c @@ -0,0 +1,1275 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +static axis2_status_t +axis2_phase_add_unique( + const axutil_env_t * env, + axutil_array_list_t * list, + axis2_handler_t * handler); + +static axis2_status_t +axis2_phase_remove_unique( + const axutil_env_t * env, + axutil_array_list_t * list, + axis2_handler_t * handler); + +struct axis2_phase +{ + + /** phase name */ + axis2_char_t *name; + + /** array list of handlers */ + axutil_array_list_t *handlers; + + /** first handler of phase */ + axis2_handler_t *first_handler; + + /** first handler of phase set? */ + axis2_bool_t first_handler_set; + + /** last handler of phase */ + axis2_handler_t *last_handler; + + /** last handler of phase set? */ + axis2_bool_t last_handler_set; + + /** + * handler_first and handler_last are the same handler + * that is for this phase there is only one handler + */ + axis2_bool_t is_one_handler; + + int ref; +}; + +AXIS2_EXTERN axis2_phase_t *AXIS2_CALL +axis2_phase_create( + const axutil_env_t * env, + const axis2_char_t * phase_name) +{ + axis2_phase_t *phase = NULL; + + phase = AXIS2_MALLOC(env->allocator, sizeof(axis2_phase_t)); + if(!phase) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + phase->name = NULL; + phase->handlers = NULL; + phase->first_handler = NULL; + phase->first_handler_set = AXIS2_FALSE; + phase->last_handler = NULL; + phase->last_handler_set = AXIS2_FALSE; + phase->is_one_handler = AXIS2_FALSE; + phase->ref = 1; + + phase->handlers = axutil_array_list_create(env, 10); + if(!(phase->handlers)) + { + + /** error is already set by last method array list container create */ + axis2_phase_free(phase, env); + return NULL; + } + + if(phase_name) + { + phase->name = axutil_strdup(env, phase_name); + if(!(phase->name)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + axis2_phase_free(phase, env); + return NULL; + } + } + + return phase; +} + +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) +{ + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "axis2_handler_t *%s added to the index %d of the phase %s", axutil_string_get_buffer( + axis2_handler_get_name(handler, env), env), index, phase->name); + + return axutil_array_list_add_at(phase->handlers, env, index, handler); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_add_handler( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler) +{ + AXIS2_LOG_INFO(env->log, "Handler %s added to phase %s", axutil_string_get_buffer( + axis2_handler_get_name(handler, env), env), phase->name); + + return axis2_phase_add_unique(env, phase->handlers, handler); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_remove_handler( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler) +{ + AXIS2_LOG_INFO(env->log, "Handler %s romoved from phase %s", axutil_string_get_buffer( + axis2_handler_get_name(handler, env), env), phase->name); + + return axis2_phase_remove_unique(env, phase->handlers, handler); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_invoke( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + int index = 0, size = 0; + axis2_status_t status = AXIS2_SUCCESS; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_invoke"); + axis2_msg_ctx_set_paused_phase_name(msg_ctx, env, phase->name); + if(phase->first_handler) + { + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + AXIS2_LOG_INFO(env->log, "Message context is paused in the phase %s", phase->name); + return AXIS2_SUCCESS; + } + else + { + const axis2_char_t *handler_name = axutil_string_get_buffer(axis2_handler_get_name( + phase->first_handler, env), env); + AXIS2_LOG_INFO(env->log, "Invoke the first handler %s within the phase %s", + handler_name, phase->name); + + status = axis2_handler_invoke(phase->first_handler, env, msg_ctx); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Handler %s invoke failed within phase %s", + handler_name, phase->name); + return status; + } + } + } + /* Invoking the rest of handlers except first_handler and last_handler */ + size = axutil_array_list_size(phase->handlers, env); + while(index < size) + { + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + break; + } + else + { + axis2_handler_t *handler = (axis2_handler_t *)axutil_array_list_get(phase->handlers, + env, index); + if(handler) + { + const axis2_char_t *handler_name = axutil_string_get_buffer(axis2_handler_get_name( + handler, env), env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Invoke the handler %s within the phase %s", handler_name, phase->name); + + /* Test code. This is used when valgrind is used to find leaks in Axis2/C modules.*/ + /*if(!axutil_strcmp(handler_name, "SandeshaGlobalInHandler") || !axutil_strcmp( + handler_name, "SandeshaInHandler")) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "dam_handler_name %s. dam_phase_name %s", handler_name, phase->name); + if(!axutil_strcmp(handler_name, "SandeshaGlobalInHandler")) + { + status = sandesha2_global_in_handler_invoke(phase->first_handler, env, msg_ctx); + } + if(!axutil_strcmp(handler_name, "SandeshaInHandler")) + { + status = sandesha2_in_handler_invoke(phase->first_handler, env, msg_ctx); + } + } + else*/ + status = axis2_handler_invoke(handler, env, msg_ctx); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler %s invoke failed within phase %s", handler_name, phase->name); + return status; + } + /* index increment should be done after the invoke function. If the invocation + failed this handler is taken care of and no need to revoke again */ + index++; + axis2_msg_ctx_set_current_handler_index(msg_ctx, env, index); + } + } + } + + /* If phase last handler is there invoke it here */ + if(phase->last_handler) + { + if(axis2_msg_ctx_is_paused(msg_ctx, env)) + { + AXIS2_LOG_INFO(env->log, "Message context is paused in the phase %s", phase->name); + return AXIS2_SUCCESS; + } + else + { + const axis2_char_t *handler_name = axutil_string_get_buffer(axis2_handler_get_name( + phase->last_handler, env), env); + AXIS2_LOG_INFO(env->log, "Invoke the last handler %s within the phase %s", + handler_name, phase->name); + + status = axis2_handler_invoke(phase->last_handler, env, msg_ctx); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler %s invoke failed within phase %s", handler_name, phase->name); + return status; + } + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_invoke"); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN const axis2_char_t *AXIS2_CALL +axis2_phase_get_name( + const axis2_phase_t * phase, + const axutil_env_t * env) +{ + return phase->name; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_phase_get_handler_count( + const axis2_phase_t * phase, + const axutil_env_t * env) +{ + return axutil_array_list_size(phase->handlers, env); +} + +AXIS2_EXTERN int AXIS2_CALL +_axis2_phase_get_before_after( + axis2_handler_t * handler, + const axutil_env_t * env) +{ + const axis2_char_t *before = NULL, *after = NULL; + axis2_handler_desc_t *handler_desc = NULL; + axis2_phase_rule_t *rules = NULL; + const axis2_char_t *name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env); + + handler_desc = axis2_handler_get_handler_desc(handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set for the Handler %s", name); + return AXIS2_FAILURE; + } + + rules = axis2_handler_desc_get_rules(handler_desc, env); + if(!rules) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler rules are not set for the Handler Description %s", name); + return AXIS2_FAILURE; + } + + before = axis2_phase_rule_get_before(rules, env); + after = axis2_phase_rule_get_after(rules, env); + + if(before && after) + { + if(!axutil_strcmp(before, after)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BEFORE_AFTER_HANDLERS_SAME, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Both before and after handlers cannot be the same"); + return AXIS2_FAILURE; + } + return AXIS2_PHASE_BOTH_BEFORE_AFTER; + } + else if(before) + { + return AXIS2_PHASE_BEFORE; + } + else if(after) + { + return AXIS2_PHASE_AFTER; + } + else + { + return AXIS2_PHASE_ANYWHERE; + } +} + +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) +{ + const axis2_char_t *handler_name = axutil_string_get_buffer( + axis2_handler_get_name(handler, env), env); + const axis2_char_t *phase_name = axis2_phase_get_name(phase, env); + if(phase->first_handler_set) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PHASE_FIRST_HANDLER_ALREADY_SET, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "First handler of phase already set, so cannot set handler %s " + "in to the phase %s as first handler", handler_name, phase_name); + return AXIS2_FAILURE; + } + else + { + if(_axis2_phase_get_before_after(handler, env) != AXIS2_PHASE_ANYWHERE) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE_FIRST_HANDLER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid first handler %s set for the Phase %s", handler_name, phase_name); + return AXIS2_FAILURE; + } + phase->first_handler = handler; + phase->first_handler_set = AXIS2_TRUE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + const axis2_char_t *handler_name = axutil_string_get_buffer( + axis2_handler_get_name(handler, env), env); + const axis2_char_t *phase_name = axis2_phase_get_name(phase, env); + if(phase->last_handler_set) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PHASE_LAST_HANDLER_ALREADY_SET, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Last handler of phase already set, so cannot set handler %s " + "in to the phase %s as last handler", handler_name, phase_name); + return AXIS2_FAILURE; + } + else + { + if(_axis2_phase_get_before_after(handler, env) != AXIS2_PHASE_ANYWHERE) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE_LAST_HANDLER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid last handler %s set for the Phase %s", + handler_name, phase_name); + return AXIS2_FAILURE; + } + phase->last_handler = handler; + phase->last_handler_set = AXIS2_TRUE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + axis2_phase_rule_t *rules = NULL; + axis2_handler_t *handler = NULL; + axis2_status_t status = AXIS2_SUCCESS; + axis2_bool_t first = AXIS2_FALSE, last = AXIS2_FALSE; + const axis2_char_t *handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name( + handler_desc, env), env); + if(phase->is_one_handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_PHASE_ADD_HANDLER_INVALID, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Only one handler allowed for phase %s, adding handler %s is not " + "allowed", phase->name, handler_desc_name); + return AXIS2_FAILURE; + } + else + { + rules = axis2_handler_desc_get_rules(handler_desc, env); + if(!rules) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler rules are not set for the Hanlder Description %s " + "within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + first = axis2_phase_rule_is_first(rules, env); + last = axis2_phase_rule_is_last(rules, env); + + if(first && last) + { + if(axutil_array_list_size(phase->handlers, env) > 0) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_RULES, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid handler rules, so unable to add handler %s to " + "phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + handler = axis2_handler_desc_get_handler(handler_desc, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler is not set for the Handler Description %s " + "within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + /*status = axutil_array_list_add(phase->handlers, env, handler); */ + status = axis2_phase_add_unique(env, phase->handlers, handler); + if(status) + phase->is_one_handler = AXIS2_TRUE; + return status; + } + else if(first) + { + handler = axis2_handler_desc_get_handler(handler_desc, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler is not set for the Handler Description %s " + "within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + return axis2_phase_set_first_handler(phase, env, handler); + } + else if(last) + { + handler = axis2_handler_desc_get_handler(handler_desc, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler is not set for the Handler Description %s " + "within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + return axis2_phase_set_last_handler(phase, env, handler); + } + else + { + handler = axis2_handler_desc_get_handler(handler_desc, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler is not set for the Handler Description %s " + "within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + return axis2_phase_insert_handler_desc(phase, env, handler_desc); + } + } +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +_axis2_phase_is_valid_before( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler) +{ + axis2_phase_rule_t *rules = NULL; + axis2_handler_desc_t *handler_desc = NULL; + const axis2_char_t *first_handler_name = NULL, *before = NULL; + + if(phase->first_handler) + { + handler_desc = axis2_handler_get_handler_desc(phase->first_handler, env); + if(!handler_desc) + return AXIS2_TRUE; + + first_handler_name = axutil_string_get_buffer( + axis2_handler_desc_get_name(handler_desc, env), env); + + if(!first_handler_name) + return AXIS2_TRUE; + + handler_desc = axis2_handler_get_handler_desc(handler, env); + if(!handler_desc) + return AXIS2_TRUE; + + rules = axis2_handler_desc_get_rules(handler_desc, env); + if(!rules) + return AXIS2_TRUE; + + before = axis2_phase_rule_get_before(rules, env); + if(!before) + return AXIS2_TRUE; + + if(!axutil_strcmp(first_handler_name, before)) + return AXIS2_FALSE; + else + return AXIS2_TRUE; + + } + return AXIS2_TRUE; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +_axis2_phase_is_valid_after( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler) +{ + axis2_phase_rule_t *rules = NULL; + axis2_handler_desc_t *handler_desc = NULL; + const axis2_char_t *last_handler_name = NULL, *after = NULL; + + if(phase->last_handler) + { + handler_desc = axis2_handler_get_handler_desc(phase->last_handler, env); + if(!handler_desc) + return AXIS2_TRUE; + + last_handler_name = axutil_string_get_buffer( + axis2_handler_desc_get_name(handler_desc, env), env); + + if(!last_handler_name) + return AXIS2_TRUE; + + handler_desc = axis2_handler_get_handler_desc(handler, env); + if(!handler_desc) + return AXIS2_TRUE; + + rules = axis2_handler_desc_get_rules(handler_desc, env); + if(!rules) + return AXIS2_TRUE; + + after = axis2_phase_rule_get_after(rules, env); + if(!after) + return AXIS2_TRUE; + + if(!axutil_strcmp(last_handler_name, after)) + return AXIS2_FALSE; + else + return AXIS2_TRUE; + + } + return AXIS2_TRUE; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_insert_before( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler) +{ + axis2_phase_rule_t *rules = NULL; + axis2_handler_desc_t *handler_desc = NULL; + const axis2_char_t *handler_name = NULL, *before = NULL; + int i = 0; + int size = 0; + const axis2_char_t *name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env); + const axis2_char_t *handler_desc_name = NULL; + + handler_desc = axis2_handler_get_handler_desc(handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the handler %s within phase %s", name, phase->name); + return AXIS2_FAILURE; + } + handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), + env); + + rules = axis2_handler_desc_get_rules(handler_desc, env); + if(!rules) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler rules are not set in the handler description %s within " + "phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + before = axis2_phase_rule_get_before(rules, env); + if(!before) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Rule `before` is not set in the handler rules for handler %s " + "within phase %s", name, phase->name); + return AXIS2_FAILURE; + } + + if(phase->last_handler) + { + const axis2_char_t *last_handler_name = axutil_string_get_buffer(axis2_handler_get_name( + phase->last_handler, env), env); + handler_desc = axis2_handler_get_handler_desc(phase->last_handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the last handler %s of " + "phase %s", last_handler_name, phase->name); + return AXIS2_FAILURE; + } + + handler_name + = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), env); + if(!handler_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler name is not set in the handler description for " + "last handler %s within phase %s", last_handler_name, phase->name); + return AXIS2_FAILURE; + } + + if(!axutil_strcmp(before, handler_name)) + { + /*return axutil_array_list_add(phase->handlers, env, handler); */ + return axis2_phase_add_unique(env, phase->handlers, handler); + } + } + + size = axutil_array_list_size(phase->handlers, env); + + for(i = 0; i < size; i++) + { + axis2_handler_t *temp_handler = (axis2_handler_t *)axutil_array_list_get(phase->handlers, + env, i); + if(temp_handler) + { + const axis2_char_t *temp_handler_name = axutil_string_get_buffer( + axis2_handler_get_name(temp_handler, env), env); + handler_desc = axis2_handler_get_handler_desc(temp_handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler Description is not set for the Handler %s " + "within phase %s", temp_handler_name, phase->name); + return AXIS2_FAILURE; + } + + handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), + env); + if(!handler_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler name is not set in the handler description for " + "handler %s within phase %s", temp_handler_name, phase->name); + return AXIS2_FAILURE; + } + + if(!axutil_strcmp(before, handler_name)) + { + return axutil_array_list_add_at(phase->handlers, env, i, handler); + } + } + } + /* add as the last handler */ + /* return axutil_array_list_add(phase->handlers, env, handler); */ + return axis2_phase_add_unique(env, phase->handlers, handler); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_insert_after( + axis2_phase_t * phase, + const axutil_env_t * env, + axis2_handler_t * handler) +{ + axis2_phase_rule_t *rules = NULL; + axis2_handler_desc_t *handler_desc = NULL; + const axis2_char_t *handler_name = NULL; + const axis2_char_t *after = NULL; + int i = 0; + int size = 0; + const axis2_char_t *name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env); + const axis2_char_t *handler_desc_name = NULL; + + handler_desc = axis2_handler_get_handler_desc(handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the handler %s within phase %s", name, phase->name); + return AXIS2_FAILURE; + } + handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), + env); + rules = axis2_handler_desc_get_rules(handler_desc, env); + if(!rules) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler rules are not set in the handler description %s within " + "phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + after = axis2_phase_rule_get_after(rules, env); + if(!after) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Rule `after` is not set in the handler rules for handler desc " + "%s within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + if(phase->first_handler) + { + const axis2_char_t *first_handler_name = axutil_string_get_buffer(axis2_handler_get_name( + phase->first_handler, env), env); + handler_desc = axis2_handler_get_handler_desc(phase->first_handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the first handler %s " + "within phase %s", first_handler_name, phase->name); + return AXIS2_FAILURE; + } + + handler_name + = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), env); + if(!handler_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler name is not set in the handler description for " + "handler %s within phase %s", name, phase->name); + return AXIS2_FAILURE; + } + + if(!axutil_strcmp(after, handler_name)) + { + return axutil_array_list_add_at(phase->handlers, env, 0, handler); + } + } + + size = axutil_array_list_size(phase->handlers, env); + + for(i = 0; i < size; i++) + { + axis2_handler_t *temp_handler = (axis2_handler_t *)axutil_array_list_get(phase->handlers, + env, i); + if(temp_handler) + { + const axis2_char_t *temp_handler_name = axutil_string_get_buffer( + axis2_handler_get_name(temp_handler, env), env); + handler_desc = axis2_handler_get_handler_desc(temp_handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the handler %s within" + " phase %s", temp_handler_name, phase->name); + return AXIS2_FAILURE; + } + + handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), + env); + if(!handler_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler name is not set in the handler description %s " + "within phase %s", temp_handler_name, phase->name); + return AXIS2_FAILURE; + } + + if(!axutil_strcmp(after, handler_name)) + { + if(i == (size - 1)) + { + return axis2_phase_add_unique(env, phase->handlers, handler); + } + else + return axutil_array_list_add_at(phase->handlers, env, i + 1, handler); + } + } + } + + if(size > 0) + return axutil_array_list_add_at(phase->handlers, env, 0, handler); + else + { + return axis2_phase_add_unique(env, phase->handlers, handler); + } +} + +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) +{ + int before = -1; + int after = -1; + axis2_phase_rule_t *rules = NULL; + axis2_handler_desc_t *handler_desc = NULL; + const axis2_char_t *before_handler_name = NULL, *after_handler_name = NULL, *after_name = NULL, + *before_name = NULL, *handler_name = NULL; + int i = 0; + int size = 0; + const axis2_char_t *name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env); + const axis2_char_t *handler_desc_name = NULL; + + handler_desc = axis2_handler_get_handler_desc(handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the handler %s within phase %s", name, phase->name); + return AXIS2_FAILURE; + } + handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), + env); + + rules = axis2_handler_desc_get_rules(handler_desc, env); + if(!rules) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler rules are not set in the handler description %s within " + "phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + before_name = axis2_phase_rule_get_before(rules, env); + if(!before_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Rule `before` is not set in the handler rules for handler desc " + " %s within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + after_name = axis2_phase_rule_get_after(rules, env); + if(!after_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Rule `after` is not set in the handler rules for handler desc " + "%s within phase %s", handler_desc_name, phase->name); + return AXIS2_FAILURE; + } + + if(phase->first_handler) + { + const axis2_char_t *first_handler_name = axutil_string_get_buffer(axis2_handler_get_name( + phase->first_handler, env), env); + handler_desc = axis2_handler_get_handler_desc(phase->first_handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the first handler %s " + "within phase %s", first_handler_name, phase->name); + return AXIS2_FAILURE; + } + + before_handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, + env), env); + if(!before_handler_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler name is not set in the handler description for the " + "first handler %s within phase %s", first_handler_name, phase->name); + return AXIS2_FAILURE; + } + } + + if(phase->last_handler) + { + const axis2_char_t *last_handler_name = axutil_string_get_buffer(axis2_handler_get_name( + phase->last_handler, env), env); + handler_desc = axis2_handler_get_handler_desc(phase->last_handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description is not set in the last handler %s " + "within phase %s", last_handler_name, phase->name); + return AXIS2_FAILURE; + } + + after_handler_name = axutil_string_get_buffer( + axis2_handler_desc_get_name(handler_desc, env), env); + if(!after_handler_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler name is not set in the handler description for the " + "last handler %s within phase %s", last_handler_name, phase->name); + return AXIS2_FAILURE; + } + } + + if(before_handler_name && after_handler_name) + { + if(!axutil_strcmp(before_handler_name, before_name) && !axutil_strcmp(after_handler_name, + after_name)) + { + return axis2_phase_add_unique(env, phase->handlers, handler); + } + } + + if(after_handler_name) + { + if(!axutil_strcmp(after_handler_name, after_name)) + after = 0; + } + + size = axutil_array_list_size(phase->handlers, env); + + if(after_handler_name) + { + if(!axutil_strcmp(before_handler_name, before_name)) + before = size; + } + + for(i = 0; i < size; i++) + { + axis2_handler_t *temp_handler = (axis2_handler_t *)axutil_array_list_get(phase->handlers, + env, i); + if(temp_handler) + { + const axis2_char_t *temp_handler_name = axutil_string_get_buffer( + axis2_handler_get_name(temp_handler, env), env); + handler_desc = axis2_handler_get_handler_desc(temp_handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler Description is not set for the Handler %s " + "within phase %s", temp_handler_name, phase->name); + return AXIS2_FAILURE; + } + + handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), + env); + if(!handler_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler name is not set in the handler Description for " + "handler %s within phase %s", temp_handler_name, phase->name); + return AXIS2_FAILURE; + } + + if(!axutil_strcmp(handler_name, after_name)) + after = i; + if(!axutil_strcmp(handler_name, before_name)) + before = i; + } + + if((after >= 0) && (before >= 0)) + { + /*both the before and after indexes have been found */ + if(after > before) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Both the before and after indexes have been found and " + "`after` comes before `before` which is wrong within " + "phase %s", phase->name); + return AXIS2_FAILURE; + } + else + { + if(after + 1 < size) + { + return axutil_array_list_add_at(phase->handlers, env, after + 1, handler); + } + else + { + return axis2_phase_add_unique(env, phase->handlers, handler); + } + } + } + } + return axis2_phase_add_unique(env, phase->handlers, handler); +} + +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) +{ + int type = 0; + axis2_handler_t *handler = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axis2_char_t *handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name( + handler_desc, env), env); + const axis2_char_t *handler_name = NULL; + handler = axis2_handler_desc_get_handler(handler_desc, env); + + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Handler is not set in the handler description %s", + handler_desc_name); + return AXIS2_FAILURE; + } + handler_name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env); + + if(!_axis2_phase_is_valid_after(phase, env, handler)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid Handler State for the handler %s within the phase %s", handler_name, + phase->name); + return AXIS2_FAILURE; + } + + if(!_axis2_phase_is_valid_before(phase, env, handler)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid Handler State for the handler %s within the phase %s", handler_name, + phase->name); + return AXIS2_FAILURE; + } + + type = _axis2_phase_get_before_after(handler, env); + + switch(type) + { + case 0: /*AXIS2_BOTH_BEFORE_AFTER: */ + status = axis2_phase_insert_before_and_after(phase, env, handler); + break; + case 1: /*AXIS2_BEFORE: */ + status = axis2_phase_insert_before(phase, env, handler); + break; + case 2: /*AXIS2_AFTER: */ + status = axis2_phase_insert_after(phase, env, handler); + break; + case 3: /*AXIS2_ANYWHERE: */ + status = axis2_phase_add_unique(env, phase->handlers, handler); + break; + default: + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler description %s insertion failed within the phase %s", handler_desc_name, + phase->name); + status = AXIS2_FAILURE; + break; + } + return status; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phase_get_all_handlers( + const axis2_phase_t * phase, + const axutil_env_t * env) +{ + return phase->handlers; +} + +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, + axis2_msg_ctx_t * msg_ctx) +{ + int i = 0, size = 0; + axis2_status_t status = AXIS2_SUCCESS; + + axis2_msg_ctx_set_paused_phase_name(msg_ctx, env, phase->name); + + size = axutil_array_list_size(phase->handlers, env); + for(i = paused_handler_index; i < size; i++) + { + axis2_handler_t *handler = + (axis2_handler_t *)axutil_array_list_get(phase->handlers, env, i); + if(handler) + { + const axis2_char_t *handler_name = axutil_string_get_buffer(axis2_handler_get_name( + handler, env), env); + int index = -1; + + axis2_handler_desc_t *handler_desc = axis2_handler_get_handler_desc(handler, env); + if(!handler_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid Handler State for the handler %s within phase %s", handler_name, + phase->name); + return AXIS2_FAILURE; + } + + axis2_handler_invoke(handler, env, msg_ctx); + index = axis2_msg_ctx_get_current_handler_index(msg_ctx, env); + axis2_msg_ctx_set_current_handler_index(msg_ctx, env, (index + 1)); + } + } + return status; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_phase_free( + axis2_phase_t * phase, + const axutil_env_t * env) +{ + if(--(phase->ref) > 0) + { + return; + } + + if(phase->name) + { + AXIS2_FREE(env->allocator, phase->name); + } + + if(phase->handlers) + { + axutil_array_list_free(phase->handlers, env); + } + AXIS2_FREE(env->allocator, phase); + return; +} + +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) +{ + axis2_handler_t *handler; + const axis2_char_t *handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name( + handler_desc, env), env); + handler = axis2_handler_desc_get_handler(handler_desc, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler is not set in the Handler Description %s within phase %s", handler_desc_name, + phase->name); + return AXIS2_FAILURE; + } + return axis2_phase_remove_unique(env, phase->handlers, handler); +} + +static axis2_status_t +axis2_phase_add_unique( + const axutil_env_t * env, + axutil_array_list_t * list, + axis2_handler_t * handler) +{ + int i = 0, size = 0; + axis2_bool_t add_handler = AXIS2_TRUE; + const axutil_string_t *handler_name = NULL; + + handler_name = axis2_handler_get_name(handler, env); + size = axutil_array_list_size(list, env); + for(i = 0; i < size; i++) + { + axis2_handler_t *obj = NULL; + const axutil_string_t *obj_name = NULL; + + obj = (axis2_handler_t *)axutil_array_list_get(list, env, i); + obj_name = axis2_handler_get_name(obj, env); + if(obj == handler) + { + add_handler = AXIS2_FALSE; + break; + } + else if(!axutil_strcmp(axutil_string_get_buffer(handler_name, env), + axutil_string_get_buffer(obj_name, env))) + { + add_handler = AXIS2_FALSE; + break; + } + } + if(add_handler) + axutil_array_list_add(list, env, handler); + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_phase_remove_unique( + const axutil_env_t * env, + axutil_array_list_t * list, + axis2_handler_t * handler) +{ + int i = 0, size = 0; + axis2_bool_t remove_handler = AXIS2_FALSE; + const axutil_string_t *handler_name = NULL; + + handler_name = axis2_handler_get_name(handler, env); + size = axutil_array_list_size(list, env); + for(i = 0; i < size; i++) + { + axis2_handler_t *obj = NULL; + const axutil_string_t *obj_name = NULL; + + obj = (axis2_handler_t *)axutil_array_list_get(list, env, i); + obj_name = axis2_handler_get_name(obj, env); + if(obj == handler) + { + remove_handler = AXIS2_TRUE; + break; + } + else if(!axutil_strcmp(axutil_string_get_buffer(handler_name, env), + axutil_string_get_buffer(obj_name, env))) + { + remove_handler = AXIS2_TRUE; + break; + } + } + if(remove_handler) + axutil_array_list_remove(list, env, i); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_increment_ref( + axis2_phase_t * phase, + const axutil_env_t * env) +{ + phase->ref++; + return AXIS2_SUCCESS; +} + diff --git a/src/core/engine/req_uri_disp.c b/src/core/engine/req_uri_disp.c new file mode 100644 index 0000000..dbc89b7 --- /dev/null +++ b/src/core/engine/req_uri_disp.c @@ -0,0 +1,206 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const axis2_char_t *AXIS2_REQ_URI_DISP_NAME = "request_uri_based_dispatcher"; + +axis2_status_t AXIS2_CALL +axis2_req_uri_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + +axis2_svc_t *AXIS2_CALL axis2_req_uri_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + +axis2_op_t *AXIS2_CALL axis2_req_uri_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc); + +AXIS2_EXTERN axis2_disp_t *AXIS2_CALL +axis2_req_uri_disp_create( + const axutil_env_t * env) +{ + axis2_disp_t *disp = NULL; + axis2_handler_t *handler = NULL; + axutil_string_t *name = NULL; + + name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_REQ_URI_DISP_NAME); + + disp = axis2_disp_create(env, name); + if(!disp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + handler = axis2_disp_get_base(disp, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + return NULL; + } + + axis2_handler_set_invoke(handler, env, axis2_req_uri_disp_invoke); + + axutil_string_free(name, env); + + return disp; +} + +axis2_svc_t *AXIS2_CALL +axis2_req_uri_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *endpoint_ref = NULL; + axis2_svc_t *svc = NULL; + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); + + if(endpoint_ref) + { + const axis2_char_t *address = NULL; + + address = axis2_endpoint_ref_get_address(endpoint_ref, env); + if(address) + { + axis2_char_t **url_tokens = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Checking for service using target endpoint address : %s", address); + + url_tokens = axutil_parse_request_url_for_svc_and_op(env, address); + + if(url_tokens) + { + if(url_tokens[0]) + { + axis2_conf_ctx_t *conf_ctx = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axis2_conf_t *conf = NULL; + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + svc = axis2_conf_get_svc(conf, env, url_tokens[0]); + if(svc) + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Service found using target endpoint address"); + } + } + AXIS2_FREE(env->allocator, url_tokens[0]); + + if(url_tokens[1]) + { + AXIS2_FREE(env->allocator, url_tokens[1]); + } + + } + AXIS2_FREE(env->allocator, url_tokens); + url_tokens = NULL; + } + } + } + + return svc; +} + +axis2_op_t *AXIS2_CALL +axis2_req_uri_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + axis2_endpoint_ref_t *endpoint_ref = NULL; + axis2_op_t *op = NULL; + + AXIS2_PARAM_CHECK(env->error, svc, NULL); + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); + + if(endpoint_ref) + { + const axis2_char_t *address = NULL; + + address = axis2_endpoint_ref_get_address(endpoint_ref, env); + if(address) + { + axis2_char_t **url_tokens = NULL; + + url_tokens = axutil_parse_request_url_for_svc_and_op(env, address); + + if(url_tokens) + { + if(url_tokens[1]) + { + axutil_qname_t *op_qname = NULL; + AXIS2_LOG_DEBUG( + env->log, + AXIS2_LOG_SI, + "Checking for operation using \ + target endpoint uri fragment : %s", + url_tokens[1]); + op_qname = axutil_qname_create(env, url_tokens[1], NULL, NULL); + op = axis2_svc_get_op_with_name(svc, env, axutil_qname_get_localpart(op_qname, + env)); + axutil_qname_free(op_qname, env); + if(op) + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Operation found using target endpoint uri fragment"); + } + if(url_tokens[0]) + AXIS2_FREE(env->allocator, url_tokens[0]); + if(url_tokens[1]) + AXIS2_FREE(env->allocator, url_tokens[1]); + AXIS2_FREE(env->allocator, url_tokens); + } + } + } + + return op; +} + +axis2_status_t AXIS2_CALL +axis2_req_uri_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_req_uri_disp_find_svc); + axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_req_uri_disp_find_op); + return axis2_disp_find_svc_and_op(handler, env, msg_ctx); +} + diff --git a/src/core/engine/rest_disp.c b/src/core/engine/rest_disp.c new file mode 100644 index 0000000..4782568 --- /dev/null +++ b/src/core/engine/rest_disp.c @@ -0,0 +1,350 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +const axis2_char_t *AXIS2_REST_DISP_NAME = "rest_dispatcher"; + +axis2_status_t AXIS2_CALL +axis2_rest_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + +axis2_svc_t *AXIS2_CALL axis2_rest_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + +axis2_op_t *AXIS2_CALL axis2_rest_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc); + +axis2_op_t *AXIS2_CALL +axis2_rest_disp_get_rest_op_with_method_and_location( + const axis2_svc_t * svc, + const axutil_env_t * env, + const axis2_char_t * method, + const axis2_char_t * location, + int * param_count, + axis2_char_t **** params); + +AXIS2_EXTERN axis2_disp_t *AXIS2_CALL +axis2_rest_disp_create( + const axutil_env_t * env) +{ + axis2_disp_t *disp = NULL; + axis2_handler_t *handler = NULL; + axutil_string_t *name = NULL; + + name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_REST_DISP_NAME); + + disp = axis2_disp_create(env, name); + if(!disp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + handler = axis2_disp_get_base(disp, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + return NULL; + } + + axis2_handler_set_invoke(handler, env, axis2_rest_disp_invoke); + + axutil_string_free(name, env); + + return disp; +} + +axis2_svc_t *AXIS2_CALL +axis2_rest_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axis2_endpoint_ref_t *endpoint_ref = NULL; + axis2_svc_t *svc = NULL; + + if(!axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); + + if(endpoint_ref) + { + const axis2_char_t *address = NULL; + + address = axis2_endpoint_ref_get_address(endpoint_ref, env); + if(address) + { + axis2_char_t **url_tokens = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Checking for service using target endpoint address : %s", address); + + url_tokens = axutil_parse_request_url_for_svc_and_op(env, address); + + if(url_tokens) + { + if(url_tokens[0]) + { + axis2_conf_ctx_t *conf_ctx = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axis2_conf_t *conf = NULL; + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + svc = axis2_conf_get_svc(conf, env, url_tokens[0]); + if(svc) + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Service found using target endpoint address"); + } + } + AXIS2_FREE(env->allocator, url_tokens[0]); + + if(url_tokens[1]) + { + AXIS2_FREE(env->allocator, url_tokens[1]); + } + + } + AXIS2_FREE(env->allocator, url_tokens); + url_tokens = NULL; + } + } + } + + return svc; +} + +axis2_op_t *AXIS2_CALL +axis2_rest_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + axis2_endpoint_ref_t *endpoint_ref = NULL; + axis2_op_t *op = NULL; + axiom_soap_envelope_t *soap_env = NULL; + axiom_soap_body_t *soap_body = NULL; + axiom_element_t *body_child = NULL; + axiom_node_t *body_child_node = NULL; + axiom_node_t *body_element_node = NULL; + axis2_bool_t soap_env_exists = AXIS2_TRUE; + int i = 0; + + axutil_array_list_t *param_keys = NULL; + axutil_array_list_t *param_values = NULL; + + AXIS2_PARAM_CHECK(env->error, svc, NULL); + + if(!axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); + + if(endpoint_ref) + { + const axis2_char_t *address = NULL; + + address = axis2_endpoint_ref_get_address(endpoint_ref, env); + if(address) + { + axis2_char_t **url_tokens = NULL; + + url_tokens = axutil_parse_request_url_for_svc_and_op(env, address); + + if(url_tokens) + { + if(url_tokens[0]) + { + axis2_char_t *location = NULL; + + location = strstr(address, url_tokens[0]); + if(location) + { + const axis2_char_t *method = NULL; + + location += strlen(url_tokens[0]); + param_keys = axutil_array_list_create(env, 10); + if(!param_keys) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create the live rest parameter maps"); + return NULL; + } + param_values = axutil_array_list_create(env, 10); + + if(!param_values) + { + axutil_array_list_free(param_keys, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create the live rest parameter maps"); + return NULL; + } + method = axis2_msg_ctx_get_rest_http_method(msg_ctx, env); + op = axis2_core_utils_get_rest_op_with_method_and_location(svc, env, + method, location, param_keys, param_values); + } + } + if(url_tokens[0]) + AXIS2_FREE(env->allocator, url_tokens[0]); + if(url_tokens[1]) + AXIS2_FREE(env->allocator, url_tokens[1]); + AXIS2_FREE(env->allocator, url_tokens); + } + } + } + + if(!op) + { + if(param_keys) + { + for(i = 0; i < axutil_array_list_size(param_keys, env); i++) + { + void *value = axutil_array_list_get(param_keys, env, i); + AXIS2_FREE(env->allocator, value); + } + axutil_array_list_free(param_keys, env); + } + if(param_values) + { + for(i = 0; i < axutil_array_list_size(param_values, env); i++) + { + void *value = axutil_array_list_get(param_values, env, i); + AXIS2_FREE(env->allocator, value); + } + axutil_array_list_free(param_values, env); + } + return NULL; + } + + soap_env = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + if(!soap_env) + { + soap_env_exists = AXIS2_FALSE; + soap_env = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + } + if(soap_env) + { + soap_body = axiom_soap_envelope_get_body(soap_env, env); + } + if(!soap_body) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, AXIS2_FAILURE); + + if(param_keys) + { + for(i = 0; i < axutil_array_list_size(param_keys, env); i++) + { + void *value = axutil_array_list_get(param_keys, env, i); + AXIS2_FREE(env->allocator, value); + } + axutil_array_list_free(param_keys, env); + } + if(param_values) + { + for(i = 0; i < axutil_array_list_size(param_values, env); i++) + { + void *value = axutil_array_list_get(param_values, env, i); + AXIS2_FREE(env->allocator, value); + } + axutil_array_list_free(param_values, env); + } + return NULL; + } + + body_element_node = axiom_soap_body_get_base_node(soap_body, env); + + if(body_element_node) + { + body_child_node = axiom_node_get_first_child(body_element_node, env); + } + + if(!body_child_node) + { + body_child = axiom_element_create_with_qname(env, NULL, axis2_op_get_qname(op, env), + &body_child_node); + axiom_soap_body_add_child(soap_body, env, body_child_node); + } + + if(param_keys && param_values) + { + for(i = 0; i < axutil_array_list_size(param_keys, env); i++) + { + axis2_char_t *param_key = NULL; + axis2_char_t *param_value = NULL; + + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + + param_key = axutil_array_list_get(param_keys, env, i); + param_value = axutil_array_list_get(param_values, env, i); + + element = axiom_element_create(env, NULL, param_key, NULL, &node); + axiom_element_set_text(element, env, param_value, node); + axiom_node_add_child(body_child_node, env, node); + + AXIS2_FREE(env->allocator, param_key); + AXIS2_FREE(env->allocator, param_value); + } + + axutil_array_list_free(param_keys, env); + axutil_array_list_free(param_values, env); + } + + if(!soap_env_exists) + { + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_env); + } + + return op; +} + +axis2_status_t AXIS2_CALL +axis2_rest_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_rest_disp_find_svc); + axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_rest_disp_find_op); + return axis2_disp_find_svc_and_op(handler, env, msg_ctx); +} + diff --git a/src/core/engine/soap_action_disp.c b/src/core/engine/soap_action_disp.c new file mode 100644 index 0000000..10d6fa4 --- /dev/null +++ b/src/core/engine/soap_action_disp.c @@ -0,0 +1,155 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const axis2_char_t *AXIS2_SOAP_ACTION_DISP_NAME = "soap_action_based_dispatcher"; + +axis2_status_t AXIS2_CALL +axis2_soap_action_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + +axis2_svc_t *AXIS2_CALL axis2_soap_action_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + +axis2_op_t *AXIS2_CALL axis2_soap_action_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc); + +axis2_disp_t *AXIS2_CALL +axis2_soap_action_disp_create( + const axutil_env_t * env) +{ + axis2_disp_t *disp = NULL; + axis2_handler_t *handler = NULL; + axutil_string_t *name = NULL; + + name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_SOAP_ACTION_DISP_NAME); + + disp = axis2_disp_create(env, name); + if(!disp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + handler = axis2_disp_get_base(disp, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + return NULL; + } + + axis2_handler_set_invoke(handler, env, axis2_soap_action_disp_invoke); + + axutil_string_free(name, env); + + return disp; +} + +axis2_svc_t *AXIS2_CALL +axis2_soap_action_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Checking for service using SOAPAction is not implemented"); + return NULL; +} + +axis2_op_t *AXIS2_CALL +axis2_soap_action_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + const axis2_char_t *action = NULL; + axutil_qname_t *name = NULL; + axis2_op_t *op = NULL; + + AXIS2_PARAM_CHECK(env->error, svc, NULL); + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + action = axutil_string_get_buffer(axis2_msg_ctx_get_soap_action(msg_ctx, env), env); + + if(action) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Checking for operation using SOAPAction : %s", + action); + + if(!op) + { + const axis2_char_t *op_name = NULL; + op_name = axutil_rindex(action, '/'); + + if(op_name) + { + op_name += 1; + } + else + { + op_name = action; + } + + if(op_name) + { + op = axis2_svc_get_op_with_name(svc, env, op_name); + } + } + + if(!op) + { + name = axutil_qname_create(env, action, NULL, NULL); + op = axis2_svc_get_op_with_qname(svc, env, name); + axutil_qname_free(name, env); + } + + if(op) + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Operation found using SOAPAction"); + } + return op; +} + +axis2_status_t AXIS2_CALL +axis2_soap_action_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_soap_action_disp_find_svc); + axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_soap_action_disp_find_op); + + return axis2_disp_find_svc_and_op(handler, env, msg_ctx); +} + diff --git a/src/core/engine/soap_body_disp.c b/src/core/engine/soap_body_disp.c new file mode 100644 index 0000000..702a988 --- /dev/null +++ b/src/core/engine/soap_body_disp.c @@ -0,0 +1,231 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const axis2_char_t *AXIS2_SOAP_MESSAGE_BODY_DISP_NAME = "soap_message_body_based_dispatcher"; + +axis2_status_t AXIS2_CALL +axis2_soap_body_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx *msg_ctx); + +axis2_svc_t *AXIS2_CALL axis2_soap_body_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env); + +axis2_op_t *AXIS2_CALL axis2_soap_body_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc); + +axis2_disp_t *AXIS2_CALL +axis2_soap_body_disp_create( + const axutil_env_t * env) +{ + axis2_disp_t *disp = NULL; + axis2_handler_t *handler = NULL; + axutil_string_t *name = NULL; + + name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_SOAP_MESSAGE_BODY_DISP_NAME); + + disp = axis2_disp_create(env, name); + if(!disp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + handler = axis2_disp_get_base(disp, env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + return NULL; + } + + axis2_handler_set_invoke(handler, env, axis2_soap_body_disp_invoke); + + axutil_string_free(name, env); + + return disp; +} + +axis2_svc_t *AXIS2_CALL +axis2_soap_body_disp_find_svc( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_svc_t *svc = NULL; + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + if(soap_envelope) + { + axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + if(soap_body) + { + axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env); + if(body_node) + { + axiom_node_t *body_first_child_node = axiom_node_get_first_element(body_node, env); + + if(body_first_child_node) + { + if(axiom_node_get_node_type(body_first_child_node, env) == AXIOM_ELEMENT) + { + axiom_element_t *element = NULL; + element = (axiom_element_t *)axiom_node_get_data_element( + body_first_child_node, env); + if(element) + { + axiom_namespace_t *ns = axiom_element_get_namespace(element, env, + body_first_child_node); + if(ns) + { + axis2_char_t *uri = axiom_namespace_get_uri(ns, env); + if(uri) + { + axis2_char_t **url_tokens = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Checking for service " + "using SOAP message body's " + "first child's namespace " + "URI : %s", uri); + + url_tokens = axutil_parse_request_url_for_svc_and_op(env, uri); + + if(url_tokens) + { + if(url_tokens[0]) + { + axis2_conf_ctx_t *conf_ctx = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axis2_conf_t *conf = NULL; + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + svc = axis2_conf_get_svc(conf, env, + url_tokens[0]); + if(svc) + AXIS2_LOG_DEBUG(env-> log, AXIS2_LOG_SI, + "Service found " + "using SOAP message" + "body's first " + "child's namespace URI"); + } + } + AXIS2_FREE(env->allocator, url_tokens[0]); + } + + AXIS2_FREE(env->allocator, url_tokens); + url_tokens = NULL; + } + } + } + } + } + } + } + } + } + + return svc; +} + +axis2_op_t *AXIS2_CALL +axis2_soap_body_disp_find_op( + axis2_msg_ctx_t * msg_ctx, + const axutil_env_t * env, + axis2_svc_t * svc) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_op_t *op = NULL; + + AXIS2_PARAM_CHECK(env->error, svc, NULL); + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + return NULL; + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + if(soap_envelope) + { + axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + if(soap_body) + { + axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, env); + if(body_node) + { + axiom_node_t *body_first_child_node = axiom_node_get_first_element(body_node, env); + + if(body_first_child_node) + { + if(axiom_node_get_node_type(body_first_child_node, env) == AXIOM_ELEMENT) + { + axiom_element_t *element = NULL; + element = (axiom_element_t *)axiom_node_get_data_element( + body_first_child_node, env); + if(element) + { + axis2_char_t *element_name = axiom_element_get_localname(element, env); + if(element_name) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Checking for operation using SOAP message" + "body's first child's local name : %s", element_name); + + op = axis2_svc_get_op_with_name(svc, env, element_name); + + if(op) + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Operation found using SOAP message " + "body's first child's local name"); + + } + } + } + } + } + } + } + return op; +} + +axis2_status_t AXIS2_CALL +axis2_soap_body_disp_invoke( + axis2_handler_t * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_soap_body_disp_find_svc); + axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_soap_body_disp_find_op); + return axis2_disp_find_svc_and_op(handler, env, msg_ctx); +} + diff --git a/src/core/phaseresolver/Makefile.am b/src/core/phaseresolver/Makefile.am new file mode 100644 index 0000000..62724f2 --- /dev/null +++ b/src/core/phaseresolver/Makefile.am @@ -0,0 +1,9 @@ +noinst_LTLIBRARIES = libaxis2_phaseresolver.la + +libaxis2_phaseresolver_la_SOURCES = phase_holder.c \ + phase_resolver.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/axiom/include \ + -I$(top_builddir)/util/include diff --git a/src/core/phaseresolver/phase_holder.c b/src/core/phaseresolver/phase_holder.c new file mode 100644 index 0000000..f371dd4 --- /dev/null +++ b/src/core/phaseresolver/phase_holder.c @@ -0,0 +1,243 @@ +/* + * 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. + */ + +#include + +struct axis2_phase_holder +{ + axutil_array_list_t *phase_list; +}; + +AXIS2_EXTERN axis2_phase_holder_t *AXIS2_CALL +axis2_phase_holder_create( + const axutil_env_t * env) +{ + axis2_phase_holder_t *phase_holder = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + phase_holder = (axis2_phase_holder_t *)AXIS2_MALLOC(env-> allocator, + sizeof(axis2_phase_holder_t)); + + if(!phase_holder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + phase_holder->phase_list = NULL; + + return 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) +{ + axis2_phase_holder_t *phase_holder = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + if(!phases) + { + return NULL; + } + + phase_holder = (axis2_phase_holder_t *)axis2_phase_holder_create(env); + phase_holder->phase_list = phases; + + return phase_holder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_phase_holder_free( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(phase_holder) + { + AXIS2_FREE(env->allocator, phase_holder); + } + + return; +} + +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) +{ + int size = 0; + int i = 0; + axis2_phase_t *phase = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, phase_name, AXIS2_FALSE); + + size = axutil_array_list_size(phase_holder->phase_list, env); + + for(i = 0; i < size; i++) + { + const axis2_char_t *phase_name_l = NULL; + + phase = (axis2_phase_t *)axutil_array_list_get(phase_holder-> phase_list, env, i); + phase_name_l = axis2_phase_get_name(phase, env); + if(0 == axutil_strcmp(phase_name_l, phase_name)) + { + return AXIS2_TRUE; + } + } + return AXIS2_FALSE; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_holder_add_handler( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env, + axis2_handler_desc_t * handler) +{ + const axis2_char_t *phase_name = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler start"); + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE); + + phase_name = axis2_phase_rule_get_name(axis2_handler_desc_get_rules(handler, env), env); + if(AXIS2_TRUE == axis2_phase_holder_is_phase_exist(phase_holder, env, phase_name)) + { + axis2_phase_t *phase = NULL; + + phase = axis2_phase_holder_get_phase(phase_holder, env, phase_name); + status = axis2_phase_add_handler_desc(phase, env, handler); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Add handler %s to phase %s", + axutil_string_get_buffer(axis2_handler_desc_get_name(handler, env), env), phase_name); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE, AXIS2_FAILURE); + status = AXIS2_FAILURE; + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_add_handler end status = %s", + status ? "SUCCESS" : "FAILURE"); + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_holder_remove_handler( + axis2_phase_holder_t * phase_holder, + const axutil_env_t * env, + axis2_handler_desc_t * handler) +{ + const axis2_char_t *phase_name = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_remove_handler start"); + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, handler, AXIS2_FAILURE); + + phase_name = axis2_phase_rule_get_name(axis2_handler_desc_get_rules(handler, env), env); + if(AXIS2_TRUE == axis2_phase_holder_is_phase_exist(phase_holder, env, phase_name)) + { + axis2_phase_t *phase = NULL; + + phase = axis2_phase_holder_get_phase(phase_holder, env, phase_name); + status = axis2_phase_remove_handler_desc(phase, env, handler); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Remove handler %s from phase %s", + axutil_string_get_buffer(axis2_handler_desc_get_name(handler, env), env), phase_name); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_PHASE, AXIS2_FAILURE); + status = AXIS2_FAILURE; + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "axis2_phase_holder_remove_handler end status = %s", + status ? "SUCCESS" : "FAILURE"); + return status; +} + +AXIS2_EXTERN axis2_phase_t *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) +{ + int size = 0; + int i = 0; + axis2_phase_t *phase = NULL; + + AXIS2_PARAM_CHECK(env->error, phase_name, NULL); + + size = axutil_array_list_size(phase_holder->phase_list, env); + + for(i = 0; i < size; i++) + { + const axis2_char_t *phase_name_l = NULL; + phase = (axis2_phase_t *)axutil_array_list_get(phase_holder-> phase_list, env, i); + phase_name_l = axis2_phase_get_name(phase, env); + if(0 == axutil_strcmp(phase_name_l, phase_name)) + { + return phase; + } + } + + return NULL; +} + +/* This function is deprecated */ +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, + axis2_phase_t * phase, + axutil_array_list_t * handlers) +{ + axis2_handler_t *handler = NULL; + int size = 0; + int status = AXIS2_FAILURE; + int i = 0; + axis2_handler_desc_t *handler_desc = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phase, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, handlers, AXIS2_FAILURE); + + size = axutil_array_list_size(handlers, env); + + for(i = 0; i < size; i++) + { + handler_desc = (axis2_handler_desc_t *)axutil_array_list_get(handlers, env, i); + status = axis2_handler_init(handler, env, handler_desc); + if(AXIS2_FAILURE == status) + { + return status; + } + + status = axis2_handler_desc_set_handler(handler_desc, env, handler); + if(AXIS2_FAILURE == status) + { + return status; + } + + status = axis2_phase_add_handler(phase, env, handler); + } + return status; +} diff --git a/src/core/phaseresolver/phase_resolver.c b/src/core/phaseresolver/phase_resolver.c new file mode 100644 index 0000000..c291456 --- /dev/null +++ b/src/core/phaseresolver/phase_resolver.c @@ -0,0 +1,2016 @@ +/* + * 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. + */ + +#include +#include +#include +/* + * It is important to understand the following relationships between the + * functions defined here and else where. + * axis2_phase_resolver_engage_module_globally->axis2_svc_add_module_ops-> + * ->axis2_phase_resolver_build_execution_chains_for_module_op->axis2_phase_resolver_build_execution_chains_for_op + * and + * axis2_phase_resolver_engage_module_to_svc->axis2_svc_add_module_ops-> + * ->axis2_phase_resolver_build_execution_chains_for_module_op->axis2_phase_resolver_build_execution_chains_for_op + */ +struct axis2_phase_resolver +{ + + /** axis2 configuration */ + axis2_conf_t *axis2_config; + + /** service */ + axis2_svc_t *svc; +}; + +static axis2_status_t +axis2_phase_resolver_build_execution_chains_for_op( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + int type, + axis2_op_t * op); + +static axis2_status_t +axis2_phase_resolver_add_module_handlers_to_system_defined_phases( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_module_desc_t * module_desc); + +static axis2_status_t +axis2_phase_resolver_add_module_handlers_to_user_defined_phases( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + struct axis2_svc *svc, + struct axis2_module_desc *module_desc); + +/* Deprecated and no longer used */ +static axis2_status_t +axis2_phase_resolver_build_in_transport_chains( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_transport_in_desc_t * transport); + +/* Deprecated and no longer used */ +static axis2_status_t +axis2_phase_resolver_build_out_transport_chains( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_transport_out_desc_t * transport); + +static axis2_status_t +axis2_phase_resolver_add_to_handler_list( + const axutil_env_t * env, + axutil_array_list_t *handler_list, + axis2_op_t *op, + axis2_module_desc_t * module_desc, + int type); + +AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL +axis2_phase_resolver_create( + const axutil_env_t * env) +{ + axis2_phase_resolver_t *phase_resolver = NULL; + + phase_resolver = (axis2_phase_resolver_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_phase_resolver_t)); + + if(!phase_resolver) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory."); + return NULL; + } + + phase_resolver->axis2_config = NULL; + phase_resolver->svc = NULL; + + return phase_resolver; +} + +AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL +axis2_phase_resolver_create_with_config( + const axutil_env_t * env, + axis2_conf_t * axis2_config) +{ + axis2_phase_resolver_t *phase_resolver = NULL; + + AXIS2_PARAM_CHECK(env->error, axis2_config, NULL); + + phase_resolver = (axis2_phase_resolver_t *)axis2_phase_resolver_create(env); + + phase_resolver->axis2_config = axis2_config; + + return phase_resolver; +} + +AXIS2_EXTERN axis2_phase_resolver_t *AXIS2_CALL +axis2_phase_resolver_create_with_config_and_svc( + const axutil_env_t * env, + axis2_conf_t * axis2_config, + axis2_svc_t * svc) +{ + axis2_phase_resolver_t *phase_resolver = NULL; + + AXIS2_PARAM_CHECK(env->error, axis2_config, NULL); + + phase_resolver = (axis2_phase_resolver_t *)axis2_phase_resolver_create(env); + + if(!phase_resolver) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No Memory."); + return NULL; + } + phase_resolver->axis2_config = axis2_config; + + phase_resolver->svc = svc; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name is : %s", axis2_svc_get_name( + phase_resolver->svc, env)); + + return phase_resolver; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_phase_resolver_free( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env) +{ + if(phase_resolver) + { + AXIS2_FREE(env->allocator, phase_resolver); + } + + return; +} + +/** + * This is in general called to engage a module to the axis2 engine. In other words modules handlers + * are added into all global and operation specific phases appropriately. Where these handlers + * should go is determined by the module handler specific descriptions in module.xml file. Also + * module operations are added to service and built exeuction chains for those operations as well. + * First add all the handlers defined for system phases are added into system phases. Then module + * operations are added into each service. At the same time execution chains for these module + * operations are built as well. Then handlers defined for user phases are added into user defined + * pahses. + */ + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_resolver_engage_module_globally( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_module_desc_t * module_desc) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_qname_t *qname_addressing = NULL; + axutil_hash_t *svcs = NULL; + + const axutil_qname_t *mod_qname = NULL; + axis2_char_t *mod_name = NULL; + axutil_hash_t *all_ops = NULL; + axutil_hash_index_t *index_j = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_engage_module_globally"); + + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + + mod_qname = axis2_module_desc_get_qname(module_desc, env); + mod_name = axutil_qname_get_localpart(mod_qname, env); + + /* Add module handlers into global phases */ + status = axis2_phase_resolver_add_module_handlers_to_system_defined_phases(phase_resolver, env, + module_desc); + + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Engaging module %s to global chain failed", + mod_name); + return status; + } + + /* Module is engaged to all the services */ + svcs = axis2_conf_get_all_svcs(phase_resolver->axis2_config, env); + if(!svcs) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "There are no services in the axis2 configuration"); + return AXIS2_FAILURE; + } + + qname_addressing = axutil_qname_create(env, AXIS2_MODULE_ADDRESSING, NULL, NULL); + + for(index_j = axutil_hash_first(svcs, env); index_j; index_j = axutil_hash_next(env, index_j)) + { + axis2_svc_t *svc = NULL; + void *w = NULL; + axis2_svc_grp_t *parent = NULL; + const axis2_char_t *svc_name = NULL; + const axis2_char_t *svc_grp_name = NULL; + + axutil_hash_this(index_j, NULL, NULL, &w); + svc = (axis2_svc_t *)w; + svc_name = axis2_svc_get_name(svc, env); + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "svc name is:%s", svc_name); + + /* Module operations are added to service and built execution chains for operations. */ + status = axis2_svc_add_module_ops(svc, env, module_desc, phase_resolver->axis2_config); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding module operations for module %s to service %s failed", mod_name, svc_name); + axutil_qname_free(qname_addressing, env); + return status; + } + + /* Call this function to add module handlers into service operation phases */ + status = axis2_phase_resolver_add_module_handlers_to_user_defined_phases(phase_resolver, + env, svc, module_desc); + + if(AXIS2_SUCCESS != status) + { + axutil_qname_free(qname_addressing, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Engaging module %s to service %s failed", + mod_name, svc_name); + + return status; + } + + if(axutil_qname_equals(mod_qname, env, qname_addressing)) + { + /* If addressing module then all operations which are not module + * operations with a wsa mapping parameter is added to the + * service's wsa-mapping list*/ + all_ops = axis2_svc_get_all_ops(svc, env); + if(all_ops) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + for(hi = axutil_hash_first(all_ops, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &val); + + if(val) + { + if(!axis2_op_is_from_module((axis2_op_t *)val, env)) + { + axis2_op_t *op_desc = NULL; + axutil_array_list_t *params = NULL; + int j = 0; + int sizej = 0; + + op_desc = (axis2_op_t *)val; + params = axis2_op_get_all_params(op_desc, env); + /* Adding wsa-mapping into service */ + sizej = axutil_array_list_size(params, env); + for(j = 0; j < sizej; j++) + { + axutil_param_t *param = NULL; + axis2_char_t *param_name = NULL; + + param = axutil_array_list_get(params, env, j); + param_name = axutil_param_get_name(param, env); + if(!axutil_strcmp(param_name, AXIS2_WSA_MAPPING)) + { + axis2_char_t *key = NULL; + key = (axis2_char_t *)axutil_param_get_value(param, env); + axis2_svc_add_mapping(svc, env, key, op_desc); + } + } + } + val = NULL; + } + } + } + } + + parent = axis2_svc_get_parent(svc, env); + if(parent) + { + axutil_array_list_t *modules = NULL; + int j = 0; + int sizej = 0; + axis2_bool_t add_to_group = AXIS2_TRUE; + svc_grp_name = axis2_svc_grp_get_name(parent, env); + + modules = axis2_svc_grp_get_all_module_qnames(parent, env); + sizej = axutil_array_list_size(modules, env); + for(j = 0; j < sizej; j++) + { + axutil_qname_t *module = NULL; + + module = (axutil_qname_t *)axutil_array_list_get(modules, env, j); + if(axutil_qname_equals(mod_qname, env, module)) + { + add_to_group = AXIS2_FALSE; + break; + } + } + + if(add_to_group) + { + status = axis2_svc_grp_add_module_qname(parent, env, mod_qname); + } + } + + if(AXIS2_SUCCESS != status) + { + axutil_qname_free(qname_addressing, env); + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding module %s to service group %s failed", + mod_name, svc_grp_name); + + return status; + } + } + + axutil_qname_free(qname_addressing, env); + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_engage_module_globally"); + + return status; +} + +/** + * This function is called to engage a module to a service specifically. In other words all module + * handlers defined for user phases are added into user defined phases and all module handlers + * defined for system defined phases are added into system defined phases. Note that user defined + * phases are in the flows taken from operation and system defined phases are in the flows taken + * from conf. Where each module handler should go is determined by module handler descriptions in + * module.xml file. + * First we add the operations defined in the module into the service and built execution chains for + * them. Then for all the operations of the service we check whether the module + * already engaged to operation. If not engage it to service operation. Also if the module is newly + * engaged to operation add the module qnname to the engaged module list of the operation. + */ +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, + axis2_svc_t * svc, + axis2_module_desc_t * module_desc) +{ + axutil_hash_t *ops = NULL; + axutil_hash_index_t *index_i = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axutil_qname_t *module_d_qname = NULL; + axis2_char_t *modname_d = NULL; + const axis2_char_t *svcname = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_engage_module_to_svc"); + + module_d_qname = axis2_module_desc_get_qname(module_desc, env); + modname_d = axutil_qname_get_localpart(module_d_qname, env); + svcname = axis2_svc_get_name(svc, env); + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module %s will be engaged to %s", modname_d, svcname); + + ops = axis2_svc_get_all_ops(svc, env); + if(!ops) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service %s has no operation", svcname); + + return AXIS2_FAILURE; + } + + /* Module operations are added to service and built execution chains */ + status = axis2_svc_add_module_ops(svc, env, module_desc, phase_resolver->axis2_config); + + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding module operations from module %s into service %s failed", modname_d, svcname); + + return status; + } + + for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i)) + { + axutil_array_list_t *modules = NULL; + axis2_op_t *op_desc = NULL; + int size = 0; + int j = 0; + void *v = NULL; + axis2_bool_t engaged = AXIS2_FALSE; + axis2_char_t *opname = NULL; + + axutil_hash_this(index_i, NULL, NULL, &v); + op_desc = (axis2_op_t *)v; + + opname = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env); + + modules = axis2_op_get_all_modules(op_desc, env); + if(modules) + { + size = axutil_array_list_size(modules, env); + } + + for(j = 0; j < size; j++) + { + axis2_module_desc_t *module_desc_l = NULL; + const axutil_qname_t *module_d_qname_l = NULL; + + module_desc_l = axutil_array_list_get(modules, env, j); + module_d_qname_l = axis2_module_desc_get_qname(module_desc_l, env); + if(axutil_qname_equals(module_d_qname, env, module_d_qname_l)) + { + engaged = AXIS2_TRUE; + status = AXIS2_SUCCESS; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Module %s already engaged to operation %s of service %s", modname_d, opname, + svcname); + + break; + } + } + + if(!engaged) + { + status = axis2_phase_resolver_engage_module_to_op(phase_resolver, env, op_desc, + module_desc); + + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Engaging module %s to operation %s failed.", modname_d, opname); + + return status; + } + + status = axis2_op_add_to_engaged_module_list(op_desc, env, module_desc); + } + + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_engage_module_to_svc"); + + return status; +} + +/** + * In this function all the handlers in each flow of the module description are added to the phases + * of the operation(user define phases) and phases of the conf(system defined phases). First handlers + * for system defined phases are added. Then handlers for operation specific phases are added. + */ +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, + axis2_op_t * axis_op, + axis2_module_desc_t * module_desc) +{ + int type = 0; + axis2_phase_holder_t *phase_holder = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_engage_module_to_op"); + AXIS2_PARAM_CHECK(env->error, axis_op, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + + for(type = 1; type < 5; type++) + { + axis2_flow_t *flow = NULL; + axis2_char_t *flowname = NULL; + axutil_array_list_t *phases = NULL; + + switch(type) + { + case AXIS2_IN_FLOW: + { + phases = axis2_op_get_in_flow(axis_op, env); + break; + } + case AXIS2_OUT_FLOW: + { + phases = axis2_op_get_out_flow(axis_op, env); + break; + } + case AXIS2_FAULT_IN_FLOW: + { + phases = axis2_op_get_fault_in_flow(axis_op, env); + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + phases = axis2_op_get_fault_out_flow(axis_op, env); + break; + } + } + + if(phases) + { + phase_holder = axis2_phase_holder_create_with_phases(env, phases); + } + + switch(type) + { + case AXIS2_IN_FLOW: + { + flow = axis2_module_desc_get_in_flow(module_desc, env); + flowname = "in flow"; + break; + } + case AXIS2_OUT_FLOW: + { + flow = axis2_module_desc_get_out_flow(module_desc, env); + flowname = "out flow"; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + flow = axis2_module_desc_get_fault_in_flow(module_desc, env); + flowname = "fault in flow"; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + flow = axis2_module_desc_get_fault_out_flow(module_desc, env); + flowname = "fault out flow"; + break; + } + } + + if(flow && phase_holder) + { + int j = 0; + int handler_count = 0; + + handler_count = axis2_flow_get_handler_count(flow, env); + for(j = 0; j < handler_count; j++) + { + /* For all handlers in the flow from the module description */ + axis2_handler_desc_t *metadata = NULL; + const axis2_char_t *phase_name = NULL; + axis2_phase_rule_t *phase_rule = NULL; + const axutil_string_t *handlersname = NULL; + const axis2_char_t *handlername = NULL; + axis2_status_t status = AXIS2_FAILURE; + + metadata = axis2_flow_get_handler(flow, env, j); + handlersname = axis2_handler_desc_get_name(metadata, env); + handlername = axutil_string_get_buffer(handlersname, env); + phase_rule = axis2_handler_desc_get_rules(metadata, env); + phase_name = axis2_phase_rule_get_name(phase_rule, env); + + /* For user/operation specific phases */ + if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp( + AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, + phase_name)) && (axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name))) + { + status = axis2_phase_holder_add_handler(phase_holder, env, metadata); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Handler %s inclusion failed for %s phase within flow %s. Phase might" + "not available in axis2.xml", handlername, phase_name, phase_name, + flowname); + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + axis2_phase_holder_free(phase_holder, env); + return status; + } + + } + + /* For System defined phases */ + if((!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_DISPATCH, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_POST_DISPATCH, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_PRE_DISPATCH, phase_name))) + { + axutil_array_list_t *phase_list = NULL; + axis2_phase_holder_t *phase_holder = NULL; + + phase_list = axis2_conf_get_in_phases_upto_and_including_post_dispatch( + phase_resolver->axis2_config, env); + + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + phase_holder = NULL; + } + + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + + status = axis2_phase_holder_add_handler(phase_holder, env, metadata); + axis2_phase_holder_free(phase_holder, env); + phase_holder = NULL; + + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding handler %s to phase %s within flow %s failed", handlername, + phase_name, flowname); + + return status; + } + } + } + } + + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + phase_holder = NULL; + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_engage_module_to_op"); + + return AXIS2_SUCCESS; +} + +/** + * The caller function first set the service into the phase resolver. Then call this function to + * build execution chains for that services operations. Within this function it just call + * axis2_phase_resolver_build_execution_chains_for_op() function to build exection chains for + * each operation. + */ +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) +{ + axutil_hash_index_t *index_i = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_op_t *op = NULL; + axutil_hash_t *ops = NULL; + + if(!(phase_resolver->svc)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No service set to phase resolver"); + return AXIS2_FAILURE; + } + + ops = axis2_svc_get_all_ops(phase_resolver->svc, env); + + for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i)) + { + void *v = NULL; + int j = 0; + + axutil_hash_this(index_i, NULL, NULL, &v); + op = (axis2_op_t *)v; + for(j = 1; j < 5; j++) + { + status = axis2_phase_resolver_build_execution_chains_for_op(phase_resolver, env, j, op); + } + } + + return status; +} + +/** + * For operation passed as parameter, build execution chains. To do this get all engaged modules + * from the axis2 configuration and for each module get the all handlers to be add to the operation + * specific phases. Then for each operation specific phases add those handlers. It should be noted + * that by the time this function is called the module handlers are already added to system specific + * phases. This function is called from axis2_phase_resolver_build_execution_chains_for_svc() + * function and axis2_phase_resolver_build_execution_chains_for_module_op() function. + */ +static axis2_status_t +axis2_phase_resolver_build_execution_chains_for_op( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + int type, + axis2_op_t *op) +{ + axutil_array_list_t *handler_list = NULL; + axutil_array_list_t *moduleqnames = NULL; + int i = 0; + int size = 0; + int status = AXIS2_FAILURE; + axis2_char_t *flowname = NULL; + axis2_phase_holder_t *phase_holder = NULL; + axutil_array_list_t *engaged_module_list_for_parent_svc = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Entry:axis2_phase_resolver_build_execution_chains_for_op"); + + handler_list = axutil_array_list_create(env, 0); + if(!handler_list) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + + /* Engage handlers from axis2.xml and from modules */ + moduleqnames = axis2_conf_get_all_engaged_modules(phase_resolver->axis2_config, env); + + size = axutil_array_list_size(moduleqnames, env); + + for(i = 0; i < size; i++) + { + axis2_char_t *modulename = NULL; + axutil_qname_t *moduleqname = NULL; + axis2_module_desc_t *module_desc = NULL; + + moduleqname = (axutil_qname_t *)axutil_array_list_get(moduleqnames, env, i); + modulename = axutil_qname_get_localpart(moduleqname, env); + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module name is:%s", modulename); + + module_desc = axis2_conf_get_module(phase_resolver->axis2_config, env, moduleqname); + if(!module_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_REF, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module description not found in axis2 configuration for name %s", modulename); + + if(handler_list) + { + axutil_array_list_free(handler_list, env); + } + + return AXIS2_FAILURE; + } + + status = axis2_phase_resolver_add_to_handler_list(env, handler_list, op, module_desc, type); + if(AXIS2_SUCCESS != status) + { + if(handler_list) + { + axutil_array_list_free(handler_list, env); + } + return AXIS2_FAILURE; + } + + axis2_op_add_to_engaged_module_list(op, env, module_desc); + } + + engaged_module_list_for_parent_svc + = axis2_svc_get_engaged_module_list(phase_resolver->svc, env); + size = axutil_array_list_size(engaged_module_list_for_parent_svc, env); + + for(i = 0; i < size; i++) + { + axis2_char_t *modulename = NULL; + axutil_qname_t *moduleqname = NULL; + axis2_module_desc_t *module_desc = NULL; + + module_desc = axutil_array_list_get(engaged_module_list_for_parent_svc, env, i); + if(!module_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_REF, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module description not found in engaged module list for service %s", + axis2_svc_get_name(phase_resolver->svc, env)); + + if(handler_list) + { + axutil_array_list_free(handler_list, env); + } + + return AXIS2_FAILURE; + } + + moduleqname = (axutil_qname_t *)axis2_module_desc_get_qname(module_desc, env); + modulename = axutil_qname_get_localpart(moduleqname, env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module name is:%s", modulename); + + status = axis2_phase_resolver_add_to_handler_list(env, handler_list, op, module_desc, type); + if(AXIS2_SUCCESS != status) + { + if(handler_list) + { + axutil_array_list_free(handler_list, env); + } + return AXIS2_FAILURE; + } + + axis2_op_add_to_engaged_module_list(op, env, module_desc); + } + + if(0 == axutil_array_list_size(handler_list, env)) + { + /* No flows configured */ + if(handler_list) + { + axutil_array_list_free(handler_list, env); + } + + return AXIS2_SUCCESS; + } + + switch(type) + { + case AXIS2_IN_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_in_flow(op, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + flowname = "in flow"; + break; + } + case AXIS2_OUT_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_out_flow(op, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + flowname = "out flow"; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_fault_in_flow(op, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + flowname = "fault in flow"; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_fault_out_flow(op, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + flowname = "fault out flow"; + break; + } + } + + size = axutil_array_list_size(handler_list, env); + for(i = 0; i < size; i++) + { + axis2_handler_desc_t *metadata = NULL; + + metadata = (axis2_handler_desc_t *)axutil_array_list_get(handler_list, env, i); + if(phase_holder) + { + status = axis2_phase_holder_add_handler(phase_holder, env, metadata); + if(!status) + { + break; + } + } + } + + /* Free the locally created handler_list*/ + if(handler_list) + { + axutil_array_list_free(handler_list, env); + } + + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Exit:axis2_phase_resolver_build_execution_chains_for_op"); + + return status; +} + +/** + * For module operation build execution chains. This is called by axis2_svc_add_module_ops() function. + */ +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, + axis2_op_t * op) +{ + int i = 0; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Entry:axis2_phase_resolver_build_execution_chains_for_module_op"); + AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE); + + for(i = 1; i < 5; i++) + { + status = axis2_phase_resolver_build_execution_chains_for_op(phase_resolver, env, i, op); + if(!status) + { + break; + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Exit:axis2_phase_resolver_build_execution_chains_for_module_op"); + return status; +} + +/** + * Take the phases for each flow from the axis2 configuration, take all the handlers of each flow + * from the module description and then each handler is added into the corresponding global phase. + * This function is called from function axis2_phase_resolver_engage_module_globally() to add + * module handlers into global phases. + */ +static axis2_status_t +axis2_phase_resolver_add_module_handlers_to_system_defined_phases( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_module_desc_t * module_desc) +{ + int type = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_phase_holder_t *phase_holder = NULL; + const axutil_qname_t *modqname = NULL; + axis2_char_t *modname = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Entry:axis2_phase_resolver_add_module_handlers_to_system_defined_phases"); + + modqname = axis2_module_desc_get_qname(module_desc, env); + modname = axutil_qname_get_localpart(modqname, env); + for(type = 1; type < 5; type++) + { + axis2_flow_t *flow = NULL; + axis2_char_t *flow_name = NULL; + + switch(type) + { + case AXIS2_IN_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_conf_get_in_phases_upto_and_including_post_dispatch( + phase_resolver->axis2_config, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + if(!phase_holder) + continue; + break; + } + case AXIS2_OUT_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_conf_get_out_flow(phase_resolver->axis2_config, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + if(!phase_holder) + continue; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_conf_get_in_fault_flow(phase_resolver-> axis2_config, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + if(!phase_holder) + continue; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_conf_get_out_fault_flow(phase_resolver-> axis2_config, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + if(!phase_holder) + continue; + break; + } + } + + /* Modules referred by axis2.xml */ + switch(type) + { + case AXIS2_IN_FLOW: + { + flow = axis2_module_desc_get_in_flow(module_desc, env); + flow_name = "in flow"; + break; + } + case AXIS2_OUT_FLOW: + { + flow = axis2_module_desc_get_out_flow(module_desc, env); + flow_name = "out flow"; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + flow = axis2_module_desc_get_fault_in_flow(module_desc, env); + flow_name = "fault in flow"; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + flow = axis2_module_desc_get_fault_out_flow(module_desc, env); + flow_name = "fault out flow"; + break; + } + } + if(flow) + { + int j = 0; + for(j = 0; j < axis2_flow_get_handler_count(flow, env); j++) + { + axis2_handler_desc_t *metadata = NULL; + const axis2_char_t *phase_name = NULL; + axis2_phase_rule_t *phase_rule = NULL; + const axutil_string_t *handlersname = NULL; + const axis2_char_t *handlername = NULL; + + metadata = axis2_flow_get_handler(flow, env, j); + handlersname = axis2_handler_desc_get_name(metadata, env); + handlername = axutil_string_get_buffer(handlersname, env); + phase_rule = axis2_handler_desc_get_rules(metadata, env); + if(phase_rule) + { + phase_name = axis2_phase_rule_get_name(phase_rule, env); + } + if(!phase_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Phase rules for handler %s has no name", handlername); + return AXIS2_FAILURE; + } + if((!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_DISPATCH, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_POST_DISPATCH, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_PRE_DISPATCH, phase_name))) + { + /* If a global phase add the module handler*/ + status = axis2_phase_holder_add_handler(phase_holder, env, metadata); + if(!status) + { + axis2_phase_holder_free(phase_holder, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding handler %s of module %s to phase %s of " + "flow %s failed", handlername, modname, phase_name, flow_name); + return status; + } + } + } + } + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Exit:axis2_phase_resolver_add_module_handlers_to_system_defined_phases"); + return AXIS2_SUCCESS; +} + +/** + * For each operation of the service first check whether module is already engaged to operation. + * If not take each operations flows and add the module handlers into them appropriately. This + * function is called from function axis2_phase_resolver_engage_module_globally() to add handlers + * from module into each services all operations. + */ +static axis2_status_t +axis2_phase_resolver_add_module_handlers_to_user_defined_phases( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_svc_t * svc, + axis2_module_desc_t * module_desc) +{ + axutil_hash_t *ops = NULL; + axis2_bool_t engaged = AXIS2_FALSE; + axutil_hash_index_t *index_i = NULL; + int type = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_phase_holder_t *phase_holder = NULL; + const axis2_char_t *svc_name = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Entry:axis2_phase_resolver_add_module_handlers_to_user_defined_phases"); + + AXIS2_PARAM_CHECK(env->error, svc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + svc_name = axis2_svc_get_name(svc, env); + ops = axis2_svc_get_all_ops(svc, env); + if(!ops) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No operations for the service %s", svc_name); + return AXIS2_FAILURE; + } + + for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i)) + { + void *v = NULL; + axis2_op_t *op_desc = NULL; + int j = 0; + axutil_array_list_t *modules = NULL; + axis2_flow_t *flow = NULL; + axis2_char_t *flowname = NULL; + const axutil_qname_t *module_desc_qname = NULL; + axis2_char_t *module_desc_name = NULL; + int size = 0; + axis2_char_t *op_name = NULL; + + axutil_hash_this(index_i, NULL, NULL, &v); + op_desc = (axis2_op_t *)v; + op_name = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Operation name is : %s", op_name); + + /* Get all modules engaged to the operation */ + modules = axis2_op_get_all_modules(op_desc, env); + module_desc_qname = axis2_module_desc_get_qname(module_desc, env); + module_desc_name = axutil_qname_get_localpart(module_desc_qname, env); + if(modules) + { + size = axutil_array_list_size(modules, env); + } + + /* Checking whether module is already engaged to operation */ + for(j = 0; j < size; j++) + { + axis2_module_desc_t *module_desc_l = NULL; + const axutil_qname_t *module_desc_qname_l = NULL; + + module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(modules, env, j); + + module_desc_qname_l = axis2_module_desc_get_qname(module_desc_l, env); + if(axutil_qname_equals(module_desc_qname_l, env, module_desc_qname)) + { + engaged = AXIS2_TRUE; + break; + } + } + + if(engaged) + { + continue; + } + + for(type = 1; type < 5; type++) + { + switch(type) + { + case AXIS2_IN_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_in_flow(op_desc, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + break; + } + case AXIS2_OUT_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_out_flow(op_desc, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + break; + } + case AXIS2_FAULT_IN_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_fault_in_flow(op_desc, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + axutil_array_list_t *phase_list = NULL; + + phase_list = axis2_op_get_fault_out_flow(op_desc, env); + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + break; + } + } + + /* Process modules referred by axis2.xml */ + + switch(type) + { + case AXIS2_IN_FLOW: + { + flow = axis2_module_desc_get_in_flow(module_desc, env); + flowname = "in flow"; + break; + } + case AXIS2_OUT_FLOW: + { + flow = axis2_module_desc_get_out_flow(module_desc, env); + flowname = "out flow"; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + flow = axis2_module_desc_get_fault_in_flow(module_desc, env); + flowname = "fault in flow"; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + flow = axis2_module_desc_get_fault_out_flow(module_desc, env); + flowname = "fault out flow"; + break; + } + } + + if(flow) + { + int handler_count = 0; + + handler_count = axis2_flow_get_handler_count(flow, env); + for(j = 0; j < handler_count; j++) + { + axis2_handler_desc_t *metadata = NULL; + const axis2_char_t *phase_name = NULL; + axis2_phase_rule_t *phase_rule = NULL; + const axutil_string_t *handlersname = NULL; + const axis2_char_t *handlername = NULL; + + metadata = axis2_flow_get_handler(flow, env, j); + handlersname = axis2_handler_desc_get_name(metadata, env); + handlername = axutil_string_get_buffer(handlersname, env); + phase_rule = axis2_handler_desc_get_rules(metadata, env); + if(phase_rule) + { + phase_name = axis2_phase_rule_get_name(phase_rule, env); + } + if(!phase_name) + { + AXIS2_LOG_ERROR( + env->log, + AXIS2_LOG_SI, + "Handler rules for the handler description %s within flow %s has no name", + handlername, flowname); + + return AXIS2_FAILURE; + } + + /* If phase is not a system defined phase, add module handler to it */ + if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp( + AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp( + AXIS2_PHASE_POST_DISPATCH, phase_name)) && (axutil_strcmp( + AXIS2_PHASE_PRE_DISPATCH, phase_name))) + { + if(phase_holder) + { + status = axis2_phase_holder_add_handler(phase_holder, env, metadata); + if(!status) + { + axis2_phase_holder_free(phase_holder, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding handler desc %s to" + "phase %s within flow %s failed", handlername, phase_name, + flowname); + + return status; + } + } + } + } + } + + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + } + } + status = axis2_op_add_to_engaged_module_list(op_desc, env, module_desc); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding module description %s to engaged " + "module list of operation %s failed", module_desc_name, op_name); + + return status; + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "Exit:axis2_phase_resolver_add_module_handlers_to_user_defined_phases"); + + return AXIS2_SUCCESS; +} + +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, + axis2_svc_t * svc, + axis2_module_desc_t * module_desc) +{ + axutil_hash_t *ops = NULL; + axutil_hash_index_t *index_i = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axutil_qname_t *module_d_qname = NULL; + const axis2_char_t *svc_name = axis2_svc_get_name(svc, env); + axis2_char_t *modname_d = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_disengage_module_from_svc"); + + ops = axis2_svc_get_all_ops(svc, env); + if(!ops) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service %s has no operation", svc_name); + return AXIS2_FAILURE; + } + + module_d_qname = axis2_module_desc_get_qname(module_desc, env); + modname_d = axutil_qname_get_localpart(module_d_qname, env); + for(index_i = axutil_hash_first(ops, env); index_i; index_i = axutil_hash_next(env, index_i)) + { + axutil_array_list_t *modules = NULL; + axis2_op_t *op_desc = NULL; + int size = 0; + int j = 0; + void *v = NULL; + axis2_bool_t engaged = AXIS2_FALSE; + const axutil_qname_t *opqname = NULL; + axis2_char_t *opname = NULL; + + axutil_hash_this(index_i, NULL, NULL, &v); + op_desc = (axis2_op_t *)v; + opqname = axis2_op_get_qname(op_desc, env); + opname = axutil_qname_get_localpart(opqname, env); + modules = axis2_op_get_all_modules(op_desc, env); + if(modules) + { + size = axutil_array_list_size(modules, env); + } + for(j = 0; j < size; j++) + { + axis2_module_desc_t *module_desc_l = NULL; + const axutil_qname_t *module_d_qname_l = NULL; + + module_desc_l = axutil_array_list_get(modules, env, j); + module_d_qname_l = axis2_module_desc_get_qname(module_desc_l, env); + if(axutil_qname_equals(module_d_qname, env, module_d_qname_l)) + { + engaged = AXIS2_TRUE; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module %s already engaged.", modname_d); + break; + } + } + + if(engaged) + { + status = axis2_phase_resolver_disengage_module_from_op(phase_resolver, env, op_desc, + module_desc); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Disengaging module %s from operation %s failed", modname_d, opname); + return status; + } + + status = axis2_op_remove_from_engaged_module_list(op_desc, env, module_desc); + } + + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_disengage_module_from_svc"); + return status; +} + +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, + axis2_op_t * axis_op, + axis2_module_desc_t * module_desc) +{ + int type = 0; + axis2_phase_holder_t *phase_holder = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_disengage_module_from_op"); + AXIS2_PARAM_CHECK(env->error, axis_op, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + + for(type = 1; type < 5; type++) + { + axis2_flow_t *flow = NULL; + axis2_char_t *flowname = NULL; + axutil_array_list_t *phases = NULL; + + switch(type) + { + case AXIS2_IN_FLOW: + { + phases = axis2_op_get_in_flow(axis_op, env); + break; + } + case AXIS2_OUT_FLOW: + { + phases = axis2_op_get_out_flow(axis_op, env); + break; + } + case AXIS2_FAULT_IN_FLOW: + { + phases = axis2_op_get_fault_in_flow(axis_op, env); + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + phases = axis2_op_get_fault_out_flow(axis_op, env); + break; + } + } + + if(phases) + { + phase_holder = axis2_phase_holder_create_with_phases(env, phases); + } + + switch(type) + { + case AXIS2_IN_FLOW: + { + flow = axis2_module_desc_get_in_flow(module_desc, env); + flowname = "in flow"; + break; + } + case AXIS2_OUT_FLOW: + { + flow = axis2_module_desc_get_out_flow(module_desc, env); + flowname = "out flow"; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + flow = axis2_module_desc_get_fault_in_flow(module_desc, env); + flowname = "fault in flow"; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + flow = axis2_module_desc_get_fault_out_flow(module_desc, env); + flowname = "fault out flow"; + break; + } + } + + if(flow && phase_holder) + { + int j = 0; + int handler_count = 0; + + handler_count = axis2_flow_get_handler_count(flow, env); + for(j = 0; j < handler_count; j++) + { + axis2_handler_desc_t *metadata = NULL; + const axis2_char_t *phase_name = NULL; + axis2_phase_rule_t *phase_rule = NULL; + const axutil_string_t *handlersname = NULL; + const axis2_char_t *handlername = NULL; + axis2_status_t status = AXIS2_FAILURE; + + metadata = axis2_flow_get_handler(flow, env, j); + handlersname = axis2_handler_desc_get_name(metadata, env); + handlername = axutil_string_get_buffer(handlersname, env); + phase_rule = axis2_handler_desc_get_rules(metadata, env); + phase_name = axis2_phase_rule_get_name(phase_rule, env); + if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp( + AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, + phase_name)) && (axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name))) + { + status = axis2_phase_holder_remove_handler(phase_holder, env, metadata); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Handler %s Removal failed for %s phase within flow %s", handlername, + phase_name, flowname); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + axis2_phase_holder_free(phase_holder, env); + return status; + } + + } + if((!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_DISPATCH, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_POST_DISPATCH, phase_name)) || (!axutil_strcmp( + AXIS2_PHASE_PRE_DISPATCH, phase_name))) + { + axutil_array_list_t *phase_list = NULL; + axis2_phase_holder_t *phase_holder = NULL; + + phase_list = axis2_conf_get_in_phases_upto_and_including_post_dispatch( + phase_resolver->axis2_config, env); + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + phase_holder = NULL; + } + phase_holder = axis2_phase_holder_create_with_phases(env, phase_list); + + status = axis2_phase_holder_remove_handler(phase_holder, env, metadata); + axis2_phase_holder_free(phase_holder, env); + phase_holder = NULL; + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Removing handler %s from phase %s within flow %s failed", handlername, + phase_name, flowname); + return status; + } + } + } + } + + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + phase_holder = NULL; + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_disengage_module_from_op"); + return AXIS2_SUCCESS; +} + +/* This function is deprecated and no longer used */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phase_resolver_build_transport_chains( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env) +{ + axis2_transport_in_desc_t **transports_in = NULL; + axis2_transport_out_desc_t **transports_out = NULL; + int index_i = 0; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_build_transport_chains"); + + transports_in = axis2_conf_get_all_in_transports(phase_resolver->axis2_config, env); + if(!transports_in) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_TRANSPORT_IN_CONFIGURED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No transport in descriptions configured"); + return AXIS2_SUCCESS; + } + + transports_out = axis2_conf_get_all_out_transports(phase_resolver->axis2_config, env); + if(!transports_out) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_TRANSPORT_OUT_CONFIGURED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No transport out descriptions configured"); + return AXIS2_SUCCESS; + } + + for(index_i = 0; index_i < AXIS2_TRANSPORT_ENUM_MAX; index_i++) + { + if(transports_in[index_i]) + { + status = axis2_phase_resolver_build_in_transport_chains(phase_resolver, env, + transports_in[index_i]); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Building transport in chains failed"); + return status; + } + } + } + + for(index_i = 0; index_i < AXIS2_TRANSPORT_ENUM_MAX; index_i++) + { + if(transports_out[index_i]) + { + status = axis2_phase_resolver_build_out_transport_chains(phase_resolver, env, + transports_out[index_i]); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Building transport out chains failed"); + return status; + } + } + } + + /* If transport in or transport out maps are not null but still they don't + * have chains configured then we return success, because there are no + * chains to process. + */ + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_build_transport_chains"); + return AXIS2_SUCCESS; +} + +/** + * This function is called from function + * axis2_phase_resolver_build_transport_chains(). + * This function is deprecated and no longer used. + */ +static axis2_status_t +axis2_phase_resolver_build_in_transport_chains( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_transport_in_desc_t * transport) +{ + int type = 0; + int j = 0; + axis2_status_t status = AXIS2_FAILURE; + axutil_array_list_t *handlers = NULL; + AXIS2_TRANSPORT_ENUMS transport_enum = axis2_transport_in_desc_get_enum(transport, env); + ; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_build_in_transport_chains"); + AXIS2_PARAM_CHECK(env->error, transport, AXIS2_FAILURE); + + for(type = 1; type < 4; type++) + { + axis2_flow_t *flow = NULL; + axis2_char_t *flowname = NULL; + axis2_phase_t *phase = NULL; + + switch(type) + { + case AXIS2_IN_FLOW: + { + flow = axis2_transport_in_desc_get_in_flow(transport, env); + phase = axis2_transport_in_desc_get_in_phase(transport, env); + flowname = "in flow"; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + flow = axis2_transport_in_desc_get_fault_in_flow(transport, env); + phase = axis2_transport_in_desc_get_fault_phase(transport, env); + flowname = "fault in flow"; + break; + } + } + if(flow) + { + axis2_phase_holder_t *phase_holder = NULL; + int size = 0; + + size = axis2_flow_get_handler_count(flow, env); + handlers = axutil_array_list_create(env, 0); + for(j = 0; j < size; j++) + { + axis2_handler_desc_t *metadata = NULL; + axis2_phase_rule_t *rule = NULL; + const axis2_char_t *handlername = NULL; + const axutil_string_t *handlersname = NULL; + + metadata = axis2_flow_get_handler(flow, env, j); + handlersname = axis2_handler_desc_get_name(metadata, env); + handlername = axutil_string_get_buffer(handlersname, env); + rule = axis2_handler_desc_get_rules(metadata, env); + if(rule) + { + status = axis2_phase_rule_set_name(rule, env, AXIS2_TRANSPORT_PHASE); + } + if(AXIS2_SUCCESS != status) + { + if(handlers) + { + axis2_handler_desc_t *handler_d = NULL; + int i = 0; + int size = 0; + + size = axutil_array_list_size(handlers, env); + for(i = 0; i < size; i++) + { + handler_d = axutil_array_list_get(handlers, env, i); + axis2_handler_desc_free(handler_d, env); + } + axutil_array_list_free(handlers, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting name %s to phase rules for handler %s failed" + "for in transport %d within flow %s", AXIS2_TRANSPORT_PHASE, + handlername, transport_enum, flowname); + return status; + } + status = axutil_array_list_add(handlers, env, metadata); + if(AXIS2_SUCCESS != status) + { + if(handlers) + { + axis2_handler_desc_t *handler_d = NULL; + int i = 0; + int size = 0; + + size = axutil_array_list_size(handlers, env); + for(i = 0; i < size; i++) + { + handler_d = axutil_array_list_get(handlers, env, i); + axis2_handler_desc_free(handler_d, env); + } + axutil_array_list_free(handlers, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding handler %s from in transport %d to handler " + "list failed within flow %s", handlername, transport_enum, flowname); + return status; + } + } + phase_holder = axis2_phase_holder_create(env); + if(!phase_holder) + { + if(handlers) + { + axis2_handler_desc_t *handler_d = NULL; + int i = 0; + int size = 0; + + size = axutil_array_list_size(handlers, env); + for(i = 0; i < size; i++) + { + handler_d = axutil_array_list_get(handlers, env, i); + axis2_handler_desc_free(handler_d, env); + } + axutil_array_list_free(handlers, env); + } + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + + status = axis2_phase_holder_build_transport_handler_chain(phase_holder, env, phase, + handlers); + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + } + } + else + { + /* Do nothing */ + } + } + if(handlers) + { + axutil_array_list_free(handlers, env); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_build_in_transport_chains"); + return status; +} + +/** + * This function is called from function + * axis2_phase_resolver_build_transport_chains(). + * This is deprecated and no longer used. + */ +static axis2_status_t +axis2_phase_resolver_build_out_transport_chains( + axis2_phase_resolver_t * phase_resolver, + const axutil_env_t * env, + axis2_transport_out_desc_t * transport) +{ + int type = 0; + axis2_status_t status = AXIS2_FAILURE; + axutil_array_list_t *handlers = NULL; + AXIS2_TRANSPORT_ENUMS transport_enum = axis2_transport_out_desc_get_enum(transport, env); + ; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_phase_resolver_build_out_transport_chains"); + AXIS2_PARAM_CHECK(env->error, transport, AXIS2_FAILURE); + for(type = 1; type < 5; type++) + { + axis2_flow_t *flow = NULL; + axis2_char_t *flowname = NULL; + axis2_phase_t *phase = NULL; + + switch(type) + { + case AXIS2_OUT_FLOW: + { + flow = axis2_transport_out_desc_get_out_flow(transport, env); + phase = axis2_transport_out_desc_get_out_phase(transport, env); + flowname = "out flow"; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + flow = axis2_transport_out_desc_get_fault_out_flow(transport, env); + phase = axis2_transport_out_desc_get_fault_phase(transport, env); + flowname = "fault out flow"; + break; + } + } + + if(flow) + { + axis2_phase_holder_t *phase_holder = NULL; + int hndlr_count = 0; + int j = 0; + hndlr_count = axis2_flow_get_handler_count(flow, env); + if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return AXIS2_ERROR_GET_STATUS_CODE(env->error); + } + handlers = axutil_array_list_create(env, 0); + + for(j = 0; j < hndlr_count; j++) + { + axis2_handler_desc_t *metadata = NULL; + axis2_phase_rule_t *rule = NULL; + const axis2_char_t *handlername = NULL; + const axutil_string_t *handlersname = NULL; + + metadata = axis2_flow_get_handler(flow, env, j); + handlersname = axis2_handler_desc_get_name(metadata, env); + handlername = axutil_string_get_buffer(handlersname, env); + + rule = axis2_handler_desc_get_rules(metadata, env); + if(rule) + { + status = axis2_phase_rule_set_name(rule, env, AXIS2_TRANSPORT_PHASE); + } + if(AXIS2_SUCCESS != status) + { + if(handlers) + { + axis2_handler_desc_t *handler_d = NULL; + int i = 0; + int size = 0; + + size = axutil_array_list_size(handlers, env); + for(i = 0; i < size; i++) + { + handler_d = axutil_array_list_get(handlers, env, i); + axis2_handler_desc_free(handler_d, env); + } + axutil_array_list_free(handlers, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting name %s to phase rules for handler %s failed" + "for out transport %d within flow %s", AXIS2_TRANSPORT_PHASE, + handlername, transport_enum, flowname); + return status; + } + + status = axutil_array_list_add(handlers, env, metadata); + if(AXIS2_FAILURE == status) + { + if(handlers) + { + axis2_handler_desc_t *handler_d = NULL; + int i = 0; + int size = 0; + + size = axutil_array_list_size(handlers, env); + for(i = 0; i < size; i++) + { + handler_d = axutil_array_list_get(handlers, env, i); + axis2_handler_desc_free(handler_d, env); + } + axutil_array_list_free(handlers, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding handler %s from out transport %d to handler " + "list failed within flow %s", handlername, transport_enum, flowname); + return status; + } + } + phase_holder = axis2_phase_holder_create(env); + if(!phase_holder) + { + if(handlers) + { + axis2_handler_desc_t *handler_d = NULL; + int i = 0; + int size = 0; + + size = axutil_array_list_size(handlers, env); + for(i = 0; i < size; i++) + { + handler_d = axutil_array_list_get(handlers, env, i); + axis2_handler_desc_free(handler_d, env); + } + axutil_array_list_free(handlers, env); + } + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + + status = axis2_phase_holder_build_transport_handler_chain(phase_holder, env, phase, + handlers); + if(phase_holder) + { + axis2_phase_holder_free(phase_holder, env); + } + } + else + { + /* Do nothing */ + } + } + if(handlers) + { + axutil_array_list_free(handlers, env); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_phase_resolver_build_out_transport_chains"); + return status; +} + +/** + * This function is called from axis2_phase_resolver_build_execution_chains_for_op() function. + */ +static axis2_status_t +axis2_phase_resolver_add_to_handler_list( + const axutil_env_t * env, + axutil_array_list_t *handler_list, + axis2_op_t *op, + axis2_module_desc_t * module_desc, + int type) +{ + axis2_flow_t *flow = NULL; + axis2_char_t *flowname = NULL; + const axutil_qname_t *opqname = NULL; + axis2_char_t *opname = NULL; + axis2_status_t status = AXIS2_FAILURE; + + opqname = axis2_op_get_qname(op, env); + opname = axutil_qname_get_localpart(opqname, env); + + switch(type) + { + case AXIS2_IN_FLOW: + { + flow = axis2_module_desc_get_in_flow(module_desc, env); + flowname = "in flow"; + break; + } + case AXIS2_OUT_FLOW: + { + flow = axis2_module_desc_get_out_flow(module_desc, env); + flowname = "out flow"; + break; + } + case AXIS2_FAULT_IN_FLOW: + { + flow = axis2_module_desc_get_fault_in_flow(module_desc, env); + flowname = "fault in flow"; + break; + } + case AXIS2_FAULT_OUT_FLOW: + { + flow = axis2_module_desc_get_fault_out_flow(module_desc, env); + flowname = "fault out flow"; + break; + } + } + + if(flow) + { + int j = 0; + int count = 0; + + /* Ignore all the errors upto now */ + AXIS2_ERROR_SET_STATUS_CODE(env->error, AXIS2_SUCCESS); + + count = axis2_flow_get_handler_count(flow, env); + /*if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Getting hanlder count for the flow %s failed", + flowname); + + return AXIS2_ERROR_GET_STATUS_CODE(env->error); + }*/ + + for(j = 0; j < count; j++) + { + axis2_handler_desc_t *metadata = NULL; + const axis2_char_t *phase_name = NULL; + axis2_phase_rule_t *phase_rule = NULL; + const axutil_string_t *handlername = NULL; + const axis2_char_t *handlername_buff = NULL; + + metadata = axis2_flow_get_handler(flow, env, j); + handlername = axis2_handler_desc_get_name(metadata, env); + handlername_buff = axutil_string_get_buffer(handlername, env); + phase_rule = axis2_handler_desc_get_rules(metadata, env); + phase_name = axis2_phase_rule_get_name(phase_rule, env); + if(!phase_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Phase rules name null for the handler description %s within flow %s", + handlername_buff, flowname); + + return AXIS2_FAILURE; + } + + /* If user defined phases */ + if((axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name)) && (axutil_strcmp( + AXIS2_PHASE_DISPATCH, phase_name)) && (axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, + phase_name)) && (axutil_strcmp(AXIS2_PHASE_PRE_DISPATCH, phase_name))) + { + status = axutil_array_list_add(handler_list, env, metadata); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding handler description %s failed for phase %s within flow %s", + handlername_buff, phase_name, flowname); + + return status; + } + } + else + { + AXIS2_LOG_DEBUG( + env->log, + AXIS2_LOG_SI, + "Trying to add this handler %s to system pre defined phases , but those " + "handlers are already added to global chain which run irrespective of the service", + handlername_buff); + } + } + } + + return AXIS2_SUCCESS; +} + diff --git a/src/core/receivers/Makefile.am b/src/core/receivers/Makefile.am new file mode 100644 index 0000000..8b12372 --- /dev/null +++ b/src/core/receivers/Makefile.am @@ -0,0 +1,11 @@ +noinst_LTLIBRARIES = libaxis2_receivers.la + +libaxis2_receivers_la_SOURCES = msg_recv.c \ + raw_xml_in_out_msg_recv.c \ + svr_callback.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/util \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/receivers/msg_recv.c b/src/core/receivers/msg_recv.c new file mode 100644 index 0000000..87bcc1d --- /dev/null +++ b/src/core/receivers/msg_recv.c @@ -0,0 +1,560 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_msg_recv +{ + axis2_char_t *scope; + /** + * conf ctx is added to pass for the load_and_init_svc method + */ + axis2_conf_ctx_t *conf_ctx; + + void *derived; + + /** + * 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_status_t + ( + AXIS2_CALL * 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 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_status_t + ( + AXIS2_CALL * receive) + ( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + struct axis2_msg_ctx * in_msg_ctx, + void *callback_recv_param); + + axis2_status_t + ( + AXIS2_CALL *load_and_init_svc) +( axis2_msg_recv_t *msg_recv, +const axutil_env_t *env, +struct axis2_svc *svc); + +}; + +static axis2_status_t AXIS2_CALL +axis2_msg_recv_receive_impl( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + void *callback_recv_param); + +static axis2_status_t AXIS2_CALL +axis2_msg_recv_load_and_init_svc_impl( + axis2_msg_recv_t *msg_recv, + const axutil_env_t *env, + struct axis2_svc *svc) +{ + axutil_param_t *impl_info_param = NULL; + void *impl_class = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + if(!svc) + { + return AXIS2_FAILURE; + } + + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + { + return AXIS2_SUCCESS; + } + /* When we load the DLL we have to make sure that only one thread will load it */ + axutil_thread_mutex_lock(axis2_svc_get_mutex(svc, env)); + /* If more than one thread tries to acquires the lock, first thread loads the DLL. + Others should not load the DLL */ + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + { + axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); + return AXIS2_SUCCESS; + } + impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS); + if(!impl_info_param) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); + return AXIS2_FAILURE; + } + + axutil_allocator_switch_to_global_pool(env->allocator); + + axutil_class_loader_init(env); + + impl_class = axutil_class_loader_create_dll(env, impl_info_param); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "loading the services from msg_recv_load_and_init_svc"); + + if(impl_class) + { + axis2_conf_t *conf = NULL; + conf = axis2_conf_ctx_get_conf(msg_recv->conf_ctx, env); + AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *)impl_class, env); + } + + axis2_svc_set_impl_class(svc, env, impl_class); + + axutil_allocator_switch_to_local_pool(env->allocator); + axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT axis2_msg_recv_t *AXIS2_CALL +axis2_msg_recv_create( + const axutil_env_t * env) +{ + axis2_msg_recv_t *msg_recv = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + msg_recv = (axis2_msg_recv_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_msg_recv_t)); + + if(!msg_recv) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + msg_recv->conf_ctx = NULL; + msg_recv->scope = axutil_strdup(env, "app*"); + msg_recv->derived = NULL; + msg_recv->load_and_init_svc = axis2_msg_recv_load_and_init_svc_impl; + msg_recv->receive = axis2_msg_recv_receive_impl; + return msg_recv; +} + +AXIS2_EXPORT void AXIS2_CALL +axis2_msg_recv_free( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(msg_recv->scope) + { + AXIS2_FREE(env->allocator, msg_recv->scope); + } + + if(msg_recv) + { + AXIS2_FREE(env->allocator, msg_recv); + } + + return; +} + +AXIS2_EXPORT 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) +{ + struct axis2_svc *svc = NULL; + struct axis2_op_ctx *op_ctx = NULL; + struct axis2_svc_ctx *svc_ctx = NULL; + axutil_param_t *impl_info_param = NULL; + void *impl_class = NULL; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + svc = axis2_svc_ctx_get_svc(svc_ctx, env); + if(!svc) + { + return NULL; + } + + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + { + return impl_class; + } + else + { + /* When we load the DLL we have to make sure that only one thread will load it */ + axutil_thread_mutex_lock(axis2_svc_get_mutex(svc, env)); + /* If more than one thread tries to acquires the lock, first thread loads the DLL. + Others should not load the DLL */ + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + { + axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); + return impl_class; + } + impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS); + if(!impl_info_param) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); + return NULL; + } + + axutil_allocator_switch_to_global_pool(env->allocator); + + axutil_class_loader_init(env); + + impl_class = axutil_class_loader_create_dll(env, impl_info_param); + + if(impl_class) + { + AXIS2_SVC_SKELETON_INIT((axis2_svc_skeleton_t *)impl_class, env); + } + + axis2_svc_set_impl_class(svc, env, impl_class); + + axutil_allocator_switch_to_local_pool(env->allocator); + axutil_thread_mutex_unlock(axis2_svc_get_mutex(svc, env)); + return impl_class; + } +} + +/*AXIS2_EXPORT 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) +{ + struct axis2_svc *svc = NULL; + struct axis2_op_ctx *op_ctx = NULL; + struct axis2_svc_ctx *svc_ctx = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + svc = axis2_svc_ctx_get_svc(svc_ctx, env); + if(!svc) + { + return NULL; + } + + return axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx); +}*/ + +AXIS2_EXPORT 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) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, scope, AXIS2_FAILURE); + + if(msg_recv->scope) + { + AXIS2_FREE(env->allocator, msg_recv->scope); + } + msg_recv->scope = axutil_strdup(env, scope); + if(!msg_recv->scope) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT axis2_char_t *AXIS2_CALL +axis2_msg_recv_get_scope( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env) +{ + return msg_recv->scope; +} + +AXIS2_EXPORT 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_svc_t *svc = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axutil_param_t *impl_info_param = NULL; + axutil_param_t *scope_param = NULL; + axis2_char_t *param_value = NULL; + axutil_dll_desc_t *dll_desc = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + svc = axis2_svc_ctx_get_svc(svc_ctx, env); + if(!svc) + { + return AXIS2_FAILURE; + } + + scope_param = axis2_svc_get_param(svc, env, AXIS2_SCOPE); + if(scope_param) + { + param_value = axutil_param_get_value(scope_param, env); + } + if(param_value && (0 == axutil_strcmp(AXIS2_APPLICATION_SCOPE, param_value))) + { + return AXIS2_SUCCESS; + } + + impl_info_param = axis2_svc_get_param(svc, env, AXIS2_SERVICE_CLASS); + if(!impl_info_param) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + dll_desc = axutil_param_get_value(impl_info_param, env); + return axutil_class_loader_delete_dll(env, dll_desc); +} + +static axis2_status_t AXIS2_CALL +axis2_msg_recv_receive_impl( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + void *callback_recv_param) +{ + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_engine_t *engine = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Entry:axis2_msg_recv_receive_impl"); + out_msg_ctx = axis2_core_utils_create_out_msg_ctx(env, msg_ctx); + if(!out_msg_ctx) + { + return AXIS2_FAILURE; + } + op_ctx = axis2_msg_ctx_get_op_ctx(out_msg_ctx, env); + if(!op_ctx) + { + axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); + axis2_msg_ctx_free(out_msg_ctx, env); + return AXIS2_FAILURE; + } + + status = axis2_op_ctx_add_msg_ctx(op_ctx, env, out_msg_ctx); + if(!status) + { + axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); + axis2_msg_ctx_free(out_msg_ctx, env); + return status; + } + status = axis2_op_ctx_add_msg_ctx(op_ctx, env, msg_ctx); + + if(!status) + { + return status; + } + + status = axis2_msg_recv_invoke_business_logic(msg_recv, env, msg_ctx, out_msg_ctx); + if(AXIS2_SUCCESS != status) + { + axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); + axis2_msg_ctx_free(out_msg_ctx, env); + return status; + } + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + conf_ctx = axis2_svc_ctx_get_conf_ctx(svc_ctx, env); + engine = axis2_engine_create(env, conf_ctx); + if(!engine) + { + axis2_msg_ctx_free(out_msg_ctx, env); + return AXIS2_FAILURE; + } + if(axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env)) + { + axiom_soap_envelope_t *soap_envelope = axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env); + if(soap_envelope) + { + axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope, env); + if(body) + { + /* in case of a SOAP fault, we got to return failure so that + transport gets to know that it should send 500 */ + if(axiom_soap_body_has_fault(body, env)) + { + status = AXIS2_FAILURE; + axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, soap_envelope); + axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, NULL); + } + else + { + /* if it is two way and not a fault then send through engine. + if it is one way we do not need to do an engine send */ + status = axis2_engine_send(engine, env, out_msg_ctx); + } + } + } + } + axis2_engine_free(engine, env); + + /* Reset the out message context to avoid double freeing at http worker. For example if this is + * not done here both in and out message context will try to free the transport out stream + * which will result in memory corruption. + */ + if(!axis2_msg_ctx_is_paused(out_msg_ctx, env) && !axis2_msg_ctx_is_keep_alive(out_msg_ctx, env)) + { + axis2_core_utils_reset_out_msg_ctx(env, out_msg_ctx); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Exit:axis2_msg_recv_receive_impl"); + return status; +} + +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) +{ + msg_recv->invoke_business_logic = func; + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT 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) +{ + return msg_recv->invoke_business_logic(msg_recv, env, in_msg_ctx, out_msg_ctx); +} + +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) +{ + msg_recv->derived = derived; + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT void *AXIS2_CALL +axis2_msg_recv_get_derived( + const axis2_msg_recv_t * msg_recv, + const axutil_env_t * env) +{ + return msg_recv->derived; +} + +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) +{ + msg_recv->receive = func; + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT axis2_status_t AXIS2_CALL +axis2_msg_recv_receive( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + void *callback_recv_param) +{ + return msg_recv->receive(msg_recv, env, msg_ctx, callback_recv_param); +} + +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) +{ + msg_recv->load_and_init_svc = func; + return AXIS2_SUCCESS; +} + +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) +{ + if(msg_recv->load_and_init_svc) + { + return msg_recv->load_and_init_svc(msg_recv, env, svc); + } + else + { + /* message receivers without physical service (e.g : programatical service injection) */ + return AXIS2_SUCCESS; + } +} +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) +{ + msg_recv->conf_ctx = conf_ctx; +} + +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) +{ + if(msg_recv) + return msg_recv->conf_ctx; + return NULL; +} diff --git a/src/core/receivers/raw_xml_in_out_msg_recv.c b/src/core/receivers/raw_xml_in_out_msg_recv.c new file mode 100644 index 0000000..4bb2de8 --- /dev/null +++ b/src/core/receivers/raw_xml_in_out_msg_recv.c @@ -0,0 +1,442 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static axis2_status_t AXIS2_CALL +axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_msg_ctx_t * new_msg_ctx); + +AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL +axis2_raw_xml_in_out_msg_recv_create( + const axutil_env_t * env) +{ + axis2_msg_recv_t *msg_recv = NULL; + axis2_status_t status = AXIS2_FAILURE; + + msg_recv = axis2_msg_recv_create(env); + if(!msg_recv) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + status = axis2_msg_recv_set_scope(msg_recv, env, AXIS2_APPLICATION_SCOPE); + if(!status) + { + axis2_msg_recv_free(msg_recv, env); + return NULL; + } + + axis2_msg_recv_set_invoke_business_logic(msg_recv, env, + axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync); + + return msg_recv; +} + +static axis2_status_t AXIS2_CALL +axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync( + axis2_msg_recv_t * msg_recv, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_msg_ctx_t * new_msg_ctx) +{ + axis2_svc_skeleton_t *svc_obj = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_op_t *op_desc = NULL; + const axis2_char_t *style = NULL; + axiom_node_t *om_node = NULL; + axiom_element_t *om_element = NULL; + axis2_char_t *local_name = NULL; + axiom_node_t *result_node = NULL; + axiom_node_t *body_content_node = NULL; + axiom_element_t *body_content_element = NULL; + axiom_soap_envelope_t *default_envelope = NULL; + axiom_soap_body_t *out_body = NULL; + axiom_soap_header_t *out_header = NULL; + axiom_soap_fault_t *soap_fault = NULL; + axiom_node_t *out_node = NULL; + axis2_status_t status = AXIS2_SUCCESS; + axis2_bool_t skel_invoked = AXIS2_FALSE; + const axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; + int soap_version = AXIOM_SOAP12; + axiom_namespace_t *env_ns = NULL; + axiom_node_t *fault_node = NULL; + axiom_soap_fault_detail_t *fault_detail; + axis2_bool_t is_fault = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, new_msg_ctx, AXIS2_FAILURE); + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "[axis2]Entry:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync"); + + /* get the implementation class for the Web Service */ + svc_obj = axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx); + + if(!svc_obj) + { + const axis2_char_t *svc_name = NULL; + axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env); + + if(svc) + { + svc_name = axis2_svc_get_name(svc, env); + } + else + { + svc_name = "unknown"; + } + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Impl object for service '%s' not set in message receiver. %d :: %s", svc_name, + env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); + + status = AXIS2_FAILURE; + } + else + { + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + op_desc = axis2_op_ctx_get_op(op_ctx, env); + + style = axis2_op_get_style(op_desc, env); + if(0 == axutil_strcmp(AXIS2_STYLE_DOC, style)) + { + axiom_soap_envelope_t *envelope = NULL; + axiom_soap_body_t *body = NULL; + + envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + body = axiom_soap_envelope_get_body(envelope, env); + om_node = axiom_soap_body_get_base_node(body, env); + om_element = axiom_node_get_data_element(om_node, env); + om_node = axiom_node_get_first_element(om_node, env); + } + else if(0 == axutil_strcmp(AXIS2_STYLE_RPC, style)) + { + axiom_soap_envelope_t *envelope = NULL; + axiom_soap_body_t *body = NULL; + axiom_node_t *op_node = NULL; + axiom_element_t *op_element = NULL; + + envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + body = axiom_soap_envelope_get_body(envelope, env); + op_node = axiom_soap_body_get_base_node(body, env); + op_element = axiom_node_get_data_element(op_node, env); + if(op_element) + { + local_name = axiom_element_get_localname(op_element, env); + if(local_name) + { + axutil_array_list_t *function_arr = NULL; + int i = 0; + int size = 0; + axis2_bool_t matches = AXIS2_FALSE; + + function_arr = svc_obj->func_array; + if(function_arr) + { + size = axutil_array_list_size(function_arr, env); + } + + for(i = 0; i < size; i++) + { + axis2_char_t *function_name = NULL; + + function_name = (axis2_char_t *)axutil_array_list_get(function_arr, env, i); + if(!axutil_strcmp(function_name, local_name)) + { + matches = AXIS2_TRUE; + + } + } + + if(matches) + { + om_node = axiom_node_get_first_child(op_node, env); + om_element = axiom_node_get_data_element(om_node, env); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE); + status = AXIS2_FAILURE; + } + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE); + status = AXIS2_FAILURE; + } + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE); + status = AXIS2_FAILURE; + } + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE); + status = AXIS2_FAILURE; + } + + if(status == AXIS2_SUCCESS) + { + skel_invoked = AXIS2_TRUE; + result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx); + } + + if(result_node) + { + if(0 == axutil_strcmp(style, AXIS2_STYLE_RPC)) + { + axiom_namespace_t *ns = NULL; + axis2_char_t *res_name = NULL; + + res_name = axutil_stracat(env, local_name, "Response"); + ns = axiom_namespace_create(env, "http://soapenc/", "res"); + if(!ns) + { + status = AXIS2_FAILURE; + } + else + { + body_content_element = axiom_element_create(env, NULL, res_name, ns, + &body_content_node); + axiom_node_add_child(body_content_node, env, result_node); + } + } + else + { + body_content_node = result_node; + } + } + else + { + axis2_char_t *mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op_desc, env); + if(axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) && axutil_strcmp(mep, + AXIS2_MEP_URI_ROBUST_IN_ONLY)) + { + status = AXIS2_ERROR_GET_STATUS_CODE(env->error); + if(status == AXIS2_SUCCESS) + { + axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE); + } + else + { + axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code( + new_msg_ctx, env)); + } + /* The new_msg_ctx is passed to the service. The status code must + * be taken from here and set to the old message context which is + * used by the worker when the request processing fails. + */ + if(svc_obj->ops->on_fault) + { + fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node); + } + is_fault = AXIS2_TRUE; + } + else + { + /* If we have a in only message result node is NULL. We create fault only if + * an error is set + */ + status = AXIS2_ERROR_GET_STATUS_CODE(env->error); + if(status == AXIS2_SUCCESS) + { + axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE); + } + else + { + axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code( + new_msg_ctx, env)); + if(!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY)) + { + /* The new_msg_ctx is passed to the service. The status code must + * be taken from here and set to the old message context which is + * used by the worker when the request processing fails. + */ + if(svc_obj->ops->on_fault) + { + fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node); + } + is_fault = AXIS2_TRUE; + } + } + } + } + } + + if(msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */ + soap_version = AXIOM_SOAP11; + } + + if(axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env)) + { + /* service implementation has set the envelope, + useful when setting a SOAP fault. + No need to further process */ + return AXIS2_SUCCESS; + } + + /* create the soap envelope here */ + env_ns = axiom_namespace_create(env, soap_ns, "soapenv"); + if(!env_ns) + { + return AXIS2_FAILURE; + } + + default_envelope = axiom_soap_envelope_create(env, env_ns); + + if(!default_envelope) + { + return AXIS2_FAILURE; + } + + out_header = axiom_soap_header_create_with_parent(env, default_envelope); + if(!out_header) + { + return AXIS2_FAILURE; + } + + out_body = axiom_soap_body_create_with_parent(env, default_envelope); + if(!out_body) + { + return AXIS2_FAILURE; + } + + out_node = axiom_soap_body_get_base_node(out_body, env); + if(!out_node) + { + return AXIS2_FAILURE; + } + + if(status != AXIS2_SUCCESS || is_fault) + { + /* something went wrong. set a SOAP Fault */ + const axis2_char_t *fault_value_str = "soapenv:Sender"; + const axis2_char_t *fault_reason_str = NULL; + const axis2_char_t *err_msg = NULL; + + if(!skel_invoked) + { + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { +fault_value_str = + AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP11_FAULT_CODE_RECEIVER; + } + else + { + fault_value_str = + AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER; + } + } + + err_msg = AXIS2_ERROR_GET_MESSAGE(env->error); + if (err_msg && axutil_strcmp(err_msg, "")) + { + if(!axutil_strcmp(err_msg, "No Error")) + { + fault_reason_str = "An error has occurred, but could not determine exact details"; + } + else + { + fault_reason_str = err_msg; + } + } + else + { + fault_reason_str = "An error has occurred, but could not determine exact details"; + } + + soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str, + fault_reason_str, soap_version); + + if (fault_node) + { + axiom_node_t *fault_detail_node = NULL; + + fault_detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault); + fault_detail_node = axiom_soap_fault_detail_get_base_node(fault_detail, env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault_detail:%s", axiom_node_to_string( + fault_detail_node, env)); + + axiom_soap_fault_detail_add_detail_entry(fault_detail, env, fault_node); + } +} + +if (body_content_node) +{ + axiom_node_add_child(out_node, env, body_content_node); + status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope); +} +else if (soap_fault) +{ + axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope); + status = AXIS2_SUCCESS; +} +else +{ + /* we should free the memory as the envelope is not used, one way case */ + axiom_soap_envelope_free(default_envelope, env); + default_envelope = NULL; +} + +AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, + "[axis2]Exit:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync"); + +return status; +} + +AXIS2_EXPORT int +axis2_get_instance( + struct axis2_msg_recv **inst, + const axutil_env_t * env) +{ + *inst = axis2_raw_xml_in_out_msg_recv_create(env); + if(!(*inst)) + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT int +axis2_remove_instance( + struct axis2_msg_recv *inst, + const axutil_env_t * env) +{ + if(inst) + { + axis2_msg_recv_free(inst, env); + } + return AXIS2_SUCCESS; +} diff --git a/src/core/receivers/svr_callback.c b/src/core/receivers/svr_callback.c new file mode 100644 index 0000000..2fe68b1 --- /dev/null +++ b/src/core/receivers/svr_callback.c @@ -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. + */ + +#include +#include + +struct axis2_svr_callback +{ + axis2_char_t *scope; +}; + +AXIS2_EXPORT axis2_svr_callback_t *AXIS2_CALL +axis2_svr_callback_create( + const axutil_env_t * env) +{ + axis2_svr_callback_t *svr_callback = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + svr_callback = (axis2_svr_callback_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_svr_callback_t)); + + if(!svr_callback) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return svr_callback; +} + +AXIS2_EXPORT void AXIS2_CALL +axis2_svr_callback_free( + axis2_svr_callback_t * svr_callback, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(svr_callback) + { + AXIS2_FREE(env->allocator, svr_callback); + } + + return; +} + +AXIS2_EXPORT 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) +{ + axis2_engine_t *engine = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_op_ctx_t *op_ctx = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + conf_ctx = axis2_svc_ctx_get_conf_ctx(svc_ctx, env); + engine = axis2_engine_create(env, conf_ctx); + if(!engine) + { + return AXIS2_FAILURE; + } + return axis2_engine_send(engine, env, msg_ctx); +} + +AXIS2_EXPORT 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) +{ + axis2_engine_t *engine = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_msg_ctx_t *fault_ctx = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); + conf_ctx = axis2_svc_ctx_get_conf_ctx(svc_ctx, env); + engine = axis2_engine_create(env, conf_ctx); + if(!engine) + { + return AXIS2_FAILURE; + } + + fault_ctx = axis2_engine_create_fault_msg_ctx(engine, env, msg_ctx, NULL, NULL); + return axis2_engine_send_fault(engine, env, fault_ctx); +} diff --git a/src/core/transport/Makefile.am b/src/core/transport/Makefile.am new file mode 100644 index 0000000..eff5f72 --- /dev/null +++ b/src/core/transport/Makefile.am @@ -0,0 +1,8 @@ +SUBDIRS=http $(TCP_DIR) $(AMQP_DIR) +DIST_SUBDIRS=http tcp amqp +EXTRA_DIST=Makefile.am amqp/server/axis2_amqp_server/axis2_amqp_server.h \ +amqp/receiver/axis2_amqp_receiver.h amqp/receiver/qpid_receiver/axis2_qpid_receiver.h \ +amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.h amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.h \ +amqp/util/axis2_amqp_defines.h amqp/util/axis2_amqp_util.h amqp/sender/qpid_sender/axis2_qpid_sender_interface.h \ +amqp/sender/qpid_sender/axis2_qpid_sender.h amqp/sender/axis2_amqp_sender.h + diff --git a/src/core/transport/amqp/Makefile.am b/src/core/transport/amqp/Makefile.am new file mode 100644 index 0000000..ca5e58d --- /dev/null +++ b/src/core/transport/amqp/Makefile.am @@ -0,0 +1,4 @@ +SUBDIRS = util \ + receiver \ + server \ + sender diff --git a/src/core/transport/amqp/receiver/Makefile.am b/src/core/transport/amqp/receiver/Makefile.am new file mode 100644 index 0000000..4e16b0f --- /dev/null +++ b/src/core/transport/amqp/receiver/Makefile.am @@ -0,0 +1,25 @@ +SUBDIRS = qpid_receiver + +lib_LTLIBRARIES = libaxis2_amqp_receiver.la + +libaxis2_amqp_receiver_la_SOURCES = axis2_amqp_receiver.c + +libaxis2_amqp_receiver_la_LIBADD = $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la \ + $(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver/libaxis2_qpid_receiver.la + +libaxis2_amqp_receiver_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/transport/amqp/receiver \ + -I$(top_builddir)/src/core/transport/amqp/sender/qpid_sender \ + -I$(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include + diff --git a/src/core/transport/amqp/receiver/axis2_amqp_receiver.c b/src/core/transport/amqp/receiver/axis2_amqp_receiver.c new file mode 100644 index 0000000..5ff69af --- /dev/null +++ b/src/core/transport/amqp/receiver/axis2_amqp_receiver.c @@ -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. + */ + +#include +#include +#include + +static const axis2_transport_receiver_ops_t amqp_receiver_ops = +{ + axis2_amqp_receiver_init, + axis2_amqp_receiver_start, + axis2_amqp_receiver_get_reply_to_epr, + axis2_amqp_receiver_get_conf_ctx, + axis2_amqp_receiver_is_running, + axis2_amqp_receiver_stop, + axis2_amqp_receiver_free +}; + +AXIS2_EXTERN axis2_transport_receiver_t* AXIS2_CALL +axis2_amqp_receiver_create( + const axutil_env_t* env, + const axis2_char_t* repo, + const axis2_char_t* qpid_broker_ip, + int qpid_broker_port) +{ + AXIS2_ENV_CHECK(env, NULL); + + axis2_amqp_receiver_resource_pack_t* receiver_resource_pack = NULL; + + receiver_resource_pack = (axis2_amqp_receiver_resource_pack_t*)AXIS2_MALLOC(env->allocator, + sizeof(axis2_amqp_receiver_resource_pack_t)); + + if(!receiver_resource_pack) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + receiver_resource_pack->receiver.ops = &amqp_receiver_ops; + receiver_resource_pack->qpid_receiver = NULL; + receiver_resource_pack->conf_ctx = NULL; + receiver_resource_pack->conf_ctx_private = NULL; + + if(repo) + { + /** + * 1. We first create a private conf ctx which is owned by this server + * we only free this private conf context. We should never free the + * receiver_impl->conf_ctx because it may be owned by any other object which + * may lead to double free. + * + * 2. The Qpid broker IP and port are set in conf_ctx at two different places. + * If the repo is specified, they are set here. Otherwise, they are set + * in axis2_amqp_receiver_init method. + */ + axutil_property_t* property = NULL; + const axis2_char_t* broker_ip = NULL; + int* broker_port = (int*)AXIS2_MALLOC(env->allocator, sizeof(int)); + *broker_port = AXIS2_QPID_NULL_CONF_INT; + + receiver_resource_pack->conf_ctx_private = axis2_build_conf_ctx(env, repo); + if(!receiver_resource_pack->conf_ctx_private) + { + axis2_amqp_receiver_free((axis2_transport_receiver_t *)receiver_resource_pack, env); + return NULL; + } + + /* Set broker IP */ + broker_ip = qpid_broker_ip ? qpid_broker_ip : AXIS2_QPID_DEFAULT_BROKER_IP; + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0, 0, + (void*)broker_ip); + axis2_conf_ctx_set_property(receiver_resource_pack->conf_ctx_private, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_IP, property); + + /* Set broker port */ + *broker_port = (qpid_broker_port != AXIS2_QPID_NULL_CONF_INT) ? qpid_broker_port + : AXIS2_QPID_DEFAULT_BROKER_PORT; + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0, 0, + (void*)broker_port); + axis2_conf_ctx_set_property(receiver_resource_pack->conf_ctx_private, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_PORT, property); + + receiver_resource_pack->conf_ctx = receiver_resource_pack->conf_ctx_private; + } + + return &(receiver_resource_pack->receiver); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_receiver_init( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx, + axis2_transport_in_desc_t* in_desc) +{ + axis2_amqp_receiver_resource_pack_t* receiver_resource_pack = NULL; + axutil_property_t* property = NULL; + const axis2_char_t* broker_ip = NULL; + int* broker_port = (int*)AXIS2_MALLOC(env->allocator, sizeof(int)); + *broker_port = AXIS2_QPID_NULL_CONF_INT; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + receiver_resource_pack = AXIS2_AMQP_RECEIVER_TO_RESOURCE_PACK(receiver); + receiver_resource_pack->conf_ctx = conf_ctx; + + /* Set broker IP */ + broker_ip = axis2_amqp_util_get_in_desc_conf_value_string(in_desc, env, + AXIS2_AMQP_CONF_QPID_BROKER_IP); + if(!broker_ip) + { + broker_ip = AXIS2_QPID_DEFAULT_BROKER_IP; + } + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0, 0, + (void*)broker_ip); + axis2_conf_ctx_set_property(receiver_resource_pack->conf_ctx, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_IP, property); + + /* Set broker port */ + *broker_port = axis2_amqp_util_get_in_desc_conf_value_int(in_desc, env, + AXIS2_AMQP_CONF_QPID_BROKER_PORT); + if(*broker_port == AXIS2_QPID_NULL_CONF_INT) + { + *broker_port = AXIS2_QPID_DEFAULT_BROKER_PORT; + } + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0, 0, + (void*)broker_port); + axis2_conf_ctx_set_property(receiver_resource_pack->conf_ctx, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_PORT, property); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_receiver_start( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + axis2_status_t status = AXIS2_FAILURE; + + axis2_amqp_receiver_resource_pack_t* amqp_receiver_resource_pack = NULL; + axis2_qpid_receiver_resource_pack_t* qpid_receiver_resource_pack = NULL; + + amqp_receiver_resource_pack = AXIS2_AMQP_RECEIVER_TO_RESOURCE_PACK(receiver); + + /* Create Qpid Receiver */ + qpid_receiver_resource_pack = axis2_qpid_receiver_create(env, + amqp_receiver_resource_pack->conf_ctx); + + if(qpid_receiver_resource_pack) + { + amqp_receiver_resource_pack->qpid_receiver = qpid_receiver_resource_pack; + + status = axis2_qpid_receiver_start(qpid_receiver_resource_pack, env); + } + + return status; +} + +AXIS2_EXTERN axis2_endpoint_ref_t* AXIS2_CALL +axis2_amqp_receiver_get_reply_to_epr( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env, + const axis2_char_t* svc_name) +{ + return NULL; +} + +AXIS2_EXTERN axis2_conf_ctx_t* AXIS2_CALL +axis2_amqp_receiver_get_conf_ctx( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, NULL); + + return AXIS2_AMQP_RECEIVER_TO_RESOURCE_PACK(receiver)->conf_ctx; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_amqp_receiver_is_running( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env) +{ + return AXIS2_TRUE; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_receiver_stop( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env) +{ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_receiver_free( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, void); + + axis2_amqp_receiver_resource_pack_t* receiver_resource_pack = NULL; + receiver_resource_pack = AXIS2_AMQP_RECEIVER_TO_RESOURCE_PACK(receiver); + + if(receiver_resource_pack->qpid_receiver) + { + axis2_qpid_receiver_free(receiver_resource_pack->qpid_receiver, env); + receiver_resource_pack->qpid_receiver = NULL; + } + + if(receiver_resource_pack->conf_ctx_private) + { + axis2_conf_ctx_free(receiver_resource_pack->conf_ctx_private, env); + receiver_resource_pack->conf_ctx_private = NULL; + } + + receiver_resource_pack->conf_ctx = NULL; /* Do not free this. It may be owned by some other object */ + + AXIS2_FREE(env->allocator, receiver_resource_pack); +} + +/* Library Exports */ + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_get_instance( +#else + axis2_amqp_receiver_get_instance( +#endif + struct axis2_transport_receiver** inst, + const axutil_env_t* env) +{ + int status = AXIS2_SUCCESS; + + *inst = axis2_amqp_receiver_create(env, NULL, NULL, AXIS2_QPID_NULL_CONF_INT); + if(!(*inst)) + { + status = AXIS2_FAILURE; + } + + return status; +} + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_remove_instance( +#else + axis2_amqp_receiver_remove_instance( +#endif + axis2_transport_receiver_t* inst, + const axutil_env_t* env) +{ + if(inst) + { + axis2_transport_receiver_free(inst, env); + } + + return AXIS2_SUCCESS; +} diff --git a/src/core/transport/amqp/receiver/axis2_amqp_receiver.h b/src/core/transport/amqp/receiver/axis2_amqp_receiver.h new file mode 100644 index 0000000..209e2bb --- /dev/null +++ b/src/core/transport/amqp/receiver/axis2_amqp_receiver.h @@ -0,0 +1,82 @@ +/* +* 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_AMQP_RECEIVER_H +#define AXIS2_AMQP_RECEIVER_H + +#include +#include +#include + +typedef struct axis2_amqp_receiver_resource_pack +{ + axis2_transport_receiver_t receiver; + axis2_qpid_receiver_resource_pack_t* qpid_receiver; + axis2_conf_ctx_t* conf_ctx; + axis2_conf_ctx_t* conf_ctx_private; +} +axis2_amqp_receiver_resource_pack_t; + +#define AXIS2_AMQP_RECEIVER_TO_RESOURCE_PACK(amqp_receiver) \ + ((axis2_amqp_receiver_resource_pack_t*)(amqp_receiver)) + +AXIS2_EXTERN axis2_transport_receiver_t* AXIS2_CALL +axis2_amqp_receiver_create( + const axutil_env_t* env, + const axis2_char_t* repo, + const axis2_char_t* qpid_broker_ip, + int qpid_broker_port); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_receiver_init( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx, + axis2_transport_in_desc_t* in_desc); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_receiver_start( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env); + +AXIS2_EXTERN axis2_endpoint_ref_t* AXIS2_CALL +axis2_amqp_receiver_get_reply_to_epr( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env, + const axis2_char_t* svc_name); + +AXIS2_EXTERN axis2_conf_ctx_t* AXIS2_CALL +axis2_amqp_receiver_get_conf_ctx( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env); + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_amqp_receiver_is_running( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_receiver_stop( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env); + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_receiver_free( + axis2_transport_receiver_t* receiver, + const axutil_env_t* env); + +#endif diff --git a/src/core/transport/amqp/receiver/qpid_receiver/Makefile.am b/src/core/transport/amqp/receiver/qpid_receiver/Makefile.am new file mode 100644 index 0000000..3ecdf34 --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/Makefile.am @@ -0,0 +1,29 @@ +SUBDIRS = request_processor + +lib_LTLIBRARIES = libaxis2_qpid_receiver.la + +libaxis2_qpid_receiver_la_SOURCES = axis2_qpid_receiver.cpp \ + axis2_qpid_receiver_interface.cpp \ + axis2_qpid_receiver_listener.cpp + +libaxis2_qpid_receiver_la_LIBADD = $(top_builddir)/util/src/libaxutil.la \ + $(QPID_HOME)/lib/libqpidclient.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la \ + $(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver/request_processor/libaxis2_amqp_request_processor.la + +libaxis2_qpid_receiver_la_LDFLAGS = g++ -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver \ + -I$(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver/request_processor \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/transport/amqp/sender/qpid_sender \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include \ + -I$(QPID_HOME)/include + diff --git a/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.cpp b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.cpp new file mode 100644 index 0000000..140ab0e --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.cpp @@ -0,0 +1,167 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +Axis2QpidReceiver::Axis2QpidReceiver( + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx) +{ + this->env = env; + this->conf_ctx = conf_ctx; +} + +Axis2QpidReceiver::~Axis2QpidReceiver( + void) +{ +} + +bool +Axis2QpidReceiver::start( + void) +{ + if(!conf_ctx) + return false; + + Connection connection; + axis2_bool_t serverSide = AXIS2_TRUE; + + serverSide = axis2_amqp_util_conf_ctx_get_server_side(conf_ctx, env); + + while(true) + { + try + { + std::list queueNameList; + string qpidBrokerIP = axis2_amqp_util_conf_ctx_get_qpid_broker_ip(conf_ctx, env); + int qpidBrokerPort = axis2_amqp_util_conf_ctx_get_qpid_broker_port(conf_ctx, env); + + /* Check if Client Side and Resolve Dynamic Queue Name */ + if(serverSide == AXIS2_TRUE) /* Server side */ + { + std::cout << "Connecting to Qpid Broker on " << qpidBrokerIP << ":" + << qpidBrokerPort << " ... "; + } + + /* Create Connection to Qpid Broker */ + connection.open(qpidBrokerIP, qpidBrokerPort); + + if(serverSide == AXIS2_TRUE) /* Server side */ + { + /* Create queue for each service. Queue name is equal to service name */ + axis2_conf_t* conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(!conf) + return false; + + axutil_hash_t* serviceMap = axis2_conf_get_all_svcs(conf, env); + if(!serviceMap) + return false; + + axutil_hash_index_t* serviceHI = NULL; + void* serviceValue = NULL; + + for(serviceHI = axutil_hash_first(serviceMap, env); serviceHI; serviceHI + = axutil_hash_next(env, serviceHI)) + { + axutil_hash_this(serviceHI, NULL, NULL, &serviceValue); + + axis2_svc_t* service = (axis2_svc_t*)serviceValue; + if(!service) + return false; + + axis2_char_t* serviceName = axutil_qname_get_localpart(axis2_svc_get_qname( + service, env), env); + if(!serviceName) + return false; + + queueNameList.push_back(serviceName); + } + + std::cout << "CONNECTED" << std::endl; + } + else /* Client side separate listener in dual-channel case */ + { + string queueName = axis2_amqp_util_conf_ctx_get_dual_channel_queue_name(conf_ctx, + env); + + queueNameList.push_back(queueName); + } + + /* Create new session */ + Session session = connection.newSession(); + + /* Create Subscription manager */ + SubscriptionManager subscriptionManager(session); + + Axis2QpidReceiverListener qpidReceiverListener(env, conf_ctx); + + /* Subscribe to queues */ + while(!queueNameList.empty()) + { + string queueName = queueNameList.front(); + + session.queueDeclare(arg::queue = queueName, arg::autoDelete = true); + session.exchangeBind(arg::exchange = AXIS2_AMQP_EXCHANGE_DIRECT, arg::queue + = queueName, arg::bindingKey = queueName); + + subscriptionManager.subscribe(qpidReceiverListener, queueName); + + queueNameList.pop_front(); + } + + /* Listen and Wait */ + if(serverSide == AXIS2_TRUE) /* Server side */ + { + std::cout << "Started Axis2 AMQP Server ..." << std::endl; + } + + subscriptionManager.run(); + + return true; + } + catch(const std::exception& e) + { + connection.close(); + + if(serverSide == AXIS2_TRUE) /* Server side */ + { + std::cout << "FAILED" << std::endl; + } + + sleep(5); + } + } + + connection.close(); + + return false; +} + +bool +Axis2QpidReceiver::shutdown( + void) +{ + return true; +} diff --git a/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.h b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.h new file mode 100644 index 0000000..66108d5 --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver.h @@ -0,0 +1,39 @@ +/* + * 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 + * + * tcp://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_QPID_RECEIVER_H +#define AXIS2_QPID_RECEIVER_H + +#include +#include + +class Axis2QpidReceiver +{ + public: + Axis2QpidReceiver(const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx); + ~Axis2QpidReceiver(void); + + bool start(void); + bool shutdown(void); + + private: + const axutil_env_t* env; + axis2_conf_ctx_t* conf_ctx; +}; + +#endif diff --git a/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.cpp b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.cpp new file mode 100644 index 0000000..79faa86 --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.cpp @@ -0,0 +1,102 @@ +/* +* 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. +*/ + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +AXIS2_EXTERN axis2_qpid_receiver_resource_pack_t* AXIS2_CALL +axis2_qpid_receiver_create( + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx) +{ + AXIS2_ENV_CHECK(env, NULL); + + axis2_qpid_receiver_resource_pack_t* resource_pack = NULL; + + resource_pack = (axis2_qpid_receiver_resource_pack_t*)AXIS2_MALLOC + (env->allocator, sizeof(axis2_qpid_receiver_resource_pack_t)); + + if (!resource_pack) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + /* Create Qpid Receiver */ + Axis2QpidReceiver* qpid_receiver = new Axis2QpidReceiver(env, conf_ctx); + + resource_pack->qpid_receiver = qpid_receiver; + + return resource_pack; +} + + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_qpid_receiver_start( + axis2_qpid_receiver_resource_pack_t* receiver_resource_pack, + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + axis2_status_t status = AXIS2_FAILURE; + + /* Start Qpid Receiver */ + Axis2QpidReceiver* qpid_receiver = (Axis2QpidReceiver*)receiver_resource_pack->qpid_receiver; + + if ((qpid_receiver) && (qpid_receiver->start())) + { + status = AXIS2_SUCCESS; + } + + return status; +} + + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_qpid_receiver_is_running( + axis2_qpid_receiver_resource_pack_t* receiver_resource_pack, + const axutil_env_t* env) +{ + return AXIS2_TRUE; +} + + +AXIS2_EXTERN void AXIS2_CALL +axis2_qpid_receiver_free( + axis2_qpid_receiver_resource_pack_t* receiver_resource_pack, + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, void); + + if (receiver_resource_pack) + { + Axis2QpidReceiver* qpid_receiver = (Axis2QpidReceiver*)receiver_resource_pack->qpid_receiver; + if (qpid_receiver) + delete qpid_receiver; + + AXIS2_FREE(env->allocator, receiver_resource_pack); + } +} + +#ifdef __cplusplus +} +#endif diff --git a/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.h b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.h new file mode 100644 index 0000000..d141dfc --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_interface.h @@ -0,0 +1,58 @@ +/* +* 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_QPID_RECEIVER_INTERFACE_H +#define AXIS2_QPID_RECEIVER_INTERFACE_H + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_qpid_receiver_resource_pack + { + void* qpid_receiver; + }axis2_qpid_receiver_resource_pack_t; + + AXIS2_EXTERN axis2_qpid_receiver_resource_pack_t* AXIS2_CALL + axis2_qpid_receiver_create( + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_qpid_receiver_start( + axis2_qpid_receiver_resource_pack_t* receiver_resource_pack, + const axutil_env_t* env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_qpid_receiver_is_running( + axis2_qpid_receiver_resource_pack_t* receiver_resource_pack, + const axutil_env_t* env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_qpid_receiver_free( + axis2_qpid_receiver_resource_pack_t* receiver_resource_pack, + const axutil_env_t* env); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.cpp b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.cpp new file mode 100644 index 0000000..63717ca --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.cpp @@ -0,0 +1,123 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include + +Axis2QpidReceiverListener::Axis2QpidReceiverListener( + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx) +{ + this->env = env; + this->conf_ctx = conf_ctx; +} + +Axis2QpidReceiverListener::~Axis2QpidReceiverListener( + void) +{ +} + +void +Axis2QpidReceiverListener::received( + Message& message) +{ + AXIS2_ENV_CHECK(env, void); + + axis2_amqp_request_processor_resource_pack_t* request_data = NULL; +#ifdef AXIS2_SVR_MULTI_THREADED + axutil_thread_t* worker_thread = NULL; +#endif + + request_data = (axis2_amqp_request_processor_resource_pack_t*)AXIS2_MALLOC(env->allocator, + sizeof(axis2_amqp_request_processor_resource_pack_t)); + + if(!request_data) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Memory Allocation Error"); + return; + } + + request_data->env = (axutil_env_t*)env; + request_data->conf_ctx = conf_ctx; + + /* Create a Local Copy of Request Content */ + std::string message_data = message.getData(); + axis2_char_t* request_content = + (axis2_char_t*)AXIS2_MALLOC(env->allocator, message_data.size()); + memcpy(request_content, message_data.c_str(), message_data.size()); + + request_data->request_content = request_content; + request_data->content_length = message_data.size(); + + /* Set ReplyTo */ + request_data->reply_to = NULL; + if(message.getMessageProperties().hasReplyTo()) + { + /* Create a Local Copy of ReplyTo */ + std::string reply_to_tmp = message.getMessageProperties().getReplyTo().getRoutingKey(); + axis2_char_t* reply_to = (axis2_char_t*)AXIS2_MALLOC(env->allocator, reply_to_tmp.size() + + 1); + strcpy(reply_to, reply_to_tmp.c_str()); + + request_data->reply_to = reply_to; + } + + /* Copy AMQP headers */ + /* Content-Type */ + request_data->content_type = NULL; + std::string content_type_tmp = message.getHeaders().getAsString(AXIS2_AMQP_HEADER_CONTENT_TYPE); + if(!content_type_tmp.empty()) + { + axis2_char_t* content_type = (axis2_char_t*)AXIS2_MALLOC(env->allocator, + content_type_tmp.size() + 1); + strcpy(content_type, content_type_tmp.c_str()); + + request_data->content_type = content_type; + } + + /* SOAPAction */ + request_data->soap_action = NULL; + std::string soap_action_tmp = message.getHeaders().getAsString(AXIS2_AMQP_HEADER_SOAP_ACTION); + if(!soap_action_tmp.empty()) + { + axis2_char_t* soap_action = (axis2_char_t*)AXIS2_MALLOC(env->allocator, + soap_action_tmp.size() + 1); + strcpy(soap_action, soap_action_tmp.c_str()); + + request_data->soap_action = soap_action; + } + +#ifdef AXIS2_SVR_MULTI_THREADED + worker_thread = axutil_thread_pool_get_thread(env->thread_pool, + axis2_amqp_request_processor_thread_function, + (void*)request_data); + + if (!worker_thread) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create Thread"); + return; + } + + axutil_thread_pool_thread_detach(env->thread_pool, worker_thread); +#else + axis2_amqp_request_processor_thread_function(NULL, (void*)request_data); +#endif +} diff --git a/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.h b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.h new file mode 100644 index 0000000..d5923db --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/axis2_qpid_receiver_listener.h @@ -0,0 +1,43 @@ +/* + * 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 + * + * tcp://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_QPID_RECEIVER_LISTENER_H +#define AXIS2_QPID_RECEIVER_LISTENER_H + +#include +#include +#include +#include + +using namespace qpid::client; +using namespace qpid::framing; + +class Axis2QpidReceiverListener : public MessageListener +{ + public: + Axis2QpidReceiverListener(const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx); + ~Axis2QpidReceiverListener(void); + + private: + virtual void received(Message& message); + + const axutil_env_t* env; + axis2_conf_ctx_t* conf_ctx; +}; + +#endif diff --git a/src/core/transport/amqp/receiver/qpid_receiver/request_processor/Makefile.am b/src/core/transport/amqp/receiver/qpid_receiver/request_processor/Makefile.am new file mode 100644 index 0000000..77cac4a --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/request_processor/Makefile.am @@ -0,0 +1,20 @@ +lib_LTLIBRARIES = libaxis2_amqp_request_processor.la + +libaxis2_amqp_request_processor_la_SOURCES = axis2_amqp_request_processor.c + +libaxis2_amqp_request_processor_la_LIBADD = $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la + +libaxis2_amqp_request_processor_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver/request_processor \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include + diff --git a/src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.c b/src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.c new file mode 100644 index 0000000..0e0c9f8 --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.c @@ -0,0 +1,334 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void* AXIS2_THREAD_FUNC +axis2_amqp_request_processor_thread_function( + axutil_thread_t* thread, + void* request_data) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_env_t* env = NULL; + axutil_env_t* thread_env = NULL; + axis2_amqp_request_processor_resource_pack_t* request_resource_pack = NULL; + +#ifndef WIN32 +#ifdef AXIS2_SVR_MULTI_THREADED + signal(SIGPIPE, SIG_IGN); +#endif +#endif + + request_resource_pack = (axis2_amqp_request_processor_resource_pack_t*)request_data; + + env = request_resource_pack->env; + thread_env = axutil_init_thread_env(env); + + /* Process Request */ + status = axis2_amqp_process_request(thread_env, request_resource_pack); + + if(status == AXIS2_SUCCESS) + { + AXIS2_LOG_INFO(thread_env->log, "Request Processed Successfully"); + } + else + { + AXIS2_LOG_WARNING(thread_env->log, AXIS2_LOG_SI, "Error while Processing Request"); + } + + AXIS2_FREE(thread_env->allocator, request_resource_pack->request_content); + AXIS2_FREE(thread_env->allocator, request_resource_pack->reply_to); + AXIS2_FREE(thread_env->allocator, request_resource_pack->content_type); + AXIS2_FREE(thread_env->allocator, request_resource_pack->soap_action); + + AXIS2_FREE(thread_env->allocator, request_resource_pack); + + if(thread_env) + { + thread_env = NULL; + } + +#ifdef AXIS2_SVR_MULTI_THREADED + axutil_thread_pool_exit_thread(env->thread_pool, thread); +#endif + + return NULL; +} + +axis2_status_t +axis2_amqp_process_request( + const axutil_env_t* env, + axis2_amqp_request_processor_resource_pack_t* request_resource_pack) +{ + axiom_xml_reader_t* xml_reader = NULL; + axiom_stax_builder_t* stax_builder = NULL; + axiom_soap_builder_t* soap_builder = NULL; + axis2_transport_out_desc_t* out_desc = NULL; + axis2_transport_in_desc_t* in_desc = NULL; + axis2_msg_ctx_t* msg_ctx = NULL; + axiom_soap_envelope_t* soap_envelope = NULL; + axis2_engine_t* engine = NULL; + const axis2_char_t* soap_ns_uri = NULL; + axis2_bool_t is_soap_11 = AXIS2_FALSE; + axis2_char_t *soap_body_str = NULL; + int soap_body_len = 0; + axis2_bool_t is_mtom = AXIS2_FALSE; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *binary_data_map = NULL; + axiom_soap_body_t *soap_body = NULL; + axutil_property_t* reply_to_property = NULL; + + /* Create msg_ctx */ + if(!request_resource_pack->conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Conf Context not Available"); + return AXIS2_FAILURE; + } + + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf( + request_resource_pack->conf_ctx, env), env, AXIS2_TRANSPORT_ENUM_AMQP); + if(!out_desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport Out Descriptor not Found"); + return AXIS2_FAILURE; + } + + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(request_resource_pack->conf_ctx, + env), env, AXIS2_TRANSPORT_ENUM_AMQP); + if(!in_desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport In Descriptor not Found"); + return AXIS2_FAILURE; + } + + /* Create msg_ctx */ + msg_ctx = axis2_msg_ctx_create(env, request_resource_pack->conf_ctx, in_desc, out_desc); + + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + /* Handle MTOM */ + if(strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_MULTIPART_RELATED)) + { + axis2_char_t* mime_boundary = axis2_amqp_util_get_value_from_content_type(env, + request_resource_pack->content_type, AXIS2_AMQP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + axiom_mime_parser_t *mime_parser = NULL; + int soap_body_len = 0; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + if(buffer_size_param) + { + value_size = (axis2_char_t*)axutil_param_get_value(buffer_size_param, env); + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + if(max_buffers_param) + { + value_num = (axis2_char_t*)axutil_param_get_value(max_buffers_param, env); + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + + /* If this paramter is there mime_parser will cached the attachment + * using to the directory for large attachments. */ + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + if(attachment_dir_param) + { + value_dir = (axis2_char_t*)axutil_param_get_value(attachment_dir_param, env); + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + if(mime_parser) + { + axis2_callback_info_t *callback_ctx = NULL; + axutil_stream_t *stream = NULL; + + callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + + stream = axutil_stream_create_basic(env); + if(stream) + { + axutil_stream_write(stream, env, request_resource_pack->request_content, + request_resource_pack->content_length); + callback_ctx->env = env; + callback_ctx->in_stream = stream; + callback_ctx->content_length = request_resource_pack->content_length; + callback_ctx->unread_len = request_resource_pack->content_length; + callback_ctx->chunked_stream = NULL; + } + + /*binary_data_map = + axiom_mime_parser_parse(mime_parser, env, + axis2_amqp_util_on_data_request, + (void*)callback_ctx, + mime_boundary);*/ + if(!binary_data_map) + { + return AXIS2_FAILURE; + } + + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + soap_body_len = axiom_mime_parser_get_soap_body_len(mime_parser, env); + + axutil_stream_free(stream, env); + AXIS2_FREE(env->allocator, callback_ctx); + axiom_mime_parser_free(mime_parser, env); + } + + AXIS2_FREE(env->allocator, mime_boundary); + } + + is_mtom = AXIS2_TRUE; + } + else + { + soap_body_str = request_resource_pack->request_content; + soap_body_len = request_resource_pack->content_length; + } + + soap_body_len = axutil_strlen(soap_body_str); + + xml_reader = axiom_xml_reader_create_for_memory(env, soap_body_str, soap_body_len, NULL, + AXIS2_XML_PARSER_TYPE_BUFFER); + if(!xml_reader) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create XML Reader"); + return AXIS2_FAILURE; + } + + stax_builder = axiom_stax_builder_create(env, xml_reader); + if(!stax_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create StAX Builder"); + return AXIS2_FAILURE; + } + + soap_ns_uri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; + + if(request_resource_pack->content_type) + { + if(strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_TEXT_XML)) + { + is_soap_11 = AXIS2_TRUE; + soap_ns_uri = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; + } + /*if (strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_APPL_SOAP)) + { + is_soap_11 = AXIS2_FALSE; + soap_ns_uri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; + } + else if (strstr(request_resource_pack->content_type, AXIS2_AMQP_HEADER_ACCEPT_TEXT_XML)) + { + is_soap_11 = AXIS2_TRUE; + soap_ns_uri = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; + }*/ + } + + soap_builder = axiom_soap_builder_create(env, stax_builder, soap_ns_uri); + if(!soap_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create SOAP Builder"); + return AXIS2_FAILURE; + } + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(!soap_body) + { + return AXIS2_FAILURE; + } + + /* SOAPAction */ + if(request_resource_pack->soap_action) + { + axis2_msg_ctx_set_soap_action(msg_ctx, env, axutil_string_create(env, + request_resource_pack->soap_action)); + } + + /* SOAP version */ + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap_11); + + /* Set ReplyTo in the msg_ctx as a property. This is used by the server when + * 1. WS-A is not in use + * 2. ReplyTo is an anonymous EPR - Sandesha2/Dual-channel */ + reply_to_property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, 0, 0, + (void*)request_resource_pack->reply_to); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_AMQP_MSG_CTX_PROPERTY_REPLY_TO, + reply_to_property); + + engine = axis2_engine_create(env, request_resource_pack->conf_ctx); + + if(AXIS2_TRUE == axiom_soap_body_has_fault(soap_body, env)) + { + status = axis2_engine_receive_fault(engine, env, msg_ctx); + } + else + { + status = axis2_engine_receive(engine, env, msg_ctx); + } + + if(engine) + { + axis2_engine_free(engine, env); + } + + if(soap_body_str && is_mtom) + { + AXIS2_FREE(env->allocator, soap_body_str); + } + + return status; +} diff --git a/src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.h b/src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.h new file mode 100644 index 0000000..97f13b2 --- /dev/null +++ b/src/core/transport/amqp/receiver/qpid_receiver/request_processor/axis2_amqp_request_processor.h @@ -0,0 +1,55 @@ +/* + * 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_AMQP_REQUEST_PROCESSOR_H +#define AXIS2_AMQP_REQUEST_PROCESSOR_H + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_amqp_request_processor_resource_pack + { + axutil_env_t* env; + axis2_conf_ctx_t* conf_ctx; + axis2_char_t* request_content; + int content_length; + axis2_char_t* reply_to; + axis2_char_t* content_type; + axis2_char_t* soap_action; + } axis2_amqp_request_processor_resource_pack_t; + + /* The worker thread function */ + void* AXIS2_THREAD_FUNC + axis2_amqp_request_processor_thread_function( + axutil_thread_t* thread, + void* request_data); + + axis2_status_t + axis2_amqp_process_request( + const axutil_env_t* env, + axis2_amqp_request_processor_resource_pack_t* request_resource_pack); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/core/transport/amqp/sender/Makefile.am b/src/core/transport/amqp/sender/Makefile.am new file mode 100644 index 0000000..8af0c7b --- /dev/null +++ b/src/core/transport/amqp/sender/Makefile.am @@ -0,0 +1,26 @@ +SUBDIRS = qpid_sender + +lib_LTLIBRARIES = libaxis2_amqp_sender.la + +libaxis2_amqp_sender_la_SOURCES = axis2_amqp_sender.c + +libaxis2_amqp_sender_la_LIBADD = $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la \ + $(top_builddir)/src/core/transport/amqp/sender/qpid_sender/libaxis2_qpid_sender.la + +libaxis2_amqp_sender_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/transport/amqp/receiver \ + -I$(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver \ + -I$(top_builddir)/src/core/transport/amqp/sender \ + -I$(top_builddir)/src/core/transport/amqp/sender/qpid_sender \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include + diff --git a/src/core/transport/amqp/sender/axis2_amqp_sender.c b/src/core/transport/amqp/sender/axis2_amqp_sender.c new file mode 100644 index 0000000..aae5496 --- /dev/null +++ b/src/core/transport/amqp/sender/axis2_amqp_sender.c @@ -0,0 +1,344 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +static const axis2_transport_sender_ops_t amqp_sender_ops = +{ + axis2_amqp_sender_init, + axis2_amqp_sender_invoke, + axis2_amqp_sender_clean_up, + axis2_amqp_sender_free +}; + +AXIS2_EXTERN axis2_transport_sender_t* AXIS2_CALL +axis2_amqp_sender_create( + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, NULL); + + axis2_amqp_sender_resource_pack_t* sender_resource_pack = NULL; + + sender_resource_pack = (axis2_amqp_sender_resource_pack_t*)AXIS2_MALLOC(env->allocator, + sizeof(axis2_amqp_sender_resource_pack_t)); + + if(!sender_resource_pack) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + sender_resource_pack->sender.ops = &amqp_sender_ops; + sender_resource_pack->conf_ctx = NULL; + + return &(sender_resource_pack->sender); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_init( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx, + axis2_transport_out_desc_t* out_desc) +{ + axis2_amqp_sender_resource_pack_t* sender_resource_pack = NULL; + axutil_property_t* property = NULL; + int* request_timeout = (int*)AXIS2_MALLOC(env->allocator, sizeof(int)); + *request_timeout = AXIS2_QPID_NULL_CONF_INT; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + sender_resource_pack = AXIS2_AMQP_SENDER_TO_RESOURCE_PACK(sender); + sender_resource_pack->conf_ctx = conf_ctx; + + /* Set request timeout */ + *request_timeout = axis2_amqp_util_get_out_desc_conf_value_int(out_desc, env, + AXIS2_AMQP_CONF_QPID_REQUEST_TIMEOUT); + if(*request_timeout == AXIS2_QPID_NULL_CONF_INT) + { + *request_timeout = AXIS2_QPID_DEFAULT_REQUEST_TIMEOUT; + } + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0, 0, + (void*)request_timeout); + axis2_conf_ctx_set_property(sender_resource_pack->conf_ctx, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_REQUEST_TIMEOUT, property); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_invoke( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + axiom_soap_envelope_t* request_soap_envelope = NULL; + axiom_xml_writer_t* xml_writer = NULL; + axiom_output_t* request_om_output = NULL; + axis2_char_t* request_content = NULL; + axis2_bool_t is_server = AXIS2_TRUE; + axis2_bool_t is_soap_11 = AXIS2_FALSE; + axutil_string_t* content_type = NULL; + const axis2_char_t* soap_action = NULL; + axis2_bool_t do_mtom = AXIS2_FALSE; + axis2_bool_t status = AXIS2_FAILURE; + + request_soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, + AXIS2_XML_PARSER_TYPE_BUFFER); + if(!xml_writer) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create XML Writer"); + return AXIS2_FAILURE; + } + + request_om_output = axiom_output_create(env, xml_writer); + if(!request_om_output) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create OM Output"); + axiom_xml_writer_free(xml_writer, env); + xml_writer = NULL; + return AXIS2_FAILURE; + } + + is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + + /* Set SOAP version */ + axiom_output_set_soap11(request_om_output, env, is_soap_11); + + /* Content-Type */ + if(AXIS2_TRUE == is_soap_11) + { + /* SOAP1.1 */ + content_type = axutil_string_create(env, AXIS2_AMQP_HEADER_ACCEPT_TEXT_XML); + } + else + { + /* SOAP1.2 */ + content_type = axutil_string_create(env, AXIS2_AMQP_HEADER_ACCEPT_APPL_SOAP); + } + + /* SOAP action */ + soap_action = axutil_string_get_buffer(axis2_msg_ctx_get_soap_action(msg_ctx, env), env); + + if(!soap_action) + soap_action = ""; + + /* Handle MTOM */ + do_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env); + + axiom_output_set_do_optimize(request_om_output, env, do_mtom); + axiom_soap_envelope_serialize(request_soap_envelope, env, request_om_output, AXIS2_FALSE); + + if(do_mtom) + { + axis2_status_t mtom_status = AXIS2_FAILURE; + axutil_array_list_t* mime_parts = NULL; + + mtom_status = axiom_output_flush(request_om_output, env); + + if(mtom_status == AXIS2_SUCCESS) + { + mime_parts = axiom_output_get_mime_parts(request_om_output, env); + if(!mime_parts) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Unable to create the mime part list from request_om_output"); + + return AXIS2_FAILURE; + } + else + { + axis2_msg_ctx_set_mime_parts(msg_ctx, env, mime_parts); + } + } + + content_type = axutil_string_create(env, axiom_output_get_content_type(request_om_output, + env)); + } + + request_content = (axis2_char_t*)axiom_xml_writer_get_xml(xml_writer, env); + if(!request_content) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Serialize the SOAP Envelope"); + return AXIS2_FAILURE; + } + + is_server = axis2_amqp_util_msg_ctx_get_server_side(msg_ctx, env); + + if(is_server) + { + status = axis2_qpid_send(request_content, env, axutil_string_get_buffer(content_type, env), + soap_action, msg_ctx); + } + else + { + if(AXIS2_TRUE == axis2_amqp_util_msg_ctx_get_use_separate_listener(msg_ctx, env)) /* Dual Channel */ + { + status = axis2_qpid_send(request_content, env, axutil_string_get_buffer(content_type, + env), soap_action, msg_ctx); + } + else + { + axis2_op_t* op = NULL; + const axis2_char_t* mep = NULL; + + op = axis2_msg_ctx_get_op(msg_ctx, env); + + if(op) + { + mep = axis2_op_get_msg_exchange_pattern(op, env); + } + + axis2_amqp_response_t* response = NULL; + response = axis2_qpid_send_receive(request_content, env, axutil_string_get_buffer( + content_type, env), soap_action, msg_ctx); + + if(response) + { + /* Create in stream */ + if(response->data) + { + axutil_stream_t* in_stream = NULL; + axutil_property_t* property = NULL; + + in_stream = axutil_stream_create_basic(env); + axutil_stream_write(in_stream, env, response->data, response->length); + + property = axutil_property_create(env); + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_free_func(property, env, axutil_stream_free_void_arg); + axutil_property_set_value(property, env, in_stream); + + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, property); + } + + if(mep) + { + if(0 == axutil_strcmp(mep, AXIS2_MEP_URI_OUT_IN)) /* Out-In */ + { + axiom_soap_envelope_t* response_soap_envelope = NULL; + + response_soap_envelope = axis2_amqp_util_get_soap_envelope(response, env, + msg_ctx); + if(response_soap_envelope) + { + axis2_msg_ctx_set_response_soap_envelope(msg_ctx, env, + response_soap_envelope); + } + } + } + + status = AXIS2_SUCCESS; + + axis2_msg_ctx_set_status_code(msg_ctx, env, status); + + axis2_amqp_response_free(response, env); + } + else + { + if(mep) + { + if(axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY) == 0 || axutil_strcmp(mep, + AXIS2_MEP_URI_ROBUST_OUT_ONLY) == 0) /* One-way */ + { + status = AXIS2_SUCCESS; + + /* Set status code in msg_ctx */ + axis2_msg_ctx_set_status_code(msg_ctx, env, status); + } + } + } + } + } + + if(content_type) + axutil_string_free(content_type, env); + + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_clean_up( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx) +{ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_sender_free( + axis2_transport_sender_t* sender, + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, void); + + axis2_amqp_sender_resource_pack_t* sender_resource_pack = NULL; + sender_resource_pack = AXIS2_AMQP_SENDER_TO_RESOURCE_PACK(sender); + + AXIS2_FREE(env->allocator, sender_resource_pack); +} + +/* Library Exports */ + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_get_instance( +#else + axis2_amqp_sender_get_instance( +#endif + struct axis2_transport_sender** inst, + const axutil_env_t* env) +{ + int status = AXIS2_SUCCESS; + + *inst = axis2_amqp_sender_create(env); + if(!(*inst)) + { + status = AXIS2_FAILURE; + } + + return status; +} + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_remove_instance( +#else + axis2_amqp_sender_remove_instance( +#endif + axis2_transport_sender_t* inst, + const axutil_env_t* env) +{ + if(inst) + { + axis2_transport_sender_free(inst, env); + } + + return AXIS2_SUCCESS; +} + diff --git a/src/core/transport/amqp/sender/axis2_amqp_sender.h b/src/core/transport/amqp/sender/axis2_amqp_sender.h new file mode 100644 index 0000000..b523347 --- /dev/null +++ b/src/core/transport/amqp/sender/axis2_amqp_sender.h @@ -0,0 +1,63 @@ +/* + * 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_AMQP_SENDER_H +#define AXIS2_AMQP_SENDER_H + +#include +#include +#include +#include + +typedef struct axis2_amqp_sender_resource_pack +{ + axis2_transport_sender_t sender; + axis2_conf_ctx_t* conf_ctx; +} +axis2_amqp_sender_resource_pack_t; + +#define AXIS2_AMQP_SENDER_TO_RESOURCE_PACK(amqp_sender) \ + ((axis2_amqp_sender_resource_pack_t*)(amqp_sender)) + +AXIS2_EXTERN axis2_transport_sender_t* AXIS2_CALL +axis2_amqp_sender_create(const axutil_env_t* env); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_init( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx, + axis2_transport_out_desc_t* out_desc); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_invoke( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_clean_up( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx); + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_sender_free( + axis2_transport_sender_t* sender, + const axutil_env_t* env); + +#endif diff --git a/src/core/transport/amqp/sender/qpid_sender/Makefile.am b/src/core/transport/amqp/sender/qpid_sender/Makefile.am new file mode 100644 index 0000000..46dcb5e --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/Makefile.am @@ -0,0 +1,23 @@ +lib_LTLIBRARIES = libaxis2_qpid_sender.la + +libaxis2_qpid_sender_la_SOURCES = axis2_qpid_sender.cpp \ + axis2_qpid_sender_interface.cpp + +libaxis2_qpid_sender_la_LIBADD = $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la \ + $(QPID_HOME)/lib/libqpidclient.la + +libaxis2_qpid_sender_la_LDFLAGS = g++ -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/sender/qpid_sender \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include \ + -I$(QPID_HOME)/include + diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp new file mode 100644 index 0000000..7f0799b --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp @@ -0,0 +1,242 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace qpid::client; +using namespace qpid::framing; + +Axis2QpidSender::Axis2QpidSender( + string qpidBrokerIP, + int qpidBrokerPort, + const axutil_env_t* env) +{ + this->qpidBrokerIP = qpidBrokerIP; + this->qpidBrokerPort = qpidBrokerPort; + this->env = env; + this->responseContent = ""; + this->responseContentType = ""; +} + +Axis2QpidSender::~Axis2QpidSender( + void) +{ +} + +bool +Axis2QpidSender::SendReceive( + string messageContent, + string toQueueName, + bool isSOAP11, + string contentType, + string soapAction, + axutil_array_list_t* mime_parts, + int timeout) +{ + bool status = false; + this->responseContent = ""; + this->responseContentType = ""; + + try + { + Connection connection; + connection.open(qpidBrokerIP, qpidBrokerPort); + + Session session = connection.newSession(); + + /* Declare Private Queue */ + string replyToQueueName = AXIS2_AMQP_TEMP_QUEUE_NAME_PREFIX; + replyToQueueName.append(axutil_uuid_gen(env)); + + session.queueDeclare(arg::queue = replyToQueueName, arg::autoDelete = true); + session.exchangeBind(arg::exchange = AXIS2_AMQP_EXCHANGE_DIRECT, arg::queue + = replyToQueueName, arg::bindingKey = replyToQueueName); + + /* Create Message */ + Message reqMessage; + + reqMessage.getDeliveryProperties().setRoutingKey(toQueueName); + reqMessage.getMessageProperties().setReplyTo(ReplyTo(AXIS2_AMQP_EXCHANGE_DIRECT, + replyToQueueName)); + + reqMessage.getHeaders().setString(AXIS2_AMQP_HEADER_CONTENT_TYPE, contentType); + reqMessage.getHeaders().setString(AXIS2_AMQP_HEADER_SOAP_ACTION, soapAction); + + if(mime_parts) + { + string mimeBody; + GetMimeBody(mime_parts, mimeBody); + + messageContent.clear();/* MIME parts include SOAP envelop */ + + messageContent.append(mimeBody); + } + + reqMessage.setData(messageContent); + + session.messageTransfer(arg::content = reqMessage, arg::destination + = AXIS2_AMQP_EXCHANGE_DIRECT); + + /* Create subscription manager */ + SubscriptionManager subscriptionManager(session); + + Message resMessage; + qpid::sys::Duration reqTimeout(timeout * AXIS2_AMQP_NANOSEC_PER_MILLISEC); + + if(subscriptionManager.get(resMessage, replyToQueueName, reqTimeout)) + { + responseContent = resMessage.getData(); + responseContentType = resMessage.getHeaders().getAsString( + AXIS2_AMQP_HEADER_CONTENT_TYPE); + + status = true; + } + + connection.close(); + } + catch(const std::exception& e) + { + } + + return status; +} + +bool +Axis2QpidSender::Send( + string messageContent, + string toQueueName, + string replyToQueueName, + bool isSOAP11, + string contentType, + string soapAction, + axutil_array_list_t* mime_parts) +{ + bool status = false; + + try + { + Connection connection; + connection.open(qpidBrokerIP, qpidBrokerPort); + + Session session = connection.newSession(); + + /* Create Message */ + Message message; + + message.getDeliveryProperties().setRoutingKey(toQueueName); + + if(!replyToQueueName.empty()) /* Client dual-channel */ + { + message.getMessageProperties().setReplyTo(ReplyTo(AXIS2_AMQP_EXCHANGE_DIRECT, + replyToQueueName)); + + session.queueDeclare(arg::queue = replyToQueueName); + session.exchangeBind(arg::exchange = AXIS2_AMQP_EXCHANGE_DIRECT, arg::queue + = replyToQueueName, arg::bindingKey = replyToQueueName); + } + + message.getHeaders().setString(AXIS2_AMQP_HEADER_CONTENT_TYPE, contentType); + message.getHeaders().setString(AXIS2_AMQP_HEADER_SOAP_ACTION, soapAction); + + if(mime_parts) + { + string mimeBody; + GetMimeBody(mime_parts, mimeBody); + + messageContent.clear();/* MIME parts include SOAP envelop */ + + messageContent.append(mimeBody); + } + + message.setData(messageContent); + + session.messageTransfer(arg::content = message, arg::destination + = AXIS2_AMQP_EXCHANGE_DIRECT); + + connection.close(); + + status = true; + } + catch(const std::exception& e) + { + } + + return status; +} + +void +Axis2QpidSender::GetMimeBody( + axutil_array_list_t* mime_parts, + string& mimeBody) +{ + int i = 0; + axiom_mime_part_t *mime_part = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + if(!mime_parts) + return; + + for(i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + + if(mime_part->type == AXIOM_MIME_PART_BUFFER) + { + mimeBody.append(mime_part->part, mime_part->part_size); + } + else if(mime_part->type == AXIOM_MIME_PART_FILE) + { + int length; + char* buffer; + + ifstream file; + file.open(mime_part->file_name, ios::binary); + + file.seekg(0, ios::end); + length = file.tellg(); + file.seekg(0, ios::beg); + + buffer = new char[length]; + + file.read(buffer, length); + file.close(); + + mimeBody.append(buffer, length); + + delete[] buffer; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unknown mime type"); + return; + } + + if(status == AXIS2_FAILURE) + { + break; + } + } +} diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h new file mode 100644 index 0000000..8c94cfa --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h @@ -0,0 +1,49 @@ +/* + * 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 + * + * tcp://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_QPID_SENDER_H +#define AXIS2_QPID_SENDER_H + +#include +#include +#include + +using std::string; + +class Axis2QpidSender +{ + public: + Axis2QpidSender(string qpidBrokerIP, int qpidBrokerPort, const axutil_env_t* env); + ~Axis2QpidSender(void); + + bool SendReceive(string messageContent, string toQueueName, bool isSOAP11, + string contentType, string soapAction, axutil_array_list_t* mime_parts, int timeout); + bool Send(string messageContent, string toQueueName, string replyToQueueName, bool isSOAP11, + string contentType, string soapAction, axutil_array_list_t* mime_parts); + + string responseContent; + string responseContentType; + + private: + void GetMimeBody(axutil_array_list_t* mime_parts, string& mimeBody); + + string qpidBrokerIP; + int qpidBrokerPort; + const axutil_env_t* env; +}; + +#endif diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp new file mode 100644 index 0000000..ac4f51e --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp @@ -0,0 +1,130 @@ +/* +* 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. +*/ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +AXIS2_EXTERN axis2_amqp_response_t* AXIS2_CALL +axis2_qpid_send_receive( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx) +{ + axis2_amqp_destination_info_t* destination_info = NULL; + destination_info = axis2_amqp_util_msg_ctx_get_destination_info(msg_ctx, env); + + if (!destination_info || !destination_info->broker_ip || + !destination_info->broker_port || !destination_info->queue_name) + { + return NULL; + } + + axis2_bool_t is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + axutil_array_list_t* mime_parts = axis2_msg_ctx_get_mime_parts(msg_ctx, env); + int timeout = axis2_amqp_util_msg_ctx_get_request_timeout(msg_ctx, env); + + /* Get Response */ + Axis2QpidSender qpid_sender(destination_info->broker_ip, + destination_info->broker_port, env); + + bool status = qpid_sender.SendReceive(request_content, destination_info->queue_name, + is_soap_11, content_type, soap_action, mime_parts, timeout); + + axis2_amqp_destination_info_free(destination_info, env); + + if (!status) + { + return NULL; + } + + /* Create response */ + axis2_amqp_response_t* response = (axis2_amqp_response_t*)AXIS2_MALLOC( + env->allocator, sizeof(axis2_amqp_response_t)); + + /* Data */ + response->data = AXIS2_MALLOC(env->allocator, qpid_sender.responseContent.size()); + memcpy(response->data, qpid_sender.responseContent.c_str(), + qpid_sender.responseContent.size()); + + /* Length */ + response->length = qpid_sender.responseContent.size(); + + /* ContentType */ + response->content_type = (axis2_char_t*)AXIS2_MALLOC( + env->allocator, qpid_sender.responseContentType.size() + 1); + strcpy(response->content_type, qpid_sender.responseContentType.c_str()); + + return response; +} + + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_qpid_send( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx) +{ + axis2_amqp_destination_info_t* destination_info = NULL; + axis2_status_t status = AXIS2_FAILURE; + string reply_to_queue_name = ""; + + destination_info = axis2_amqp_util_msg_ctx_get_destination_info(msg_ctx, env); + + if (!destination_info || !destination_info->broker_ip || + !destination_info->broker_port || !destination_info->queue_name) + { + return AXIS2_FAILURE; + } + + axis2_bool_t is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + axutil_array_list_t* mime_parts = axis2_msg_ctx_get_mime_parts(msg_ctx, env); + + /* If client side, find reply_to_queue_name */ + if (!axis2_msg_ctx_get_server_side(msg_ctx, env)) + { + axis2_conf_ctx_t* conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + axis2_char_t* queue_name = + axis2_amqp_util_conf_ctx_get_dual_channel_queue_name(conf_ctx, env); + if (queue_name) + reply_to_queue_name = queue_name; + } + + Axis2QpidSender qpid_sender(destination_info->broker_ip, + destination_info->broker_port, env); + + status = qpid_sender.Send(request_content, destination_info->queue_name, + reply_to_queue_name, is_soap_11, content_type, soap_action, mime_parts); + + axis2_amqp_destination_info_free(destination_info, env); + + return status; +} + +#ifdef __cplusplus +} +#endif diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h new file mode 100644 index 0000000..94e232f --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h @@ -0,0 +1,50 @@ +/* +* 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_QPID_SENDER_INTERFACE_H +#define AXIS2_QPID_SENDER_INTERFACE_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +AXIS2_EXTERN axis2_amqp_response_t* AXIS2_CALL +axis2_qpid_send_receive( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_qpid_send( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/core/transport/amqp/server/Makefile.am b/src/core/transport/amqp/server/Makefile.am new file mode 100644 index 0000000..2de6967 --- /dev/null +++ b/src/core/transport/amqp/server/Makefile.am @@ -0,0 +1 @@ +SUBDIRS = axis2_amqp_server diff --git a/src/core/transport/amqp/server/axis2_amqp_server/Makefile.am b/src/core/transport/amqp/server/axis2_amqp_server/Makefile.am new file mode 100644 index 0000000..643827f --- /dev/null +++ b/src/core/transport/amqp/server/axis2_amqp_server/Makefile.am @@ -0,0 +1,33 @@ +prgbindir = $(bindir) + +prgbin_PROGRAMS = axis2_amqp_server + +AM_CFLAGS = -g -pthread + +axis2_amqp_server_SOURCES = axis2_amqp_server.c + +axis2_amqp_server_LDADD = $(LDFLAGS) \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la \ + $(top_builddir)/src/core/description/libaxis2_description.la \ + $(top_builddir)/src/core/deployment/libaxis2_deployment.la \ + $(top_builddir)/src/core/context/libaxis2_context.la \ + $(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la \ + $(top_builddir)/neethi/src/libneethi.la \ + $(top_builddir)/src/core/transport/amqp/receiver/libaxis2_amqp_receiver.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la \ + -lpthread + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/deploymenti \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/transport/amqp/receiver \ + -I$(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.c b/src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.c new file mode 100644 index 0000000..9f69283 --- /dev/null +++ b/src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.c @@ -0,0 +1,232 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +axis2_transport_receiver_t* receiver = NULL; +axutil_env_t* server_env = NULL; + +axutil_env_t* +init_server_env( + axutil_allocator_t* allocator, + const axis2_char_t* log_file_name) +{ + axutil_error_t* error = axutil_error_create(allocator); + axutil_log_t* log = axutil_log_create(allocator, NULL, log_file_name); + axutil_thread_pool_t* thread_pool = axutil_thread_pool_init(allocator); + axutil_env_t* env = axutil_env_create_with_error_log_thread_pool(allocator, error, log, + thread_pool); + + axiom_xml_reader_init(); + + return env; +} + +void +server_exit( + int status) +{ + if(receiver) + { + axis2_transport_receiver_free(receiver, server_env); + } + + if(server_env) + { + axutil_env_free(server_env); + } + + axiom_xml_reader_cleanup(); + + exit(status); +} + +void +show_usage( + axis2_char_t* prog_name) +{ + fprintf(stdout, "\n Usage : %s", prog_name); + fprintf(stdout, " [-i QPID_BROKER_IP]"); + fprintf(stdout, " [-p QPID_BROKER_PORT]"); + fprintf(stdout, " [-r REPO_PATH]"); + fprintf(stdout, " [-l LOG_LEVEL]"); + fprintf(stdout, " [-f LOG_FILE]\n"); + fprintf(stdout, " [-s LOG_FILE_SIZE]\n"); + fprintf(stdout, " Options :\n"); + fprintf(stdout, "\t-i QPID_BROKER_IP \t Qpid broker IP, default is 127.0.0.1\n"); + fprintf(stdout, + "\t-p QPID_BROKER_PORT \t the port on which the Qpid broker listens, default is 5672\n"); + fprintf(stdout, "\t-r REPO_PATH \t\t repository path, default is ../\n"); + fprintf(stdout, "\t-l LOG_LEVEL\t\t log level, available log levels:" + "\n\t\t\t\t\t 0 - critical 1 - errors 2 - warnings" + "\n\t\t\t\t\t 3 - information 4 - debug 5- user 6 - trace" + "\n\t\t\t\t\t Default log level is 4(debug).\n"); +#ifndef WIN32 + fprintf(stdout, "\t-f LOG_FILE\t\t log file, default is $AXIS2C_HOME/logs/axis2.log" + "\n\t\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#else + fprintf(stdout, + "\t-f LOG_FILE\t\t log file, default is %%AXIS2C_HOME%%\\logs\\axis2.log" + "\n\t\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#endif + fprintf(stdout, + "\t-s LOG_FILE_SIZE\t Maximum log file size in mega bytes, default maximum size is 1MB.\n"); + fprintf(stdout, " Help :\n\t-h \t\t\t display this help screen.\n\n"); +} + +#ifndef WIN32 + +void +sig_handler( + int signal) +{ + switch(signal) + { + case SIGINT: + AXIS2_LOG_INFO(server_env->log, "Received signal SIGINT.Server shutting down"); + axis2_amqp_receiver_stop(receiver, server_env); + AXIS2_LOG_INFO(server_env->log, "Shutdown complete ..."); + + server_exit(0); + + case SIGPIPE: + AXIS2_LOG_INFO(server_env->log, "Received signal SIGPIPE.Client request serve aborted"); + return; + + case SIGSEGV: + fprintf(stderr, "Received deadly signal SIGSEGV. Terminating ...\n"); + _exit(-1); + } +} + +#endif + +int +main( + int argc, + char* argv[]) +{ + axutil_allocator_t* allocator = NULL; + extern char* optarg; + extern int optopt; + int c; + const axis2_char_t* qpid_broker_ip = NULL; + int qpid_broker_port = AXIS2_QPID_NULL_CONF_INT; + const axis2_char_t* repo_path = AXIS2_AMQP_SERVER_REPO_PATH; + axutil_log_levels_t log_level = AXIS2_LOG_LEVEL_DEBUG; + const axis2_char_t* log_file_name = AXIS2_AMQP_SERVER_LOG_FILE_NAME; + int log_file_size = AXUTIL_LOG_FILE_SIZE; + + while((c = AXIS2_GETOPT(argc, argv, "i:p:r:l:f:s:h")) != -1) + { + switch(c) + { + case 'i': + qpid_broker_ip = optarg; + break; + + case 'p': + qpid_broker_port = AXIS2_ATOI(optarg); + break; + + case 'r': + repo_path = optarg; + break; + + case 'l': + log_level = AXIS2_ATOI(optarg); + if(log_level < AXIS2_LOG_LEVEL_CRITICAL) + log_level = AXIS2_LOG_LEVEL_CRITICAL; + if(log_level > AXIS2_LOG_LEVEL_TRACE) + log_level = AXIS2_LOG_LEVEL_TRACE; + break; + + case 'f': + log_file_name = optarg; + break; + + case 's': + log_file_size = 1024 * 1024 * AXIS2_ATOI(optarg); + break; + + case 'h': + show_usage(argv[0]); + return 0; + + case ':': + fprintf(stderr, "\nOption -%c requires an operand\n", optopt); + show_usage(argv[0]); + return -1; + + case '?': + if(isprint(optopt)) + fprintf(stderr, "\nUnknown option `-%c'.\n", optopt); + show_usage(argv[0]); + return -1; + } + } + + allocator = axutil_allocator_init(NULL); + if(!allocator) + { + server_exit(-1); + } + + server_env = init_server_env(allocator, log_file_name); + server_env->log->level = log_level; + server_env->log->size = log_file_size; + + axutil_error_init(); + +#ifndef WIN32 + signal(SIGINT, sig_handler); + signal(SIGPIPE, sig_handler); +#endif + + AXIS2_LOG_INFO(server_env->log, "Starting Axis2 AMQP Server ..."); + AXIS2_LOG_INFO(server_env->log, "Repo Location : %s", repo_path); + + receiver = axis2_amqp_receiver_create(server_env, repo_path, qpid_broker_ip, qpid_broker_port); + if(!receiver) + { + AXIS2_LOG_ERROR(server_env->log, AXIS2_LOG_SI, + "Server creation failed: Error code:" " %d :: %s", server_env->error->error_number, + AXIS2_ERROR_GET_MESSAGE(server_env->error)); + server_exit(-1); + } + + if(axis2_amqp_receiver_start(receiver, server_env) == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(server_env->log, AXIS2_LOG_SI, + "Server start failed: Error code:" " %d :: %s", server_env->error->error_number, + AXIS2_ERROR_GET_MESSAGE(server_env->error)); + server_exit(-1); + } + + return 0; +} diff --git a/src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.h b/src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.h new file mode 100644 index 0000000..82a200e --- /dev/null +++ b/src/core/transport/amqp/server/axis2_amqp_server/axis2_amqp_server.h @@ -0,0 +1,41 @@ +/* + * 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 + * + * tcp://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_AMQP_SERVER_H +#define AXIS2_AMQP_SERVER_H + +#include +#include + +axutil_env_t* +init_server_env(axutil_allocator_t* allocator, + const axis2_char_t* log_file_name); + +void +server_exit(int status); + +void +show_usage(axis2_char_t* prog_name); + +#ifndef WIN32 + +void +sig_handler(int signal); + +#endif + +#endif diff --git a/src/core/transport/amqp/util/Makefile.am b/src/core/transport/amqp/util/Makefile.am new file mode 100644 index 0000000..2b27d76 --- /dev/null +++ b/src/core/transport/amqp/util/Makefile.am @@ -0,0 +1,18 @@ +lib_LTLIBRARIES = libaxis2_amqp_util.la + +libaxis2_amqp_util_la_SOURCES = axis2_amqp_util.c + +libaxis2_amqp_util_la_LIBADD = $(top_builddir)/util/src/libaxutil.la + +libaxis2_amqp_util_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/transport/amqp/sender/qpid_sender \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include + diff --git a/src/core/transport/amqp/util/axis2_amqp_defines.h b/src/core/transport/amqp/util/axis2_amqp_defines.h new file mode 100644 index 0000000..a892e9e --- /dev/null +++ b/src/core/transport/amqp/util/axis2_amqp_defines.h @@ -0,0 +1,65 @@ +/* + * 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_AMQP_DEFINES_H +#define AXIS2_AMQP_DEFINES_H + +#include + +#define AXIS2_AMQP_EXCHANGE_DIRECT "amq.direct" + +#define AXIS2_AMQP_CONF_QPID_BROKER_IP "qpid_broker_ip" +#define AXIS2_AMQP_CONF_QPID_BROKER_PORT "qpid_broker_port" +#define AXIS2_AMQP_CONF_QPID_REQUEST_TIMEOUT "request_timeout" + +#define AXIS2_QPID_DEFAULT_BROKER_IP "127.0.0.1" +#define AXIS2_QPID_DEFAULT_BROKER_PORT 5672 +#define AXIS2_QPID_DEFAULT_REQUEST_TIMEOUT 500 +#define AXIS2_QPID_NULL_CONF_INT -1 + +#define AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_IP "qpid_broker_ip" +#define AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_PORT "qpid_broker_port" +#define AXIS2_AMQP_CONF_CTX_PROPERTY_REQUEST_TIMEOUT "request_timeout" +#define AXIS2_AMQP_CONF_CTX_PROPERTY_QUEUE_NAME "queue_name" + +#define AXIS2_AMQP_MSG_CTX_PROPERTY_REPLY_TO "qpid_reply_to" + +#define AXIS2_AMQP_HEADER_ACCEPT_TEXT_XML "text/xml" +#define AXIS2_AMQP_HEADER_ACCEPT_APPL_SOAP "application/soap+xml" +#define AXIS2_AMQP_HEADER_ACCEPT_MULTIPART_RELATED AXIOM_MIME_TYPE_MULTIPART_RELATED +#define AXIS2_AMQP_HEADER_CONTENT_TYPE_MIME_BOUNDARY "boundary" +#define AXIS2_AMQP_HEADER_SOAP_ACTION "SOAPAction" +#define AXIS2_AMQP_HEADER_CONTENT_TYPE "Content-Type" + +#define AXIS2_AMQP_TEMP_QUEUE_NAME_PREFIX "TempQueue" + +#define AXIS2_AMQP_SERVER_LOG_FILE_NAME "axis2_amqp_server.log" +#define AXIS2_AMQP_SERVER_REPO_PATH "../" + +#define AXIS2_AMQP_EPR_PREFIX "amqp:" +#define AXIS2_AMQP_EPR_SERVICE_PREFIX "services" +#define AXIS2_AMQP_EPR_ANON_SERVICE_NAME "__ANONYMOUS_SERVICE__" + +#define AXIS2_AMQP_EQ '=' +#define AXIS2_AMQP_SEMI_COLON ';' +#define AXIS2_AMQP_ESC_NULL '\0' +#define AXIS2_AMQP_DOUBLE_QUOTE '"' +#define AXIS2_AMQP_B_SLASH '\\' + +#define AXIS2_AMQP_NANOSEC_PER_MILLISEC 1000*1000 + +#endif diff --git a/src/core/transport/amqp/util/axis2_amqp_util.c b/src/core/transport/amqp/util/axis2_amqp_util.c new file mode 100644 index 0000000..cfef4a9 --- /dev/null +++ b/src/core/transport/amqp/util/axis2_amqp_util.c @@ -0,0 +1,823 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +AXIS2_EXTERN axis2_char_t* AXIS2_CALL +axis2_amqp_util_get_in_desc_conf_value_string( + axis2_transport_in_desc_t* in_desc, + const axutil_env_t* env, + const axis2_char_t* param_name) +{ + axutil_param_t* param = NULL; + axis2_char_t* value = NULL; + + param = (axutil_param_t*)axutil_param_container_get_param( + axis2_transport_in_desc_param_container(in_desc, env), env, param_name); + if(param) + { + value = axutil_param_get_value(param, env); + } + + return value; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_amqp_util_get_in_desc_conf_value_int( + axis2_transport_in_desc_t* in_desc, + const axutil_env_t* env, + const axis2_char_t* param_name) +{ + axis2_char_t* value_str = NULL; + int value = AXIS2_QPID_NULL_CONF_INT; + + value_str = axis2_amqp_util_get_in_desc_conf_value_string(in_desc, env, param_name); + if(value_str) + { + value = atoi(value_str); + } + + return value; +} + +AXIS2_EXTERN axis2_char_t* AXIS2_CALL +axis2_amqp_util_get_out_desc_conf_value_string( + axis2_transport_out_desc_t* out_desc, + const axutil_env_t* env, + const axis2_char_t* param_name) +{ + axutil_param_t* param = NULL; + axis2_char_t* value = NULL; + + param = (axutil_param_t*)axutil_param_container_get_param( + axis2_transport_out_desc_param_container(out_desc, env), env, param_name); + if(param) + { + value = axutil_param_get_value(param, env); + } + + return value; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_amqp_util_get_out_desc_conf_value_int( + axis2_transport_out_desc_t* out_desc, + const axutil_env_t* env, + const axis2_char_t* param_name) +{ + axis2_char_t* value_str = NULL; + int value = AXIS2_QPID_NULL_CONF_INT; + + value_str = axis2_amqp_util_get_out_desc_conf_value_string(out_desc, env, param_name); + if(value_str) + { + value = atoi(value_str); + } + + return value; +} + +AXIS2_EXTERN axiom_soap_envelope_t* AXIS2_CALL +axis2_amqp_util_get_soap_envelope( + axis2_amqp_response_t* response, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx) +{ + axiom_xml_reader_t* xml_reader = NULL; + axiom_stax_builder_t* stax_builder = NULL; + axiom_soap_builder_t* soap_builder = NULL; + axiom_soap_envelope_t* soap_envelope = NULL; + const axis2_char_t* soap_ns_uri = NULL; + axis2_char_t *soap_body_str = NULL; + int soap_body_len = 0; + axis2_bool_t is_mtom = AXIS2_FALSE; + axutil_hash_t *binary_data_map = NULL; + axis2_bool_t is_soap_11 = AXIS2_FALSE; + + if(!response || !response->data || !response->content_type) + { + return NULL; + } + + is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + + /* Handle MTOM */ + if(strstr(response->content_type, AXIS2_AMQP_HEADER_ACCEPT_MULTIPART_RELATED)) + { + axis2_char_t* mime_boundary = axis2_amqp_util_get_value_from_content_type(env, + response->content_type, AXIS2_AMQP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + axiom_mime_parser_t *mime_parser = NULL; + int soap_body_len = 0; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + + if(buffer_size_param) + { + value_size = (axis2_char_t *)axutil_param_get_value(buffer_size_param, env); + + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + + if(max_buffers_param) + { + value_num = (axis2_char_t*)axutil_param_get_value(max_buffers_param, env); + + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + + if(attachment_dir_param) + { + value_dir = (axis2_char_t*)axutil_param_get_value(attachment_dir_param, env); + + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + if(mime_parser) + { + axis2_callback_info_t* callback_ctx = NULL; + axutil_stream_t* stream = NULL; + + callback_ctx = (axis2_callback_info_t*)AXIS2_MALLOC(env->allocator, + sizeof(axis2_callback_info_t)); + + stream = axutil_stream_create_basic(env); + + if(stream) + { + axutil_stream_write(stream, env, response->data, response->length); + callback_ctx->env = env; + callback_ctx->in_stream = stream; + callback_ctx->content_length = response->length; + callback_ctx->unread_len = response->length; + callback_ctx->chunked_stream = NULL; + } + + /*binary_data_map = + axiom_mime_parser_parse(mime_parser, env, + axis2_amqp_util_on_data_request, + (void*)callback_ctx, + mime_boundary);*/ + + if(!binary_data_map) + { + return AXIS2_FAILURE; + } + + soap_body_len = axiom_mime_parser_get_soap_body_len(mime_parser, env); + + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + + axutil_stream_free(stream, env); + AXIS2_FREE(env->allocator, callback_ctx); + axiom_mime_parser_free(mime_parser, env); + } + + AXIS2_FREE(env->allocator, mime_boundary); + } + + is_mtom = AXIS2_TRUE; + } + else + { + soap_body_str = response->data; + soap_body_len = axutil_strlen(response->data); + } + + soap_body_len = axutil_strlen(soap_body_str); + + xml_reader = axiom_xml_reader_create_for_memory(env, soap_body_str, soap_body_len, NULL, + AXIS2_XML_PARSER_TYPE_BUFFER); + if(!xml_reader) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create XML Reader"); + return NULL; + } + + stax_builder = axiom_stax_builder_create(env, xml_reader); + if(!stax_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create StAX Builder"); + return NULL; + } + + soap_ns_uri = is_soap_11 ? AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI + : AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; + + soap_builder = axiom_soap_builder_create(env, stax_builder, soap_ns_uri); + if(!soap_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create SOAP Builder"); + return NULL; + } + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + + if(soap_envelope) + { + /* hack to get around MTOM problem */ + axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(soap_body) + { + axiom_soap_body_has_fault(soap_body, env); + } + } + + return soap_envelope; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_amqp_util_conf_ctx_get_server_side( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env) +{ + axutil_property_t* property = NULL; + axis2_char_t* value = NULL; + + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_IS_SVR_SIDE); + if(!property) + return AXIS2_TRUE; + + value = (axis2_char_t*)axutil_property_get_value(property, env); + if(!value) + return AXIS2_TRUE; + + return (axutil_strcmp(value, AXIS2_VALUE_TRUE) == 0) ? AXIS2_TRUE : AXIS2_FALSE; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_amqp_util_get_value_from_content_type( + const axutil_env_t * env, + const axis2_char_t * content_type, + const axis2_char_t * key) +{ + axis2_char_t *tmp = NULL; + axis2_char_t *tmp_content_type = NULL; + axis2_char_t *tmp2 = NULL; + + AXIS2_PARAM_CHECK(env->error, content_type, NULL); + AXIS2_PARAM_CHECK(env->error, key, NULL); + + tmp_content_type = axutil_strdup(env, content_type); + + if(!tmp_content_type) + { + return NULL; + } + + tmp = strstr(tmp_content_type, key); + + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_content_type); + return NULL; + } + + tmp = strchr(tmp, AXIS2_AMQP_EQ); + tmp2 = strchr(tmp, AXIS2_AMQP_SEMI_COLON); + + if(tmp2) + { + *tmp2 = AXIS2_AMQP_ESC_NULL; + } + + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_content_type); + return NULL; + } + + tmp2 = axutil_strdup(env, tmp + 1); + + AXIS2_FREE(env->allocator, tmp_content_type); + + if(*tmp2 == AXIS2_AMQP_DOUBLE_QUOTE) + { + tmp = tmp2; + tmp2 = axutil_strdup(env, tmp + 1); + tmp2[strlen(tmp2) - 1] = AXIS2_AMQP_ESC_NULL; + + if(tmp) + { + AXIS2_FREE(env->allocator, tmp); + tmp = NULL; + } + } + + /* handle XOP */ + if(*tmp2 == AXIS2_AMQP_B_SLASH && *(tmp2 + 1) == '\"') + { + tmp = tmp2; + tmp2 = axutil_strdup(env, tmp + 2); + tmp2[strlen(tmp2) - 3] = AXIS2_AMQP_ESC_NULL; + + if(tmp) + { + AXIS2_FREE(env->allocator, tmp); + tmp = NULL; + } + } + + return tmp2; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_amqp_util_on_data_request( + char* buffer, + int size, + void* ctx) +{ + const axutil_env_t* env = NULL; + int len = -1; + axis2_callback_info_t* cb_ctx = (axis2_callback_info_t*)ctx; + axutil_stream_t* in_stream = NULL; + + if(!buffer || !ctx) + { + return 0; + } + + if(cb_ctx->unread_len <= 0 && -1 != cb_ctx->content_length) + { + return 0; + } + + env = ((axis2_callback_info_t*)ctx)->env; + + in_stream = (axutil_stream_t*)((axis2_callback_info_t *)ctx)->in_stream; + --size; /* reserve space to insert trailing null */ + + len = axutil_stream_read(in_stream, env, buffer, size); + + if(len > 0) + { + buffer[len] = AXIS2_AMQP_ESC_NULL; + ((axis2_callback_info_t*)ctx)->unread_len -= len; + } + else if(len == 0) + { + ((axis2_callback_info_t*)ctx)->unread_len = 0; + } + + return len; +} + +AXIS2_EXTERN axis2_char_t* AXIS2_CALL +axis2_amqp_util_conf_ctx_get_dual_channel_queue_name( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env) +{ + axutil_property_t* property = NULL; + axis2_char_t* queue_name = NULL; + axis2_char_t* value = NULL; + + /* Get property */ + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_AMQP_CONF_CTX_PROPERTY_QUEUE_NAME); + if(!property) /* Very first call */ + { + property = axutil_property_create(env); + + axis2_conf_ctx_set_property(conf_ctx, env, AXIS2_AMQP_CONF_CTX_PROPERTY_QUEUE_NAME, + property); + } + + /* Get queue name */ + value = (axis2_char_t*)axutil_property_get_value(property, env); + + /* AMQP listener and the sender are the two parties that are + * interested in the queue. Either party can create the queue. + * If the queue is already created by one party, "value" is + * not NULL. If "value" is NULL, that mean the caller of + * this method is supposed to create the queue */ + if(value) + { + queue_name = (axis2_char_t*)AXIS2_MALLOC(env->allocator, axutil_strlen(value) + 1); + strcpy(queue_name, value); + + /*axutil_property_set_value(property, env, NULL);*/ + } + else + { + /* Create new queue name */ + queue_name = axutil_stracat(env, AXIS2_AMQP_TEMP_QUEUE_NAME_PREFIX, axutil_uuid_gen(env)); + + /* Put queue name in the conf_ctx so that the sender will know */ + axutil_property_set_value(property, env, (void*)queue_name); + } + + return queue_name; +} + +AXIS2_EXTERN axis2_char_t* AXIS2_CALL +axis2_amqp_util_conf_ctx_get_qpid_broker_ip( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env) +{ + axutil_property_t* property = NULL; + void* value = NULL; + axis2_char_t* broker_ip = AXIS2_QPID_DEFAULT_BROKER_IP; + + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_IP); + + if(property) + { + value = axutil_property_get_value(property, env); + + if(value) + { + broker_ip = (axis2_char_t*)value; + } + } + + return broker_ip; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_amqp_util_conf_ctx_get_qpid_broker_port( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env) +{ + axutil_property_t* property = NULL; + void* value = NULL; + int broker_port = AXIS2_QPID_DEFAULT_BROKER_PORT; + + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_PORT); + + if(property) + { + value = axutil_property_get_value(property, env); + + if(value) + { + broker_port = *(int*)value; + } + } + + return broker_port; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_amqp_util_msg_ctx_get_use_separate_listener( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env) +{ + axutil_property_t* property = NULL; + axis2_char_t* value = NULL; + axis2_bool_t use_separate_listener = AXIS2_FALSE; + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_USE_SEPARATE_LISTENER); + + if(property) + { + value = (axis2_char_t*)axutil_property_get_value(property, env); + + if(value && (axutil_strcmp(AXIS2_VALUE_TRUE, value) == 0)) + { + use_separate_listener = AXIS2_TRUE; + } + } + + return use_separate_listener; +} + +AXIS2_EXTERN axis2_amqp_destination_info_t* AXIS2_CALL +axis2_amqp_util_msg_ctx_get_destination_info( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env) +{ + /* The destination URI that is expected by this method + * should be of one of the following formats + * 1. amqp://IP:PORT/services/SERVICE_NAME + * 2. jms:/SERVICE_NAME?java.naming.provider.url=tcp://IP:PORT... + * 3. TempQueue... */ + + axis2_endpoint_ref_t* endpoint_ref = NULL; + axis2_amqp_destination_info_t* destination_info = NULL; + + destination_info = (axis2_amqp_destination_info_t*)AXIS2_MALLOC(env->allocator, + sizeof(axis2_amqp_destination_info_t)); + + destination_info->broker_ip = NULL; + destination_info->broker_port = AXIS2_QPID_NULL_CONF_INT; + destination_info->queue_name = NULL; + + endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); + + if(endpoint_ref) + { + const axis2_char_t* endpoint_address_original = NULL; + axis2_char_t* endpoint_address = NULL; + char* substr = NULL; + char* token = NULL; + endpoint_address_original = axis2_endpoint_ref_get_address(endpoint_ref, env); + + if(!endpoint_address_original) + return NULL; + + endpoint_address = (axis2_char_t*)AXIS2_MALLOC(env->allocator, (sizeof(axis2_char_t) + * axutil_strlen(endpoint_address_original)) + 1); + strcpy((char*)endpoint_address, (char*)endpoint_address_original); + + if((substr = strstr(endpoint_address, AXIS2_AMQP_EPR_PREFIX))) /* Start with amqp: */ + { + if(strstr(endpoint_address, AXIS2_AMQP_EPR_ANON_SERVICE_NAME)) + { + /* Server reply to dual-channel client */ + axutil_property_t* property = NULL; + property = axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_AMQP_MSG_CTX_PROPERTY_REPLY_TO); + + if(property) + { + axis2_char_t* queue_name = (axis2_char_t*)axutil_property_get_value(property, + env); + + if(queue_name) + { + destination_info->queue_name = (axis2_char_t*)AXIS2_MALLOC(env->allocator, + (sizeof(axis2_char_t) * strlen(queue_name)) + 1); + strcpy(destination_info->queue_name, queue_name); + } + } + } + else + { + substr += strlen(AXIS2_AMQP_EPR_PREFIX) + 2; /* 2 -> "//" */ + if(substr) /* IP:PORT/services/SERVICE_NAME */ + { + token = strtok(substr, ":"); + if(token) /* IP */ + { + axis2_char_t* broker_ip = (axis2_char_t*)AXIS2_MALLOC(env->allocator, + (sizeof(axis2_char_t) * strlen(token)) + 1); + strcpy(broker_ip, token); + destination_info->broker_ip = broker_ip; + + token = strtok(NULL, "/"); /* PORT */ + if(token) + { + destination_info->broker_port = atoi(token); + + token = strtok(NULL, "#"); /* ... services/SERVICE_NAME */ + if(token) + { + if((substr = strstr(token, AXIS2_AMQP_EPR_SERVICE_PREFIX))) + { + substr += strlen(AXIS2_AMQP_EPR_SERVICE_PREFIX) + 1; /* 1 -> "/" */ + if(substr) + { + axis2_char_t* queue_name = (axis2_char_t*)AXIS2_MALLOC( + env->allocator, (sizeof(axis2_char_t) * strlen(substr)) + + 1); + strcpy(queue_name, substr); + destination_info->queue_name = queue_name; + } + } + } + } + } + } + } + } + else if(0 == strcmp(endpoint_address, AXIS2_WSA_ANONYMOUS_URL)) /* Required to work with Sandesha2 */ + { + axutil_property_t* property = NULL; + property = axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_AMQP_MSG_CTX_PROPERTY_REPLY_TO); + + if(property) + { + axis2_char_t* queue_name = (axis2_char_t*)axutil_property_get_value(property, env); + + if(queue_name) + { + destination_info->queue_name = (axis2_char_t*)AXIS2_MALLOC(env->allocator, + (sizeof(axis2_char_t) * strlen(queue_name)) + 1); + strcpy(destination_info->queue_name, queue_name); + } + } + } + else if((substr = strstr(endpoint_address, "jms:/")) && (substr == endpoint_address)) + { + + } + + AXIS2_FREE(env->allocator, endpoint_address); + } + else + { + /* Single-channel blocking */ + axutil_property_t* property = NULL; + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_AMQP_MSG_CTX_PROPERTY_REPLY_TO); + + if(property) + { + axis2_char_t* queue_name = (axis2_char_t*)axutil_property_get_value(property, env); + + if(queue_name) + { + destination_info->queue_name = (axis2_char_t*)AXIS2_MALLOC(env->allocator, + (sizeof(axis2_char_t) * strlen(queue_name)) + 1); + strcpy(destination_info->queue_name, queue_name); + } + } + } + + /* Get broker IP/Port from conf_ctx if they are not + * found in the destination URI */ + if(!destination_info->broker_ip) + { + axis2_conf_ctx_t* conf_ctx = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axutil_property_t* property = NULL; + property = axis2_conf_ctx_get_property(conf_ctx, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_IP); + + if(property) + { + axis2_char_t* broker_ip = (axis2_char_t*)axutil_property_get_value(property, env); + + if(broker_ip) + { + destination_info->broker_ip = (axis2_char_t*)AXIS2_MALLOC(env->allocator, + (sizeof(axis2_char_t) * strlen(broker_ip)) + 1); + strcpy(destination_info->broker_ip, broker_ip); + } + } + + } + } + + if(AXIS2_QPID_NULL_CONF_INT == destination_info->broker_port) + { + axis2_conf_ctx_t* conf_ctx = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + axutil_property_t* property = NULL; + property = axis2_conf_ctx_get_property(conf_ctx, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_BROKER_PORT); + + if(property) + { + void* value = axutil_property_get_value(property, env); + + if(value) + { + destination_info->broker_port = *(int*)value; + } + } + } + } + + return destination_info; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_amqp_util_msg_ctx_get_request_timeout( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env) +{ + axis2_conf_ctx_t* conf_ctx = NULL; + axutil_property_t* property = NULL; + void* value = NULL; + int request_timeout = AXIS2_QPID_DEFAULT_REQUEST_TIMEOUT; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + if(conf_ctx) + { + property = axis2_conf_ctx_get_property(conf_ctx, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_REQUEST_TIMEOUT); + + if(property) + { + value = axutil_property_get_value(property, env); + + if(value) + { + request_timeout = *(int*)value; + } + } + } + + return request_timeout; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_amqp_util_msg_ctx_get_server_side( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env) +{ + axis2_conf_ctx_t* conf_ctx = NULL; + axis2_bool_t is_server = AXIS2_FALSE; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + if(conf_ctx) + { + is_server = axis2_amqp_util_conf_ctx_get_server_side(conf_ctx, env); + } + + return is_server; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_response_free( + axis2_amqp_response_t* response, + const axutil_env_t* env) +{ + if(response) + { + if(response->data) + { + AXIS2_FREE(env->allocator, response->data); + } + + if(response->content_type) + { + AXIS2_FREE(env->allocator, response->content_type); + } + + AXIS2_FREE(env->allocator, response); + } +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_destination_info_free( + axis2_amqp_destination_info_t* destination_info, + const axutil_env_t* env) +{ + if(destination_info) + { + if(destination_info->broker_ip) + { + AXIS2_FREE(env->allocator, destination_info->broker_ip); + } + + if(destination_info->queue_name) + { + AXIS2_FREE(env->allocator, destination_info->queue_name); + } + + AXIS2_FREE(env->allocator, destination_info); + } +} + diff --git a/src/core/transport/amqp/util/axis2_amqp_util.h b/src/core/transport/amqp/util/axis2_amqp_util.h new file mode 100644 index 0000000..0b3abbb --- /dev/null +++ b/src/core/transport/amqp/util/axis2_amqp_util.h @@ -0,0 +1,143 @@ +/* + * 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_AMQP_UTIL_H +#define AXIS2_AMQP_UTIL_H + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_amqp_response + { + void* data; + int length; + axis2_char_t* content_type; + } axis2_amqp_response_t; + + typedef struct axis2_amqp_destination_info + { + axis2_char_t* broker_ip; + int broker_port; + axis2_char_t* queue_name; + } axis2_amqp_destination_info_t; + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_amqp_util_get_in_desc_conf_value_string( + axis2_transport_in_desc_t* in_desc, + const axutil_env_t* env, + const axis2_char_t* param_name); + + AXIS2_EXTERN int AXIS2_CALL + axis2_amqp_util_get_in_desc_conf_value_int( + axis2_transport_in_desc_t* in_desc, + const axutil_env_t* env, + const axis2_char_t* param_name); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_amqp_util_get_out_desc_conf_value_string( + axis2_transport_out_desc_t* out_desc, + const axutil_env_t* env, + const axis2_char_t* param_name); + + AXIS2_EXTERN int AXIS2_CALL + axis2_amqp_util_get_out_desc_conf_value_int( + axis2_transport_out_desc_t* out_desc, + const axutil_env_t* env, + const axis2_char_t* param_name); + + AXIS2_EXTERN axiom_soap_envelope_t* AXIS2_CALL + axis2_amqp_util_get_soap_envelope( + axis2_amqp_response_t* response, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_amqp_util_conf_ctx_get_server_side( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_amqp_util_get_value_from_content_type( + const axutil_env_t * env, + const axis2_char_t * content_type, + const axis2_char_t * key); + + AXIS2_EXTERN int AXIS2_CALL + axis2_amqp_util_on_data_request( + char *buffer, + int size, + void *ctx); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_amqp_util_conf_ctx_get_dual_channel_queue_name( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_amqp_util_conf_ctx_get_qpid_broker_ip( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN int AXIS2_CALL + axis2_amqp_util_conf_ctx_get_qpid_broker_port( + axis2_conf_ctx_t* conf_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_amqp_util_msg_ctx_get_use_separate_listener( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN axis2_amqp_destination_info_t* AXIS2_CALL + axis2_amqp_util_msg_ctx_get_destination_info( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN int AXIS2_CALL + axis2_amqp_util_msg_ctx_get_request_timeout( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_amqp_util_msg_ctx_get_server_side( + axis2_msg_ctx_t* msg_ctx, + const axutil_env_t* env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_amqp_response_free( + axis2_amqp_response_t* response, + const axutil_env_t* env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_amqp_destination_info_free( + axis2_amqp_destination_info_t* destination_info, + const axutil_env_t* env); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/core/transport/http/Makefile.am b/src/core/transport/http/Makefile.am new file mode 100644 index 0000000..cc23d78 --- /dev/null +++ b/src/core/transport/http/Makefile.am @@ -0,0 +1 @@ +SUBDIRS = sender receiver server diff --git a/src/core/transport/http/common/Makefile.am b/src/core/transport/http/common/Makefile.am new file mode 100644 index 0000000..8aaa2c6 --- /dev/null +++ b/src/core/transport/http/common/Makefile.am @@ -0,0 +1,29 @@ +lib_LTLIBRARIES = libaxis2_http_common.la + +libaxis2_http_common_la_LIBADD=$(top_builddir)/util/src/libaxutil.la\ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la + +libaxis2_http_common_la_SOURCES = http_header.c\ + http_out_transport_info.c\ + http_request_line.c\ + http_simple_request.c\ + http_simple_response.c\ + http_status_line.c\ + http_accept_record.c\ + http_response_writer.c\ + simple_http_svr_conn.c\ + http_worker.c + + +libaxis2_http_common_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport\ + -I$(top_builddir)/src/core/transport/http \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/common/http_accept_record.c b/src/core/transport/http/common/http_accept_record.c new file mode 100644 index 0000000..25f15b1 --- /dev/null +++ b/src/core/transport/http/common/http_accept_record.c @@ -0,0 +1,165 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +struct axis2_http_accept_record +{ + axis2_char_t *name; + float quality; + int level; + axis2_char_t *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) +{ + axis2_char_t *tmp_accept_record = NULL; + axis2_char_t *tmp = NULL; + axis2_http_accept_record_t *accept_record = NULL; + float quality = 1.0; + int level = -1; + axis2_char_t *name = NULL; + + AXIS2_PARAM_CHECK(env->error, str, NULL); + + tmp_accept_record = (axis2_char_t *)axutil_strdup(env, str); + if(!tmp_accept_record) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "unable to strdup string %s", str); + return NULL; + } + + accept_record = (axis2_http_accept_record_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_accept_record_t)); + + if(!accept_record) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)accept_record, 0, sizeof(axis2_http_accept_record_t)); + accept_record->record = axutil_strtrim(env, tmp_accept_record, AXIS2_SPACE_COMMA); + + tmp = strchr(tmp_accept_record, AXIS2_Q); + if(tmp) + { + *tmp = AXIS2_ESC_NULL; + tmp++; + tmp = axutil_strtrim(env, tmp, AXIS2_EQ_N_SEMICOLON); + if(tmp) + { + sscanf(tmp, "%f", &quality); + AXIS2_FREE(env->allocator, tmp); + } + } + + tmp = strstr(tmp_accept_record, AXIS2_LEVEL); + if(tmp) + { + *tmp = AXIS2_ESC_NULL; + tmp++; + tmp = axutil_strtrim(env, tmp, AXIS2_EQ_N_SEMICOLON); + if(tmp) + { + sscanf(tmp, "%d", &level); + AXIS2_FREE(env->allocator, tmp); + } + } + + tmp = axutil_strtrim(env, tmp_accept_record, AXIS2_SPACE_SEMICOLON); + if(tmp) + { + name = tmp; + } + + if(!name || quality > 1.0 || quality < 0.0) + { + axis2_http_accept_record_free(accept_record, env); + return NULL; + } + + accept_record->name = name; + accept_record->quality = quality; + accept_record->level = level; + + AXIS2_FREE(env->allocator, tmp_accept_record); + return accept_record; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_accept_record_free( + axis2_http_accept_record_t * accept_record, + const axutil_env_t * env) +{ + + if(!accept_record) + { + return; + } + + if(accept_record->name) + { + AXIS2_FREE(env->allocator, accept_record->name); + } + if(accept_record->record) + { + AXIS2_FREE(env->allocator, accept_record->record); + } + AXIS2_FREE(env->allocator, accept_record); + return; +} + +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) +{ + return accept_record->quality; +} + +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) +{ + return accept_record->name; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_accept_record_get_level( + const axis2_http_accept_record_t * accept_record, + const axutil_env_t * env) +{ + return accept_record->level; +} + +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) +{ + return accept_record->record; +} diff --git a/src/core/transport/http/common/http_header.c b/src/core/transport/http/common/http_header.c new file mode 100644 index 0000000..3ea2ffc --- /dev/null +++ b/src/core/transport/http/common/http_header.c @@ -0,0 +1,168 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +struct axis2_http_header +{ + axis2_char_t *name; + axis2_char_t *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) +{ + axis2_http_header_t *http_header = NULL; + http_header = (axis2_http_header_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_http_header_t)); + if(!http_header) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)http_header, 0, sizeof(axis2_http_header_t)); + http_header->name = (axis2_char_t *)axutil_strdup(env, name); + http_header->value = (axis2_char_t *)axutil_strdup(env, value); + + return http_header; +} + +/** + * 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) +{ + axis2_char_t *tmp_str = NULL; + axis2_char_t *ch = NULL; + axis2_char_t *ch2 = NULL; + axis2_http_header_t *ret = NULL; + int tmp_str_len = 0; + AXIS2_PARAM_CHECK(env->error, str, NULL); + + /* + tmp_str = axutil_strdup(env, str); + if(!tmp_str) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "unable to strdup string, %s", str); + return NULL; + } + */ + /* + * strdup is removed to increase the performance. This method is called from + * axis2_simple_http_svr_conn_read_request and axis2_http_client_recieve_header and both of them + * passes a temporary string. hence we can modify the contents without doing a strdup. + * Above code is commented after 1.6.0 . If no issue is found until 1.8.0, above can be removed + */ + tmp_str = (axis2_char_t *)str; + + /* remove trailing \r\n */ + tmp_str_len = axutil_strlen(tmp_str); + if((tmp_str_len >= 2) && (AXIS2_RETURN == tmp_str[tmp_str_len - 2])) + { + tmp_str[tmp_str_len - 2] = AXIS2_ESC_NULL; + } + + /* get http header */ + ch = strchr((const char *)tmp_str, AXIS2_COLON); + if(!ch) + { + /*AXIS2_FREE(env->allocator, tmp_str);*/ + return NULL; + } + *ch = AXIS2_ESC_NULL; + + /* get http header value */ + ch2 = ++ch; + + /* skip spaces */ + while(AXIS2_SPACE == *ch2) + { + ++ch2; + } + + ret = axis2_http_header_create(env, tmp_str, ch2); + /*AXIS2_FREE(env->allocator, tmp_str);*/ + return ret; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_header_free( + axis2_http_header_t * http_header, + const axutil_env_t * env) +{ + + if(!http_header) + { + return; + } + + if(http_header->name) + { + AXIS2_FREE(env->allocator, http_header->name); + } + if(http_header->value) + { + AXIS2_FREE(env->allocator, http_header->value); + } + + AXIS2_FREE(env->allocator, http_header); + return; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_header_to_external_form( + axis2_http_header_t * http_header, + const axutil_env_t * env) +{ + axis2_ssize_t len = 0; + axis2_char_t *external_form = NULL; + + AXIS2_PARAM_CHECK(env->error, http_header, NULL); + + len = axutil_strlen(http_header->name) + axutil_strlen(http_header->value) + 8; + external_form = (axis2_char_t *)AXIS2_MALLOC(env->allocator, len); + sprintf(external_form, "%s: %s%s", http_header->name, http_header->value, AXIS2_HTTP_CRLF); + return external_form; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_header_get_name( + const axis2_http_header_t * http_header, + const axutil_env_t * env) +{ + return http_header->name; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_header_get_value( + const axis2_http_header_t * http_header, + const axutil_env_t * env) +{ + return http_header->value; +} diff --git a/src/core/transport/http/common/http_out_transport_info.c b/src/core/transport/http/common/http_out_transport_info.c new file mode 100644 index 0000000..b70ee6c --- /dev/null +++ b/src/core/transport/http/common/http_out_transport_info.c @@ -0,0 +1,353 @@ +/* + * 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. + */ + +#include +#include +#include +#include + +#define AXIS2_INTF_TO_IMPL(out_transport_info) \ + ((axis2_http_out_transport_info_t *) \ + (out_transport_info)) + +axis2_status_t AXIS2_CALL +axis2_out_transport_info_impl_set_content_type( + axis2_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_http_out_transport_info_t *http_transport_info = NULL; + http_transport_info = AXIS2_INTF_TO_IMPL(out_transport_info); + return axis2_http_out_transport_info_set_content_type(http_transport_info, env, content_type); +} + +axis2_status_t AXIS2_CALL +axis2_out_transport_info_impl_set_char_encoding( + axis2_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + axis2_http_out_transport_info_t *http_transport_info = NULL; + http_transport_info = AXIS2_INTF_TO_IMPL(out_transport_info); + return axis2_http_out_transport_info_set_char_encoding(http_transport_info, env, encoding); +} + +axis2_status_t AXIS2_CALL +axis2_out_transport_info_impl_set_cookie_header( + axis2_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * set_cookie) +{ + axis2_http_out_transport_info_t *http_transport_info = NULL; + http_transport_info = AXIS2_INTF_TO_IMPL(out_transport_info); + return axis2_http_out_transport_info_set_cookie_header(http_transport_info, env, set_cookie); +} + +axis2_status_t AXIS2_CALL +axis2_out_transport_info_impl_set_session( + axis2_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value) +{ + axis2_http_out_transport_info_t *http_transport_info = NULL; + http_transport_info = AXIS2_INTF_TO_IMPL(out_transport_info); + return axis2_http_out_transport_info_set_session(http_transport_info, env, session_id, + session_value); +} + +void AXIS2_CALL +axis2_out_transport_info_impl_free( + axis2_out_transport_info_t * out_transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *http_transport_info = NULL; + http_transport_info = AXIS2_INTF_TO_IMPL(out_transport_info); + axis2_http_out_transport_info_free(http_transport_info, env); + return; +} + +static const axis2_out_transport_info_ops_t ops_var = { + axis2_out_transport_info_impl_set_content_type, + axis2_out_transport_info_impl_set_char_encoding, + axis2_out_transport_info_impl_set_cookie_header, + axis2_out_transport_info_impl_set_session, + axis2_out_transport_info_impl_free }; + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_impl_set_content_type( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_char_t *tmp1 = NULL; + axis2_char_t *tmp2 = NULL; + + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + if(http_out_transport_info->encoding) + { + axis2_char_t *charset_pos = axutil_strcasestr(content_type, AXIS2_CHARSET); + if(!charset_pos) + { + /* if "charset" not found in content_type string */ + tmp1 = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_CHARSET); + tmp2 = axutil_stracat(env, tmp1, http_out_transport_info->encoding); + axis2_http_simple_response_set_header(http_out_transport_info-> response, env, + axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, tmp2)); + AXIS2_FREE(env->allocator, tmp1); + AXIS2_FREE(env->allocator, tmp2); + } + else + { + /* "charset" is found in content_type string */ + axis2_http_simple_response_set_header(http_out_transport_info-> response, env, + axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, content_type)); + } + } + else + { + /* no http_out_transport_info->encoding */ + if(http_out_transport_info->response) + { + axis2_http_simple_response_set_header(http_out_transport_info-> response, env, + axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, content_type)); + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_impl_set_char_encoding( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + if(http_out_transport_info->encoding) + { + AXIS2_FREE(env->allocator, http_out_transport_info->encoding); + } + http_out_transport_info->encoding = axutil_strdup(env, encoding); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_impl_set_cookie_header( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * set_cookie) +{ + AXIS2_PARAM_CHECK(env->error, set_cookie, AXIS2_FAILURE); + if(http_out_transport_info->response) + { + axis2_http_simple_response_set_header(http_out_transport_info-> response, env, + axis2_http_header_create(env, AXIS2_HTTP_HEADER_SET_COOKIE, set_cookie)); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_impl_set_session( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value) +{ + AXIS2_PARAM_CHECK(env->error, session_id, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, session_value, AXIS2_FAILURE); + if(http_out_transport_info->server) + { + env->set_session_fn((void *) http_out_transport_info->server, session_id, session_value); + } + return AXIS2_SUCCESS; +} +AXIS2_EXTERN void AXIS2_CALL +axis2_http_out_transport_info_impl_free( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env) +{ + + if(!http_out_transport_info) + { + return; + } + + if(http_out_transport_info->response) + { + axis2_http_simple_response_free(http_out_transport_info->response, env); + } + if(http_out_transport_info->encoding) + { + AXIS2_FREE(env->allocator, http_out_transport_info->encoding); + } + AXIS2_FREE(env->allocator, http_out_transport_info); + return; +} + +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) +{ + axis2_http_out_transport_info_t *http_out_transport_info = NULL; + + http_out_transport_info = (axis2_http_out_transport_info_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_out_transport_info_t)); + + if(!http_out_transport_info) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)http_out_transport_info, 0, sizeof(axis2_http_out_transport_info_t)); + http_out_transport_info->out_transport.ops = &ops_var; + http_out_transport_info->response = response; + http_out_transport_info->encoding = NULL; + http_out_transport_info->set_char_encoding = NULL; + http_out_transport_info->set_content_type = NULL; + http_out_transport_info->set_cookie_header = NULL; + http_out_transport_info->set_session = NULL; + http_out_transport_info->free_function = NULL; + + http_out_transport_info->set_char_encoding + = axis2_http_out_transport_info_impl_set_char_encoding; + http_out_transport_info->set_content_type = axis2_http_out_transport_info_impl_set_content_type; + http_out_transport_info->set_cookie_header = axis2_http_out_transport_info_impl_set_cookie_header; + http_out_transport_info->set_session = axis2_http_out_transport_info_impl_set_session; + http_out_transport_info->free_function = axis2_http_out_transport_info_impl_free; + + return http_out_transport_info; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_out_transport_info_free( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env) +{ + http_out_transport_info->free_function(http_out_transport_info, env); + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *transport_info_l = NULL; + + transport_info_l = AXIS2_INTF_TO_IMPL(transport_info); + axis2_http_out_transport_info_free(transport_info_l, env); + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_set_content_type( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + return http_out_transport_info->set_content_type(http_out_transport_info, env, content_type); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + return http_out_transport_info->set_char_encoding(http_out_transport_info, env, encoding); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_set_cookie_header( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * set_cookie) +{ + return http_out_transport_info->set_cookie_header(http_out_transport_info, env, set_cookie); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_out_transport_info_set_session( + axis2_http_out_transport_info_t * http_out_transport_info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value) +{ + return http_out_transport_info->set_session(http_out_transport_info, env, session_id, + session_value); +} + +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_char_encoding) + (axis2_http_out_transport_info_t *, + const axutil_env_t *, + const axis2_char_t *)) +{ + out_transport_info->set_char_encoding = set_char_encoding; +} + +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 *)) +{ + out_transport_info->set_content_type = set_content_type; +} + +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 *)) +{ + out_transport_info->set_cookie_header = set_cookie_header; +} + +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 *)) +{ + out_transport_info->set_session = set_session; +} + +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 *)) +{ + out_transport_info->free_function = free_function; +} + diff --git a/src/core/transport/http/common/http_request_line.c b/src/core/transport/http/common/http_request_line.c new file mode 100644 index 0000000..f12cbba --- /dev/null +++ b/src/core/transport/http/common/http_request_line.c @@ -0,0 +1,227 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +struct axis2_http_request_line +{ + axis2_char_t *http_version; + axis2_char_t *method; + axis2_char_t *uri; +}; + +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) +{ + axis2_http_request_line_t *request_line = NULL; + + AXIS2_PARAM_CHECK(env->error, method, NULL); + AXIS2_PARAM_CHECK(env->error, uri, NULL); + AXIS2_PARAM_CHECK(env->error, http_version, NULL); + + request_line = (axis2_http_request_line_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_request_line_t)); + + if(!request_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)request_line, 0, sizeof(axis2_http_request_line_t)); + request_line->method = (axis2_char_t *)axutil_strdup(env, method); + request_line->uri = (axis2_char_t *)axutil_strdup(env, uri); + request_line->http_version = (axis2_char_t *)axutil_strdup(env, http_version); + + return request_line; +} + +void AXIS2_CALL +axis2_http_request_line_free( + axis2_http_request_line_t * request_line, + const axutil_env_t * env) +{ + + if(!request_line) + { + return; + } + + if(request_line->method) + { + AXIS2_FREE(env->allocator, request_line->method); + } + if(request_line->uri) + { + AXIS2_FREE(env->allocator, request_line->uri); + } + if(request_line->http_version) + { + AXIS2_FREE(env->allocator, request_line->http_version); + } + + AXIS2_FREE(env->allocator, request_line); + return; +} + +/** + * 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) +{ + /*axis2_char_t *req_line = NULL;*/ + axis2_char_t *method = NULL; + axis2_char_t *uri = NULL; + axis2_char_t *http_version = NULL; + axis2_http_request_line_t *ret = NULL; + axis2_char_t *tmp = NULL; + int i = 0; + + if(!str) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid parameter is given to parse"); + return NULL; + } + + tmp = axutil_strstr(str, AXIS2_HTTP_CRLF); + if(!tmp) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + return NULL; + } + + i = (int)(tmp - str); /* We are sure that the difference lies within the int range */ + + /* + req_line = AXIS2_MALLOC(env->allocator, i * sizeof(axis2_char_t) + 1); + if(!req_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memcpy(req_line, str, i * sizeof(axis2_char_t)); + req_line[i] = AXIS2_ESC_NULL; + tmp = req_line; + */ + /* we don't need to do a malloc and memcpy, because this method is only used by + * axis2_simple_http_svr_conn_read_request and it passes a temporary string. So, we can just + * set it as req_line and set the escape characters. this is done after 1.6.0 and if no issues + * found until 1.8.0, above code comment can be removed after 1.8.0 + */ + + tmp = (axis2_char_t *)str; + tmp[i] = AXIS2_ESC_NULL; + + /* find http method */ + method = tmp; + tmp = strchr(tmp, AXIS2_SPACE); + if(!tmp) + { + /*AXIS2_FREE(env->allocator, req_line);*/ + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + return NULL; + } + *tmp++ = AXIS2_ESC_NULL; + + /* find URI */ + uri = tmp; + tmp = strrchr(tmp, AXIS2_SPACE); + if(!tmp) + { + /*AXIS2_FREE(env->allocator, req_line);*/ + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + return NULL; + } + *tmp++ = AXIS2_ESC_NULL; + + /* find HTTP version */ + http_version = tmp; + ret = axis2_http_request_line_create(env, method, uri, http_version); + /*AXIS2_FREE(env->allocator, req_line);*/ + + return ret; +} + +axis2_char_t *AXIS2_CALL +axis2_http_request_line_get_method( + const axis2_http_request_line_t * request_line, + const axutil_env_t * env) +{ + return request_line->method; +} + +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) +{ + return request_line->http_version; +} + +axis2_char_t *AXIS2_CALL +axis2_http_request_line_get_uri( + const axis2_http_request_line_t * request_line, + const axutil_env_t * env) +{ + return request_line->uri; +} + +axis2_char_t *AXIS2_CALL +axis2_http_request_line_to_string( + axis2_http_request_line_t * request_line, + const axutil_env_t * env) +{ + int alloc_len = 0; + axis2_char_t *ret = NULL; + + alloc_len = axutil_strlen(request_line->method) + axutil_strlen(request_line->uri) + + axutil_strlen(request_line->http_version) + 6; + /* 5 = 2 * spaces + '/' +CR + LF + '\0' */ + + ret = AXIS2_MALLOC(env->allocator, alloc_len * sizeof(axis2_char_t)); + if(!ret) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + if(request_line->uri[0] != AXIS2_F_SLASH) + { + sprintf(ret, "%s /%s %s%s", request_line->method, request_line->uri, + request_line->http_version, AXIS2_HTTP_CRLF); + } + else + { + sprintf(ret, "%s %s %s%s", request_line->method, request_line->uri, + request_line->http_version, AXIS2_HTTP_CRLF); + } + return ret; +} diff --git a/src/core/transport/http/common/http_response_writer.c b/src/core/transport/http/common/http_response_writer.c new file mode 100644 index 0000000..eec2422 --- /dev/null +++ b/src/core/transport/http/common/http_response_writer.c @@ -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. + */ + +#include +#include +#include +#include + +struct axis2_http_response_writer +{ + axutil_stream_t *stream; + axis2_char_t *encoding; +}; + +AXIS2_EXTERN axis2_http_response_writer_t *AXIS2_CALL +axis2_http_response_writer_create( + const axutil_env_t * env, + axutil_stream_t * stream) +{ + return axis2_http_response_writer_create_with_encoding(env, stream, + AXIS2_HTTP_DEFAULT_CONTENT_CHARSET); +} + +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) +{ + axis2_http_response_writer_t *response_writer = NULL; + response_writer = (axis2_http_response_writer_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_response_writer_t)); + if(!response_writer) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + response_writer->stream = stream; + response_writer->encoding = (axis2_char_t *)axutil_strdup(env, encoding); + return response_writer; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_response_writer_free( + axis2_http_response_writer_t * response_writer, + const axutil_env_t * env) +{ + AXIS2_FREE(env->allocator, response_writer->encoding); + AXIS2_FREE(env->allocator, response_writer); +} + +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) +{ + return response_writer->encoding; +} + +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) +{ + int write = -1; + if(!response_writer->stream) + { + return AXIS2_FAILURE; + } + + write = axutil_stream_write(response_writer->stream, env, &c, 1); + if(write < 0) + { + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +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) +{ + int write = -1; + + AXIS2_PARAM_CHECK(env->error, response_writer, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, buf, AXIS2_FAILURE); + + if(!response_writer->stream) + { + return AXIS2_FAILURE; + } + write = axutil_stream_write(response_writer->stream, env, buf, len); + if(write < 0) + { + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +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) +{ + int write = -1; + int len = -1; + + len = axutil_strlen(str); + if(!response_writer->stream) + { + return AXIS2_FAILURE; + } + write = axutil_stream_write(response_writer->stream, env, str, len); + + if(write < 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "failed to write to stream string %s of length %d", str, len); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +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) +{ + axis2_char_t int_str[10]; + sprintf(int_str, "%10d", i); + return axis2_http_response_writer_print_str(response_writer, env, int_str); +} + +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) +{ + if(AXIS2_SUCCESS == axis2_http_response_writer_print_str(response_writer, env, str)) + { + return axis2_http_response_writer_print_str(response_writer, env, AXIS2_HTTP_CRLF); + } + return 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) +{ + return axis2_http_response_writer_print_str(response_writer, env, AXIS2_HTTP_CRLF); +} diff --git a/src/core/transport/http/common/http_simple_request.c b/src/core/transport/http/common/http_simple_request.c new file mode 100644 index 0000000..9e10ce1 --- /dev/null +++ b/src/core/transport/http/common/http_simple_request.c @@ -0,0 +1,433 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +struct axis2_http_simple_request +{ + axis2_http_request_line_t *request_line; + axutil_array_list_t *header_group; + axutil_stream_t *stream; + axis2_bool_t owns_stream; +}; + +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) +{ + axis2_http_simple_request_t *simple_request = NULL; + simple_request = (axis2_http_simple_request_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_simple_request_t)); + if(!simple_request) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)simple_request, 0, sizeof(axis2_http_simple_request_t)); + simple_request->request_line = request_line; + simple_request->stream = content; + + if(!(simple_request->stream)) + { + simple_request->stream = axutil_stream_create_basic(env); + if(!simple_request->stream) + { + axis2_http_simple_request_free(simple_request, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + simple_request->owns_stream = AXIS2_TRUE; + } + + if((http_hdr_count > 0) && http_headers) + { + int i = 0; + simple_request->header_group = axutil_array_list_create(env, http_hdr_count); + + for(i = 0; i < (int)http_hdr_count; i++) + /* We are sure that the difference lies within the int range */ + { + axutil_array_list_add(simple_request->header_group, env, (void *)http_headers[i]); + } + } + + return simple_request; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_simple_request_free( + axis2_http_simple_request_t * simple_request, + const axutil_env_t * env) +{ + /* free the stream only if we own it. Otherwise shouldn't free the stream + * since it belongs to the socket + */ + if(simple_request->owns_stream) + { + axutil_stream_free(simple_request->stream, env); + } + + if(simple_request->request_line) + { + axis2_http_request_line_free(simple_request->request_line, env); + } + + if(simple_request->header_group) + { + int i = 0; + axis2_http_header_t *tmp = NULL; + for(i = 0; i < axutil_array_list_size(simple_request->header_group, env); i++) + { + tmp = (axis2_http_header_t*)axutil_array_list_get(simple_request->header_group, env, i); + axis2_http_header_free(tmp, env); + } + axutil_array_list_free(simple_request->header_group, env); + } + AXIS2_FREE(env->allocator, simple_request); +} + +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) +{ + return simple_request->request_line; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, request_line, AXIS2_FAILURE); + simple_request->request_line = request_line; + return AXIS2_SUCCESS; +} + +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) +{ + int i = 0; + axis2_char_t *header_name = NULL; + int count = 0; + + AXIS2_PARAM_CHECK(env->error, name, AXIS2_FAILURE); + + if(!simple_request->header_group) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "http simple request \ +does not contain headers, unable to find: %s header", name); + return AXIS2_FALSE; + } + + count = axutil_array_list_size(simple_request->header_group, env); + + if(0 == count) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "http simple request \ +contains zero headers, unable to find: %s header", name); + return AXIS2_FALSE; + } + + for(i = 0; i < count; i++) + { + header_name = axis2_http_header_get_name((axis2_http_header_t *)axutil_array_list_get( + simple_request->header_group, env, i), env); + if(0 == axutil_strcasecmp(name, header_name)) + { + return AXIS2_TRUE; + } + } + return AXIS2_FALSE; +} + +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) +{ + return simple_request->header_group; +} + +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) +{ + axutil_array_list_t *header_group = NULL; + int i = 0; + int count = 0; + + AXIS2_PARAM_CHECK(env->error, str, NULL); + + header_group = simple_request->header_group; + if(!simple_request->header_group) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "http simple request does not contain any headers; unable to find: %s header", str); + return NULL; + } + + if(0 == axutil_array_list_size(header_group, env)) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "http simple request contain zero headers, unable to find: %s header", str); + return NULL; + } + + count = axutil_array_list_size(header_group, env); + for(i = 0; i < count; i++) + { + axis2_http_header_t *tmp_header = NULL; + axis2_char_t *tmp_name = NULL; + tmp_header = (axis2_http_header_t *)axutil_array_list_get(header_group, env, i); + tmp_name = axis2_http_header_get_name(tmp_header, env); + if(0 == axutil_strcasecmp(str, tmp_name)) + { + return tmp_header; + } + } + return NULL; +} + +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) +{ + axis2_http_header_t *tmp_header = NULL; + axis2_char_t *tmp_name = NULL; + int i = 0; + int count = 0; + axutil_array_list_t *header_group = NULL; + + AXIS2_PARAM_CHECK(env->error, str, AXIS2_FAILURE); + + header_group = simple_request->header_group; + + if(!header_group) + { + /* Even though we couldn't complete the op, we are sure that the + * requred header is no more in the request. So we can proceed without a + * problem. + */ + return AXIS2_SUCCESS; + } + + count = axutil_array_list_size(header_group, env); + + for(i = 0; i < count; i++) + { + tmp_header = (axis2_http_header_t *)axutil_array_list_get(header_group, env, i); + tmp_name = axis2_http_header_get_name(tmp_header, env); + if(0 == axutil_strcasecmp(str, tmp_name)) + { + axis2_http_header_free(tmp_header, env); + axutil_array_list_remove(header_group, env, i); + break; + } + } + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, header, AXIS2_FAILURE); + + if(!simple_request->header_group) + { + simple_request->header_group = axutil_array_list_create(env, 1); + } + return axutil_array_list_add(simple_request->header_group, env, header); +} + +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) +{ + axis2_http_header_t *tmp_header = NULL; + + tmp_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(tmp_header) + { + return axis2_http_header_get_value(tmp_header, env); + } + + return AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN; +} + +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) +{ + axis2_http_header_t *tmp_header = NULL; + + tmp_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(tmp_header) + { + axis2_char_t *value = axis2_http_header_get_value(tmp_header, env); + axis2_char_t *charset = (axis2_char_t *)strstr((char *)value, + (char *)AXIS2_HTTP_CHAR_SET_ENCODING); + if(charset) + { + charset = strchr((char *)charset, AXIS2_EQ); + return charset; + } + } + + return AXIS2_HTTP_DEFAULT_CONTENT_CHARSET; +} + +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) +{ + axis2_http_header_t *tmp_header = NULL; + int error_return = -1; + + tmp_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH); + if(tmp_header) + { + return AXIS2_ATOI(axis2_http_header_get_value(tmp_header, env)); + } + return error_return; +} + +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) +{ + return simple_request->stream; +} + +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) +{ + axutil_stream_t *body = NULL; + char *tmp_buf = NULL; + char *tmp_buf2 = NULL; + char *tmp_buf3 = NULL; + int length = 0; + int read_len = 0; + + body = simple_request->stream; + if(!body) + { + *buf = (char *)AXIS2_MALLOC(env->allocator, 1); + *buf[0] = '\0'; + return 0; + } + + length = axis2_http_simple_request_get_content_length(simple_request, env); + if(length > 0) + { + *buf = (char *)AXIS2_MALLOC(env->allocator, length + 1); + read_len = axutil_stream_read(body, env, *buf, length + 1); + return read_len; + } + + tmp_buf2 = AXIS2_MALLOC(env->allocator, 128 * sizeof(char)); + while(axutil_stream_read(body, env, tmp_buf2, 128) > 0) + { + tmp_buf3 = axutil_stracat(env, tmp_buf, tmp_buf2); + if(tmp_buf) + { + AXIS2_FREE(env->allocator, tmp_buf); + tmp_buf = NULL; + } + tmp_buf = tmp_buf3; + + } + + if(tmp_buf2) + { + AXIS2_FREE(env->allocator, tmp_buf2); + tmp_buf2 = NULL; + } + + if(tmp_buf) + { + *buf = tmp_buf; + return axutil_strlen(tmp_buf); + } + + *buf = (char *)AXIS2_MALLOC(env->allocator, 1); + *buf[0] = AXIS2_ESC_NULL; + return 0; +} + +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) +{ + axutil_stream_t *body_stream = NULL; + + AXIS2_PARAM_CHECK(env->error, str, AXIS2_FAILURE); + + body_stream = simple_request->stream; + if(!body_stream) + { + body_stream = axutil_stream_create_basic(env); + if(!body_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "unable to create stream\ +for stream %s of %d length", (axis2_char_t *)str, str_len); + return AXIS2_FAILURE; + } + simple_request->stream = body_stream; + simple_request->owns_stream = AXIS2_TRUE; + } + + axutil_stream_write(body_stream, env, str, str_len); + return AXIS2_SUCCESS; +} diff --git a/src/core/transport/http/common/http_simple_response.c b/src/core/transport/http/common/http_simple_response.c new file mode 100644 index 0000000..74acb80 --- /dev/null +++ b/src/core/transport/http/common/http_simple_response.c @@ -0,0 +1,615 @@ +/* + * 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. + */ +#include +#include +#include +#include +#include +#include +#include + +#define AXIS2_HTTP_SIMPLE_RESPONSE_READ_SIZE 2048 + +struct axis2_http_simple_response +{ + axis2_http_status_line_t *status_line; + axutil_array_list_t *header_group; + axutil_stream_t *stream; + axutil_array_list_t *mime_parts; + axis2_char_t *mtom_sending_callback_name; +}; + +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) +{ + axis2_http_simple_response_t *ret = NULL; + ret = axis2_http_simple_response_create_default(env); + if(!ret) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2 http simple response creation failed"); + return NULL; + } + + ret->status_line = status_line; + if(http_hdr_count > 0 && http_headers) + { + int i = 0; + ret->header_group = axutil_array_list_create(env, http_hdr_count); + + for(i = 0; i < (int)http_hdr_count; i++) + /* We are sure that the difference lies within the int range */ + { + axutil_array_list_add(ret->header_group, env, (void *)http_headers[i]); + } + } + ret->stream = content; + return ret; +} + +AXIS2_EXTERN axis2_http_simple_response_t *AXIS2_CALL +axis2_http_simple_response_create_default( + const axutil_env_t * env) +{ + axis2_http_simple_response_t *simple_response = NULL; + simple_response = (axis2_http_simple_response_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_simple_response_t)); + if(!simple_response) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)simple_response, 0, sizeof(axis2_http_simple_response_t)); + return simple_response; +} + +void AXIS2_CALL +axis2_http_simple_response_free( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + if(simple_response->status_line) + { + axis2_http_status_line_free(simple_response->status_line, env); + } + + if(simple_response->header_group) + { + int i = 0; + for(i = 0; i < axutil_array_list_size(simple_response->header_group, env); i++) + { + void *tmp = NULL; + tmp = axutil_array_list_get(simple_response-> header_group, env, i); + if(tmp) + { + axis2_http_header_free((axis2_http_header_t *)tmp, env); + } + } + axutil_array_list_free(simple_response->header_group, env); + } + + if(simple_response->mime_parts) + { + int i = 0; + for(i = 0; i < axutil_array_list_size(simple_response->mime_parts, env); i++) + { + void *mime_part = NULL; + mime_part = axutil_array_list_get(simple_response->mime_parts, env, i); + if(mime_part) + { + axiom_mime_part_free((axiom_mime_part_t *)mime_part, env); + } + } + axutil_array_list_free(simple_response->mime_parts, env); + } + + /* Stream is not freed. Assumption : stream doesn't belong to the response */ + + AXIS2_FREE(env->allocator, simple_response); +} + +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) +{ + if(!http_ver || !phrase || !status_code) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "invalid parameter given"); + return AXIS2_FAILURE; + } + + if(simple_response->status_line) + { + axis2_http_status_line_free(simple_response->status_line, env); + } + + simple_response->status_line = axis2_http_status_line_create_with_values( + env, http_ver, status_code, phrase); + if(!simple_response->status_line) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "http status line creation failed for string %s %3d %s", http_ver, status_code, phrase); + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +axis2_char_t *AXIS2_CALL +axis2_http_simple_response_get_phrase( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + if(!(simple_response->status_line)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2 simple response , status line is not available"); + return NULL; + } + + return axis2_http_status_line_get_reason_phrase(simple_response-> status_line, env); +} + +int AXIS2_CALL +axis2_http_simple_response_get_status_code( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + if(!(simple_response->status_line)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2 simple response , status line is not available"); + return -1; + } + return axis2_http_status_line_get_status_code(simple_response->status_line, env); +} + +axis2_char_t *AXIS2_CALL +axis2_http_simple_response_get_http_version( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + if(!(simple_response->status_line)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2 simple response , status line is not available"); + + return NULL; + } + return axis2_http_status_line_get_http_version(simple_response->status_line, env); +} + +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) +{ + if(!(simple_response->status_line)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2 simple response , status line is not available"); + + return AXIS2_FAILURE; + } + axis2_http_status_line_set_http_version(simple_response->status_line, env, http_version); + return AXIS2_SUCCESS; +} + +axis2_char_t *AXIS2_CALL +axis2_http_simple_response_get_status_line( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + + if(!(simple_response->status_line)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2 simple response , status line is not available"); + + return NULL; + } + return axis2_http_status_line_to_string(simple_response->status_line, env); +} + +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) +{ + return simple_response->header_group; +} + +axutil_array_list_t *AXIS2_CALL +axis2_http_simple_response_extract_headers( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + axutil_array_list_t *temp = NULL; + temp = simple_response->header_group; + if(temp) + { + simple_response->header_group = NULL; + } + return temp; +} + +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) +{ + axis2_http_header_t *tmp_header = NULL; + axis2_char_t *tmp_name = NULL; + int i = 0; + int count = 0; + axutil_array_list_t *header_group = NULL; + + AXIS2_PARAM_CHECK(env->error, str, NULL); + + header_group = simple_response->header_group; + if(!simple_response->header_group) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2 simple response , headers not available"); + return NULL; + } + + if(0 == axutil_array_list_size(header_group, env)) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "axis2 simple response , contains zero headers"); + + return NULL; + } + + count = axutil_array_list_size(header_group, env); + + for(i = 0; i < count; i++) + { + tmp_header = (axis2_http_header_t *)axutil_array_list_get(header_group, env, i); + tmp_name = axis2_http_header_get_name(tmp_header, env); + if(0 == axutil_strcasecmp(str, tmp_name)) + { + return tmp_header; + } + } + return NULL; + +} + +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) +{ + axutil_array_list_t *header_group = NULL; + int i = 0; + int count = 0; + + AXIS2_PARAM_CHECK(env->error, str, AXIS2_FAILURE); + + header_group = simple_response->header_group; + if(!header_group) + { + /* Even though we couldn't complete the op, we are sure that the + * required header is no more in the request. So we can proceed without a + * problem. + */ + return AXIS2_SUCCESS; + } + + count = axutil_array_list_size(header_group, env); + for(i = 0; i < count; i++) + { + axis2_http_header_t *tmp_header = NULL; + axis2_char_t *tmp_name = NULL; + tmp_header = (axis2_http_header_t *)axutil_array_list_get(header_group, env, i); + tmp_name = axis2_http_header_get_name(tmp_header, env); + if(0 == axutil_strcasecmp(str, tmp_name)) + { + axis2_http_header_free(tmp_header, env); + axutil_array_list_remove(header_group, env, i); + break; + } + } + return AXIS2_SUCCESS; +} + +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) +{ + int i = 0; + int count = 0; + axutil_array_list_t *header_group = NULL; + + AXIS2_PARAM_CHECK(env->error, header, AXIS2_FAILURE); + + if(!simple_response->header_group) + { + simple_response->header_group = axutil_array_list_create(env, 10); + axutil_array_list_add(simple_response->header_group, env, header); + return AXIS2_SUCCESS; + } + + /* If a header with the same name exists search and remove the old header */ + header_group = simple_response->header_group; + count = axutil_array_list_size(header_group, env); + for(i = 0; i < count; i++) + { + axis2_http_header_t *tmp_header = NULL; + axis2_char_t *tmp_name = NULL; + tmp_header = (axis2_http_header_t *)axutil_array_list_get(header_group, env, i); + tmp_name = axis2_http_header_get_name(tmp_header, env); + if(0 == axutil_strcasecmp(axis2_http_header_get_name(header, env), tmp_name)) + { + axis2_http_header_free(tmp_header, env); + axutil_array_list_set(header_group, env, i, header); + return AXIS2_SUCCESS; + } + } + + /* if header is not found, then we have to add it */ + axutil_array_list_add(header_group, env, header); + return AXIS2_SUCCESS; +} + +const axis2_char_t *AXIS2_CALL +axis2_http_simple_response_get_charset( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + axis2_http_header_t *tmp_header = NULL; + + tmp_header = axis2_http_simple_response_get_first_header(simple_response, env, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(tmp_header) + { + axis2_char_t *value = axis2_http_header_get_value(tmp_header, env); + axis2_char_t *charset = (axis2_char_t *)strstr((char *)value, + (char *)AXIS2_HTTP_CHAR_SET_ENCODING); + if(charset) + { + charset = strchr((char *)charset, AXIS2_EQ); + return charset; + } + } + + return AXIS2_HTTP_DEFAULT_CONTENT_CHARSET; +} + +axis2_ssize_t AXIS2_CALL +axis2_http_simple_response_get_content_length( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + axis2_http_header_t *tmp_header = NULL; + int error_return = -1; + + tmp_header = axis2_http_simple_response_get_first_header(simple_response, env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH); + if(tmp_header) + { + return AXIS2_ATOI(axis2_http_header_get_value(tmp_header, env)); + } + return error_return; +} + +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) +{ + axis2_http_header_t *tmp_header = NULL; + + tmp_header = axis2_http_simple_response_get_first_header(simple_response, env, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(tmp_header) + { + return axis2_http_header_get_value(tmp_header, env); + } + + return AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN; +} + +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) +{ + axutil_stream_t *body_stream = NULL; + + AXIS2_PARAM_CHECK(env->error, str, AXIS2_FAILURE); + + body_stream = simple_response->stream; + if(!body_stream) + { + body_stream = axutil_stream_create_basic(env); + if(!body_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "unable to create basic stream for string %s", + str); + return AXIS2_FAILURE; + } + simple_response->stream = body_stream; + } + axutil_stream_write(body_stream, env, str, axutil_strlen(str)); + return AXIS2_SUCCESS; +} + +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) +{ + /* + * We don't free the stream + * Problem in freeing is most of the time the stream doesn't belong + * to the http_simple_response + */ + simple_response->stream = stream; + return AXIS2_SUCCESS; +} + +axutil_stream_t *AXIS2_CALL +axis2_http_simple_response_get_body( + axis2_http_simple_response_t * simple_response, + const axutil_env_t * env) +{ + return simple_response->stream; +} + +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 ** buffer) +{ + axutil_stream_t *tmp_stream = NULL; + axis2_bool_t loop_state = AXIS2_TRUE; + int return_size = -1; + + if(!simple_response->stream) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_BODY, AXIS2_FAILURE); + return return_size; + } + tmp_stream = axutil_stream_create_basic(env); + while(loop_state) + { + int read = 0; + int write = 0; + char buf[AXIS2_HTTP_SIMPLE_RESPONSE_READ_SIZE]; + + read = axutil_stream_read(simple_response->stream, env, buf, + AXIS2_HTTP_SIMPLE_RESPONSE_READ_SIZE); + if(read < 0) + { + break; + } + write = axutil_stream_write(tmp_stream, env, buf, read); + if(read < (AXIS2_HTTP_SIMPLE_RESPONSE_READ_SIZE - 1)) + { + break; + } + } + return_size = axutil_stream_get_len(tmp_stream, env); + + if(return_size > 0) + { + *buffer = (char *)AXIS2_MALLOC(env->allocator, sizeof(char) * (return_size + 1)); + + if(!buffer) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return -1; + } + + return_size = axutil_stream_read(tmp_stream, env, *buffer, return_size + 1); + } + axutil_stream_free(tmp_stream, env); + return return_size; +} + +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) +{ + axis2_char_t *header_name = NULL; + int count = 0; + int i = 0; + + AXIS2_PARAM_CHECK(env->error, name, AXIS2_FAILURE); + if(!simple_response->header_group) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2 simple response , headers not available"); + return AXIS2_FALSE; + } + + count = axutil_array_list_size(simple_response->header_group, env); + if(0 == count) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "axis2 simple response , contains zero headers"); + return AXIS2_FALSE; + } + + for(i = 0; i < count; i++) + { + axis2_http_header_t *header = (axis2_http_header_t *)axutil_array_list_get( + simple_response->header_group, env, i); + header_name = axis2_http_header_get_name(header, env); + if(0 == axutil_strcasecmp(name, header_name)) + { + return AXIS2_TRUE; + } + } + return AXIS2_FALSE; +} + +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) +{ + + return simple_response->mime_parts; + +} + +void AXIS2_EXTERN 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) +{ + + simple_response->mime_parts = mime_parts; + +} + +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) +{ + return simple_response->mtom_sending_callback_name; +} + +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) +{ + simple_response->mtom_sending_callback_name = + mtom_sending_callback_name; +} diff --git a/src/core/transport/http/common/http_status_line.c b/src/core/transport/http/common/http_status_line.c new file mode 100644 index 0000000..fdf0fea --- /dev/null +++ b/src/core/transport/http/common/http_status_line.c @@ -0,0 +1,267 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +struct axis2_http_status_line +{ + axis2_char_t *line; + axis2_char_t *http_version; + axis2_char_t *status_code; + axis2_char_t *reason_phrase; +}; + +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_char_t *tmp_status_line = NULL; + axis2_char_t *reason_phrase = NULL; + axis2_char_t *status_code = NULL; + axis2_char_t *http_version = NULL; + int i = 0; + axis2_char_t *tmp = NULL; + axis2_http_status_line_t *status_line = NULL; + + status_line = (axis2_http_status_line_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_status_line_t)); + + if(!status_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)status_line, 0, sizeof(axis2_http_status_line_t)); + status_line->line = (axis2_char_t *)axutil_strdup(env, str); + + /* extract status code, phrase and version from given string */ + tmp = strstr(str, AXIS2_HTTP_CRLF); + if(!tmp) + { + axis2_http_status_line_free(status_line, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + return NULL; + } + + i = (int)(tmp - str); /* We are sure that the difference lies within the int range */ + + tmp_status_line = AXIS2_MALLOC(env->allocator, i * sizeof(axis2_char_t) + 1); + if(!tmp_status_line) + { + axis2_http_status_line_free(status_line, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memcpy(tmp_status_line, str, i * sizeof(axis2_char_t)); + tmp_status_line[i] = AXIS2_ESC_NULL; + tmp = tmp_status_line; + + /* get HTTP version */ + http_version = tmp; + tmp = strchr(tmp, AXIS2_SPACE); + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_status_line); + axis2_http_status_line_free(status_line, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + return NULL; + } + *tmp++ = AXIS2_ESC_NULL; + + /* get status code */ + status_code = tmp; + tmp = strchr(tmp, AXIS2_SPACE); + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_status_line); + axis2_http_status_line_free(status_line, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + return NULL; + } + *tmp++ = AXIS2_ESC_NULL; + + /* get reason phrase */ + reason_phrase = tmp; + + /* populate values */ + status_line->http_version = (axis2_char_t *)axutil_strdup(env, http_version); + status_line->status_code = (axis2_char_t *)axutil_strdup(env, status_code); + status_line->reason_phrase = (axis2_char_t *)axutil_strdup(env, reason_phrase); + AXIS2_FREE(env->allocator, tmp_status_line); + + if(!status_line->http_version || !status_line->reason_phrase || !status_line->status_code) + { + axis2_http_status_line_free(status_line, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return status_line; +} + +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_http_status_line_t *status_line = NULL; + status_line = (axis2_http_status_line_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_status_line_t)); + if(!status_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)status_line, 0, sizeof(axis2_http_status_line_t)); + + status_line->status_code = AXIS2_MALLOC(env->allocator, 6 * sizeof(axis2_char_t *)); + if(!status_line->status_code) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + axis2_http_status_line_free(status_line, env); + return NULL; + } + sprintf(status_line->status_code, "%3d", status_code); + + status_line->http_version = axutil_strdup(env, http_ver); + status_line->reason_phrase = axutil_strdup(env, phrase); + if(!status_line->http_version || !status_line->reason_phrase) + { + axis2_http_status_line_free(status_line, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + status_line->line = axutil_strcat(env, http_ver, " ", status_line->status_code, " ", phrase, + AXIS2_HTTP_CRLF, NULL); + if(!status_line->line) + { + axis2_http_status_line_free(status_line, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return status_line; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_status_line_free( + axis2_http_status_line_t * status_line, + const axutil_env_t * env) +{ + + if(!status_line) + { + return; + } + + if(status_line->line) + { + AXIS2_FREE(env->allocator, status_line->line); + } + if(status_line->http_version) + { + AXIS2_FREE(env->allocator, status_line->http_version); + } + if(status_line->status_code) + { + AXIS2_FREE(env->allocator, status_line->status_code); + } + if(status_line->reason_phrase) + { + AXIS2_FREE(env->allocator, status_line->reason_phrase); + } + + AXIS2_FREE(env->allocator, status_line); + return; +} + +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) +{ + if(status_line->status_code) + { + return AXIS2_ATOI(status_line->status_code); + } + else + { + return AXIS2_CRITICAL_FAILURE; + } + +} + +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) +{ + return status_line->http_version; +} + +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) +{ + if(status_line->http_version) + { + AXIS2_FREE(env->allocator, status_line->http_version); + status_line->http_version = NULL; + } + + status_line->http_version = (axis2_char_t *)axutil_strdup(env, http_version); + +} + +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) +{ + return status_line->reason_phrase; +} + +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) +{ + if(0 == axutil_strncasecmp(status_line->line, AXIS2_HTTP, 4)) + { + return AXIS2_TRUE; + } + return AXIS2_FALSE; +} + +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) +{ + return status_line->line; +} diff --git a/src/core/transport/http/common/http_worker.c b/src/core/transport/http/common/http_worker.c new file mode 100644 index 0000000..26ccce3 --- /dev/null +++ b/src/core/transport/http/common/http_worker.c @@ -0,0 +1,2064 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_http_worker +{ + axis2_conf_ctx_t *conf_ctx; + int svr_port; + axis2_bool_t is_application_client_side; +}; + +static axis2_status_t +axis2_http_worker_set_response_headers( + 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, + axis2_http_simple_response_t * simple_response, + axis2_ssize_t content_length); + +static axutil_hash_t * +axis2_http_worker_get_headers( + axis2_http_worker_t * http_worker, + const axutil_env_t * env, + axis2_http_simple_request_t * request); + +static axis2_http_simple_response_t * +axis2_http_worker_create_simple_response( + axis2_http_worker_t *http_worker, + const axutil_env_t *env); + +AXIS2_EXTERN axis2_http_worker_t *AXIS2_CALL +axis2_http_worker_create( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_http_worker_t *http_worker = NULL; + + http_worker = (axis2_http_worker_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_http_worker_t)); + + if(!http_worker) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + http_worker->conf_ctx = conf_ctx; + http_worker->svr_port = 9090; /* default - must set later */ + http_worker->is_application_client_side = AXIS2_FALSE; /* default is creating for application + server side */ + + return http_worker; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_worker_free( + axis2_http_worker_t * http_worker, + const axutil_env_t * env) +{ + http_worker->conf_ctx = NULL; + AXIS2_FREE(env->allocator, http_worker); + return; +} + +/* Each in-coming request is passed into this function for process. Basically http method to deliver + * is deduced here and call appropriate http processing function. + * eg. transport_utils_process_http_post_request() function. Once this function call done it will go + * through engine inflow phases and finally hit the message receiver for the operation. + */ +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) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_msg_ctx_t *msg_ctx = NULL; + axutil_stream_t *request_body = NULL; + + /* Creating out_stream as basic stream */ + axutil_stream_t *out_stream = axutil_stream_create_basic(env); + axis2_http_simple_response_t *response = NULL; + + /* Transport in and out descriptions */ + axis2_transport_out_desc_t *out_desc = NULL; + axis2_transport_in_desc_t *in_desc = NULL; + + axis2_char_t *http_version = NULL; + axis2_char_t *soap_action = NULL; + axutil_string_t *soap_action_str = NULL; + axis2_bool_t processed = AXIS2_FALSE; + axis2_status_t status = AXIS2_FAILURE; + int content_length = -1; + axis2_http_header_t *encoding_header = NULL; + axis2_char_t *encoding_header_value = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_char_t *svr_ip = NULL; + axis2_char_t *peer_ip = NULL; + axutil_url_t *request_url = NULL; + axis2_http_out_transport_info_t *http_out_transport_info = NULL; + axutil_hash_t *headers = NULL; + axis2_char_t *url_external_form = NULL; + axis2_char_t *svc_grp_uuid = NULL; + axis2_char_t *path = NULL; + axutil_property_t *peer_property = NULL; + + /* REST processing variables */ + axis2_bool_t is_get = AXIS2_FALSE; + axis2_bool_t is_head = AXIS2_FALSE; + axis2_bool_t is_put = AXIS2_FALSE; + axis2_bool_t is_delete = AXIS2_FALSE; + axis2_bool_t request_handled = AXIS2_FALSE; + + /* HTTP and Proxy authentication */ + axis2_char_t *cookie_header_value = NULL; + /*axis2_char_t *set_cookie_header_value = NULL; + axis2_http_header_t *set_cookie_header = NULL; + axis2_http_header_t *connection_header = NULL;*/ + axis2_http_header_t *cookie_header = NULL; + axis2_char_t *accept_header_value = NULL; + axis2_http_header_t *accept_header = NULL; + axis2_char_t *accept_charset_header_value = NULL; + axis2_http_header_t *accept_charset_header = NULL; + axis2_char_t *accept_language_header_value = NULL; + axis2_http_header_t *accept_language_header = NULL; + + axis2_char_t *http_method = NULL; + axis2_http_request_line_t *request_line = NULL; + + axutil_hash_t *request_params = NULL; + axis2_char_t *request_uri = NULL; + axis2_char_t *url_ext_form = NULL; + const axis2_char_t *content_type = NULL; + + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + AXIS2_PARAM_CHECK(env->error, svr_conn, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, simple_request, AXIS2_FALSE); + + conf_ctx = http_worker->conf_ctx; + if(!conf_ctx) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); + return AXIS2_FALSE; + } + + content_length = axis2_http_simple_request_get_content_length(simple_request, env); + request_line = axis2_http_simple_request_get_request_line(simple_request, env); + http_method = axis2_http_request_line_get_method(request_line, env); + + http_version = axis2_http_request_line_get_http_version(request_line, env); + if(!http_version) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE); + return AXIS2_FALSE; + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Client HTTP version %s", http_version); + + encoding_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING); + if(encoding_header) + { + encoding_header_value = axis2_http_header_get_value(encoding_header, env); + } + + response = axis2_http_worker_create_simple_response(http_worker, env); + if(!response) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "cannot create http simple response"); + return AXIS2_FALSE; + } + + /* if length is not given and it is not chunked, then return error to client */ + if((content_length < 0) && encoding_header_value + && (0 != axutil_strcmp(encoding_header_value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))) + { + if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_POST) + || 0 == axutil_strcasecmp(http_method, AXIS2_HTTP_PUT)) + { + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_LENGTH_REQUIRED_CODE_VAL, + AXIS2_HTTP_RESPONSE_LENGTH_REQUIRED_CODE_NAME); + + status = axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + axis2_http_simple_response_free(response, env); + return status; + } + } + + request_body = axis2_http_simple_request_get_body(simple_request, env); + + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + + msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + cookie_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_COOKIE); + if(cookie_header) + { + char *session_str = NULL; + axis2_char_t *session_id = NULL; + + cookie_header_value = axis2_http_header_get_value(cookie_header, env); + session_id = axis2_http_transport_utils_get_session_id_from_cookie(env, + cookie_header_value); + if(session_id) + session_str = env->get_session_fn((void *) conf_ctx, session_id); + if(session_str) + axis2_http_transport_utils_set_session(env, msg_ctx, session_str); + } + + /*connection_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_CONNECTION); + if(connection_header) + { + axutil_property_t *connection_header_property = NULL; + axis2_char_t *connection_header_value = NULL; + connection_header_value = axis2_http_header_get_value(connection_header, env); + connection_header_property = axutil_property_create_with_args(env, + AXIS2_SCOPE_REQUEST, 0, 0, connection_header_value); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_HEADER_CONNECTION, + connection_header_property); + }*/ + + /* Server and Peer IP's */ + svr_ip = axis2_simple_http_svr_conn_get_svr_ip(svr_conn, env); + peer_ip = axis2_simple_http_svr_conn_get_peer_ip(svr_conn, env); + + if(peer_ip) + { + peer_property = axutil_property_create(env); + axutil_property_set_value(peer_property, env, axutil_strdup(env, peer_ip)); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_SVR_PEER_IP_ADDR, peer_property); + } + + path = axis2_http_request_line_get_uri(request_line, env); + + request_url = axutil_url_create(env, AXIS2_HTTP_PROTOCOL, svr_ip, http_worker->svr_port, path); + if(request_url) + { + url_external_form = axutil_url_to_external_form(request_url, env); + } + + if(!url_external_form) + { + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL, AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME); + status = axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + axis2_http_simple_response_free(response, env); + response = NULL; + return status; + } + + accept_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_ACCEPT); + if(accept_header) + { + accept_header_value = axis2_http_header_get_value(accept_header, env); + } + if(accept_header_value) + { + axutil_array_list_t *accept_header_field_list = NULL; + axutil_array_list_t *accept_record_list = NULL; + accept_header_field_list = axutil_tokenize(env, accept_header_value, AXIS2_COMMA); + if(accept_header_field_list && axutil_array_list_size(accept_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_header_field_list, env, 0); + } + while(token); + } + if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0) + { + axis2_msg_ctx_set_http_accept_record_list(msg_ctx, env, accept_record_list); + } + } + + accept_charset_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_ACCEPT_CHARSET); + if(accept_charset_header) + { + accept_charset_header_value = axis2_http_header_get_value(accept_charset_header, env); + } + if(accept_charset_header_value) + { + axutil_array_list_t *accept_charset_header_field_list = NULL; + axutil_array_list_t *accept_charset_record_list = NULL; + accept_charset_header_field_list = axutil_tokenize(env, accept_charset_header_value, + AXIS2_COMMA); + if(accept_charset_header_field_list && axutil_array_list_size( + accept_charset_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_charset_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_charset_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_charset_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_charset_header_field_list, + env, 0); + } + while(token); + } + + if(accept_charset_record_list && axutil_array_list_size(accept_charset_record_list, env) + > 0) + { + axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env, + accept_charset_record_list); + } + } + + accept_language_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE); + if(accept_language_header) + { + accept_language_header_value = axis2_http_header_get_value(accept_language_header, env); + } + + if(accept_language_header_value) + { + axutil_array_list_t *accept_language_header_field_list = NULL; + axutil_array_list_t *accept_language_record_list = NULL; + accept_language_header_field_list = axutil_tokenize(env, accept_language_header_value, + AXIS2_COMMA); + if(accept_language_header_field_list && axutil_array_list_size( + accept_language_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_language_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_language_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_language_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_language_header_field_list, + env, 0); + } + while(token); + } + if(accept_language_record_list && axutil_array_list_size(accept_language_record_list, env) + > 0) + { + axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env, + accept_language_record_list); + } + } + + /* Here out_stream is set into the in message context. out_stream is copied from in message context + * into the out message context later in core_utils_create_out_msg_ctx() function. The buffer in + * out_stream is finally filled with the soap envelope in http_transport_sender_invoke() function. + * To avoid double freeing of out_stream we reset the out message context at the end of engine + * receive function. + */ + axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream); + + headers = axis2_http_worker_get_headers(http_worker, env, simple_request); + axis2_msg_ctx_set_transport_headers(msg_ctx, env, headers); + + svc_grp_uuid = axutil_uuid_gen(env); + if(svc_grp_uuid) + { + axutil_string_t *svc_grp_uuid_str = axutil_string_create_assume_ownership(env, + &svc_grp_uuid); + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_uuid_str); + axutil_string_free(svc_grp_uuid_str, env); + } + + http_out_transport_info = axis2_http_out_transport_info_create(env, response); + axis2_msg_ctx_set_out_transport_info(msg_ctx, env, &(http_out_transport_info->out_transport)); + + if(axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_SOAP_ACTION)) + { + soap_action = axis2_http_header_get_value(axis2_http_simple_request_get_first_header( + simple_request, env, AXIS2_HTTP_HEADER_SOAP_ACTION), env); + soap_action_str = axutil_string_create(env, soap_action); + } + + if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_GET)) + { + is_get = AXIS2_TRUE; + } + else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_HEAD)) + { + is_head = AXIS2_TRUE; + } + else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_DELETE)) + { + is_delete = AXIS2_TRUE; + } + else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_PUT)) + { + is_put = AXIS2_TRUE; + } + + request_uri = axis2_http_request_line_get_uri(request_line, env); + request_params = axis2_http_transport_utils_get_request_params(env, request_uri); + url_ext_form = axutil_url_to_external_form(request_url, env); + + content_type = axis2_http_simple_request_get_content_type(simple_request, env); + + if(is_get || is_head || is_delete) + { + + if(is_get) + { + /* HTTP GET */ + processed = axis2_http_transport_utils_process_http_get_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action_str, url_ext_form, conf_ctx, + request_params); + } + else if(is_delete) + { + /* HTTP DELETE */ + processed = axis2_http_transport_utils_process_http_delete_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action_str, url_ext_form, conf_ctx, + request_params); + } + else if(is_head) + { + /* HTTP HEAD */ + processed = axis2_http_transport_utils_process_http_head_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action_str, url_ext_form, conf_ctx, + request_params); + } + + if(AXIS2_FALSE == processed) + { + axis2_http_header_t *cont_len = NULL; + axis2_http_header_t *cont_type = NULL; + axis2_char_t *body_string = NULL; + axis2_char_t *wsdl = NULL; + axis2_bool_t is_services_path = AXIS2_FALSE; + + if(!is_delete) + { + axis2_char_t *temp = NULL; + /* check whether request url have "/services" */ + temp = strstr(axutil_url_get_path(request_url, env), AXIS2_REQUEST_URL_PREFIX); + if(temp) + { + temp += strlen(AXIS2_REQUEST_URL_PREFIX); + if(*temp == AXIS2_F_SLASH) + { + temp++; + } + if(!*temp || *temp == AXIS2_Q_MARK || *temp == AXIS2_H_MARK) + { + is_services_path = AXIS2_TRUE; + } + } + + } + + /* processing request for WSDL via "?wsdl" */ + wsdl = strstr(url_external_form, AXIS2_REQUEST_WSDL); + if(is_services_path) + { + /* request for service */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_OK_CODE_VAL, AXIS2_HTTP_RESPONSE_OK_CODE_NAME); + body_string = axis2_http_transport_utils_get_services_html(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(!is_delete && wsdl) + { + /* Request is not for delete and ask for wsdl */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_OK_CODE_VAL, AXIS2_HTTP_RESPONSE_OK_CODE_NAME); + body_string = axis2_http_transport_utils_get_services_static_wsdl(env, conf_ctx, + url_external_form); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_APPLICATION_XML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + + /* Processing SVC or Operation Not found case */ + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + if(method_list && size) + { + axis2_http_header_t *allow_header = NULL; + axis2_char_t *method_list_str = NULL; + axis2_char_t *temp; + int i = 0; + method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29); + + if(!method_list_str) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FALSE); + } + + temp = method_list_str; + for(i = 0; i < size; i++) + { + if(i) + { + sprintf(temp, AXIS2_COMMA_SPACE_STR); + temp += 2; + } + sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, + i)); + temp += strlen(temp); + } + *temp = AXIS2_ESC_NULL; + + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL, + AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME); + + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + allow_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_ALLOW, + method_list_str); + axis2_http_simple_response_set_header(response, env, allow_header); + AXIS2_FREE(env->allocator, method_list_str); + } + else + { + /* 404 Not Found */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL, + AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME); + + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + } + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) + { + /* 400 Bad Request */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL, + AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME); + + body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) + { + + /* 408 , Request Time Out */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL, + AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME); + + body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) + { + /* 409, Conflict */ + + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL, AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME); + + body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) + { + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_GONE_CODE_VAL, AXIS2_HTTP_RESPONSE_GONE_CODE_NAME); + + body_string = axis2_http_transport_utils_get_gone(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) + { + /* 412 Precondition failed */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL, + AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME); + + body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) + { + /* 413 entity too large */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL, + AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME); + + body_string + = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) + { + /* 503, Service Unavailable*/ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL, + AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME); + + body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + else + { + /* 500 Internal Server Error */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL, + AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME); + + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + + if(body_string) + { + axis2_char_t str_len[10]; + if(!is_head) + { + axis2_http_simple_response_set_body_string(response, env, body_string); + } + sprintf(str_len, "%d", axutil_strlen(body_string)); + cont_len = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_LENGTH, str_len); + axis2_http_simple_response_set_header(response, env, cont_len); + } + + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, simple_request, + response, 0); + + axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + request_handled = AXIS2_TRUE; + status = AXIS2_TRUE; + } + } + else if(0 == axutil_strcasecmp(http_method, AXIS2_HTTP_POST) || is_put) + { + if(is_put) + { + axutil_property_t *property = NULL; + if(http_worker->is_application_client_side) + { + property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_TRUE, 0, + AXIS2_VALUE_TRUE); + } + else + { + property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_FALSE, + 0, AXIS2_VALUE_FALSE); + } + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE, + property); + status = axis2_http_transport_utils_process_http_put_request(env, msg_ctx, + request_body, out_stream, content_type, content_length, soap_action_str, + url_ext_form); + + } + else + { + axutil_property_t *property = NULL; + if(http_worker->is_application_client_side) + { + property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_TRUE, 0, + AXIS2_VALUE_TRUE); + } + else + { + property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_FALSE, + 0, AXIS2_VALUE_FALSE); + } + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE, + property); + status = axis2_http_transport_utils_process_http_post_request(env, msg_ctx, + request_body, out_stream, content_type, content_length, soap_action_str, + url_ext_form); + + } + if(url_ext_form) + AXIS2_FREE(env->allocator, url_ext_form); + if(AXIS2_FAILURE == status && (is_put || axis2_msg_ctx_get_doing_rest(msg_ctx, env))) + { + /* Failure Occur while processing REST */ + + axis2_http_header_t *cont_len = NULL; + axis2_http_header_t *cont_type = NULL; + axis2_char_t *body_string = NULL; + if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + if(method_list && size) + { + axis2_http_header_t *allow_header = NULL; + axis2_char_t *method_list_str = NULL; + axis2_char_t *temp; + int i = 0; + method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29); + if(!method_list_str) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FALSE); + } + + temp = method_list_str; + for(i = 0; i < size; i++) + { + if(i) + { + sprintf(temp, AXIS2_COMMA_SPACE_STR); + temp += 2; + } + sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, + i)); + temp += strlen(temp); + } + *temp = AXIS2_ESC_NULL; + + /* 405 Method Not Allowed */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL, + AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME); + + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + allow_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_ALLOW, + method_list_str); + axis2_http_simple_response_set_header(response, env, allow_header); + AXIS2_FREE(env->allocator, method_list_str); + } + else + { + /* 404 Not Found */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL, + AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME); + + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + } + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) + { + /* 400, Bad Request */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL, + AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME); + + body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) + { + /* 408, Request Timeout */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL, + AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME); + + body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) + { + /* 409, Conflict Types */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL, AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME); + + body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) + { + /* 410, Gone. Resource no longer available */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_GONE_CODE_VAL, AXIS2_HTTP_RESPONSE_GONE_CODE_NAME); + + body_string = axis2_http_transport_utils_get_gone(env, conf_ctx); + + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) + { + /*410, Precondition for the url failed */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL, + AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME); + + body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) + { + /* 413, Request entity too large */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL, + AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME); + + body_string + = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) + { + /* 513, Service Unavailable */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL, + AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME); + + body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx); + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + else + { + /* 500, Internal Server Error */ + axis2_http_simple_response_set_status_line(response, env, http_version, + AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL, + AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME); + + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + + cont_type = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + } + + if(body_string) + { + axis2_char_t str_len[10]; + if(!is_head) + { + axis2_http_simple_response_set_body_string(response, env, body_string); + } + sprintf(str_len, "%d", axutil_strlen(body_string)); + cont_len = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_LENGTH, str_len); + axis2_http_simple_response_set_header(response, env, cont_len); + } + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, simple_request, + response, 0); + axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + request_handled = AXIS2_TRUE; + status = AXIS2_TRUE; + } + else if(status == AXIS2_FAILURE) + { + axis2_msg_ctx_t *fault_ctx = NULL; + axis2_engine_t *engine = axis2_engine_create(env, conf_ctx); + axis2_http_request_line_t *req_line = NULL; + axis2_http_status_line_t *tmp_stat_line = NULL; + axis2_char_t status_line_str[100]; + axutil_property_t *http_error_property = NULL; + axis2_char_t *http_error_value = NULL; + axis2_char_t *fault_code = NULL; + int status_code = 0; + axis2_char_t *reason_phrase = NULL; + int stream_len = 0; + + if(!engine) + { + return AXIS2_FALSE; + } + + http_error_property = axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_HTTP_TRANSPORT_ERROR); + + if(http_error_property) + http_error_value = (axis2_char_t *)axutil_property_get_value(http_error_property, + env); + + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX AXIS2_COLON_STR + AXIOM_SOAP11_FAULT_CODE_SENDER; + } + else + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX AXIS2_COLON_STR + AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER; + } + + fault_ctx = axis2_engine_create_fault_msg_ctx(engine, env, msg_ctx, + fault_code, + axutil_error_get_message + (env->error)); + req_line = + axis2_http_simple_request_get_request_line(simple_request, env); + if (req_line) + { + if (!http_error_value) + { + sprintf(status_line_str, "%s %s\r\n", + http_version, + AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR); + } + else + { + sprintf(status_line_str, "%s %s", + http_version, + http_error_value); + } + } + else + { + sprintf(status_line_str, "%s %s\r\n", + AXIS2_HTTP_HEADER_PROTOCOL_11, + AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR); + } + + tmp_stat_line = axis2_http_status_line_create(env, status_line_str); + + if (!http_error_value) + { + axis2_engine_send_fault(engine, env, fault_ctx); + } + + status_code = axis2_http_status_line_get_status_code(tmp_stat_line, env); + reason_phrase = axis2_http_status_line_get_reason_phrase(tmp_stat_line, env); + + axis2_http_simple_response_set_status_line(response, env, + http_version, + status_code, + reason_phrase); + + axis2_http_simple_response_set_body_stream(response, env, + out_stream); + + stream_len = axutil_stream_get_len (out_stream, env); + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, + stream_len); + + status = axis2_simple_http_svr_conn_write_response(svr_conn, env, + response); + request_handled = AXIS2_TRUE; + if(tmp_stat_line) + { + axis2_http_status_line_free(tmp_stat_line, env); + tmp_stat_line = NULL; + } + } + } + else + { + /* Other case than, PUT, DELETE, HEAD, GET and POST */ + /* 501, Request method is not implemented */ + axis2_http_header_t *cont_len = NULL; + axis2_http_header_t *cont_type = NULL; + axis2_char_t *body_string = NULL; + axis2_http_simple_response_set_status_line( + response, env, + http_version, + AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_VAL, + AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME); + + body_string = + axis2_http_transport_utils_get_not_implemented(env, + conf_ctx); + cont_type = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + axis2_http_simple_response_set_header(response, env, cont_type); + + if (body_string) + { + axis2_char_t str_len[10]; + axis2_http_simple_response_set_body_string(response, env, + body_string); + sprintf(str_len, "%d", axutil_strlen(body_string)); + cont_len = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, + str_len); + axis2_http_simple_response_set_header(response, env, cont_len); + } + + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, 0); + axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + request_handled = AXIS2_TRUE; + status = AXIS2_TRUE; + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if (op_ctx) + { + /*axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL;*/ + axis2_char_t *language_str = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + if (out_msg_ctx) + { + language_str = axis2_msg_ctx_get_content_language(out_msg_ctx, env); + } + + if (language_str && *language_str && !request_handled) + { + axis2_http_header_t *language = NULL; + language = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_LANGUAGE, + language_str); + axis2_http_simple_response_set_header(response, env, language); + } + } + + if (!request_handled) + { + axis2_bool_t do_rest = AXIS2_FALSE; + axis2_bool_t response_written = AXIS2_FALSE; + if (is_get || is_head || is_put || is_delete || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + + if ((accept_header_value || accept_charset_header_value || + accept_language_header_value) && do_rest) + { + axis2_char_t *content_type_header_value = NULL; + axis2_http_header_t *content_type_header = NULL; + axis2_char_t *temp = NULL; + axis2_char_t *language_header_value = NULL; + axis2_http_header_t *language_header = NULL; + content_type_header = axis2_http_simple_response_get_first_header( + response, + env, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + + language_header = axis2_http_simple_response_get_first_header( + response, + env, + AXIS2_HTTP_HEADER_CONTENT_LANGUAGE); + + if (content_type_header) + { + content_type_header_value = axis2_http_header_get_value(content_type_header, + env); + } + + if (content_type_header_value) + { + temp = axutil_strdup(env, content_type_header_value); + } + + if (language_header) + { + language_header_value = axis2_http_header_get_value(language_header, + env); + } + + if (temp) + { + axis2_char_t *content_type = NULL; + axis2_char_t *char_set = NULL; + axis2_char_t *temp2 = NULL; + + temp2 = strchr(temp, AXIS2_SEMI_COLON); + if (temp2) + { + *temp2 = AXIS2_ESC_NULL; + temp2++; + char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING); + } + + if (char_set) + { + char_set = axutil_strltrim(env, char_set, AXIS2_SPACE_TAB_EQ); + } + + content_type = axutil_strtrim(env, temp, NULL); + + if (temp) + { + AXIS2_FREE(env->allocator, temp); + temp = NULL; + } + + if (content_type && accept_header_value && + !axutil_strcasestr(accept_header_value, content_type)) + { + temp2 = strchr(content_type, AXIS2_F_SLASH); + if (temp2) + { + *temp2 = AXIS2_ESC_NULL; + temp = AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * + ((int)strlen(content_type) + 3)); + if (!temp) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FALSE; + } + + sprintf(temp, "%s/*", content_type); + if (!axutil_strcasestr(accept_header_value, temp) && + !strstr(accept_header_value, AXIS2_HTTP_HEADER_ACCEPT_ALL)) + { + /* 406, Not Acceptable */ + axis2_http_header_t *cont_len = NULL; + axis2_http_header_t *cont_type = NULL; + axis2_char_t *body_string = NULL; + axis2_http_simple_response_set_status_line( + response, env, http_version, + AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL, + AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME); + + body_string = + axis2_http_transport_utils_get_not_acceptable(env, + conf_ctx); + cont_type = + axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + if (body_string) + { + axis2_char_t str_len[10]; + axis2_http_simple_response_set_body_string(response, env, + body_string); + sprintf(str_len, "%d", axutil_strlen(body_string)); + cont_len = + axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, + str_len); + + axis2_http_simple_response_set_header(response, + env, + cont_len); + } + + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, 0); + axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + request_handled = AXIS2_TRUE; + status = AXIS2_TRUE; + response_written = AXIS2_TRUE; + } + AXIS2_FREE(env->allocator, temp); + } + } + + if (content_type) + { + AXIS2_FREE(env->allocator, content_type); + } + + if (char_set) + { + temp2 = strchr(char_set, AXIS2_EQ); + } + + if (temp2) + { + ++temp2; + } + + if (char_set && accept_charset_header_value && + !axutil_strcasestr(accept_charset_header_value, char_set) && + !axutil_strcasestr(accept_charset_header_value, temp2)) + { + /* 406, Not Acceptable */ + axis2_http_header_t *cont_len = NULL; + axis2_http_header_t *cont_type = NULL; + axis2_char_t *body_string = NULL; + axis2_http_simple_response_set_status_line( + response, env, http_version, + AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL, + AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME); + body_string = + axis2_http_transport_utils_get_not_acceptable(env, + conf_ctx); + cont_type = + axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + if (body_string) + { + axis2_char_t str_len[10]; + axis2_http_simple_response_set_body_string(response, env, + body_string); + sprintf(str_len, "%d", axutil_strlen(body_string)); + cont_len = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, + str_len); + axis2_http_simple_response_set_header(response, env, cont_len); + } + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, 0); + axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + request_handled = AXIS2_TRUE; + status = AXIS2_TRUE; + response_written = AXIS2_TRUE; + } + if (char_set) + { + AXIS2_FREE(env->allocator, char_set); + } + } + + if (language_header_value) + { + if (accept_language_header_value && + !axutil_strcasestr(accept_language_header_value, + language_header_value)) + { + /* 406, Not acceptable */ + axis2_http_header_t *cont_len = NULL; + axis2_http_header_t *cont_type = NULL; + axis2_char_t *body_string = NULL; + axis2_http_simple_response_set_status_line( + response, env, http_version, + AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL, + AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME); + + body_string = + axis2_http_transport_utils_get_not_acceptable(env, + conf_ctx); + cont_type = + axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML); + + axis2_http_simple_response_set_header(response, env, cont_type); + axis2_http_simple_response_remove_headers( + response, + env, + AXIS2_HTTP_HEADER_CONTENT_LANGUAGE); + + if (body_string) + { + axis2_char_t str_len[10]; + axis2_http_simple_response_set_body_string(response, env, + body_string); + sprintf(str_len, "%d", axutil_strlen(body_string)); + cont_len = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, + str_len); + axis2_http_simple_response_set_header(response, env, cont_len); + } + + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, 0); + axis2_simple_http_svr_conn_write_response(svr_conn, env, response); + request_handled = AXIS2_TRUE; + status = AXIS2_TRUE; + response_written = AXIS2_TRUE; + } + } + } + + if (!response_written) + { + /* If in there is a soap message is to to be sent in the back channel then we go inside this + * block. Somewhere in the receiveing end axis2_op_ctx_set_response_written() function has + * been called by this time to indicate to append the message into the http back channel. + */ + if (op_ctx && axis2_op_ctx_get_response_written(op_ctx, env)) + { + if (do_rest) + { + /*axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL;*/ + + /*msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT];*/ + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + if (in_msg_ctx) + { + /* TODO: Add neccessary handling */ + } + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = + axis2_msg_ctx_get_http_output_headers(out_msg_ctx, + env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, + env); + } + while (size) + { + axis2_http_header_t *simple_header = NULL; + size--; + simple_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, + env, size); + axis2_http_simple_response_set_header(response, + env, + simple_header); + } + + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = 0; + axis2_char_t *status_code_str = NULL; + status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_CONTINUE_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_ACK_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_GONE_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME; + break; + default: + status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + status_code_str = + AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + break; + } + + axis2_http_simple_response_set_status_line(response, env, + http_version, + status_code, + status_code_str); + request_handled = AXIS2_TRUE; + } + } + } + + if (!request_handled) + { + axis2_http_simple_response_set_status_line( + response, env, http_version, + AXIS2_HTTP_RESPONSE_OK_CODE_VAL, + AXIS2_HTTP_RESPONSE_OK_CODE_NAME); + + if (!is_head) + { + /* This is where we append the message into the http back channel.*/ + axis2_http_simple_response_set_body_stream(response, env, out_stream); + } + } + } + else if (op_ctx) + { + /* If response is not written */ + if (do_rest) + { + /*axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL;*/ + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + if (in_msg_ctx) + { + /* TODO: Add neccssary handling */ + } + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = + axis2_msg_ctx_get_http_output_headers(out_msg_ctx, + env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, + env); + } + + while (size) + { + axis2_http_header_t *simeple_header = NULL; + size--; + simeple_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, + env, size); + axis2_http_simple_response_set_header(response, env, + simeple_header); + } + + if (axis2_msg_ctx_get_no_content(out_msg_ctx, env)) + { + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + axis2_char_t *status_code_str = NULL; + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME; + break; + default: + status_code = + AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL; + status_code_str = + AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_NAME; + break; + } + axis2_http_simple_response_set_status_line( + response, env, http_version, + status_code, + status_code_str); + } + else + { + /* status code not available in msg_ctx */ + axis2_http_simple_response_set_status_line( + response, env, http_version, + AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL, + AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_NAME); + } + + request_handled = AXIS2_TRUE; + } + else if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + axis2_char_t *status_code_str = NULL; + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_CONTINUE_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_OK_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_GONE_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + status_code_str = + AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME; + break; + default: + status_code = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL; + status_code_str = + AXIS2_HTTP_RESPONSE_ACK_CODE_NAME; + break; + } + axis2_http_simple_response_set_status_line( + response, env, http_version, + status_code, + status_code_str); + + request_handled = AXIS2_TRUE; + } + } + } + if (!request_handled) + { + axis2_http_simple_response_set_status_line( + response, env, http_version, + AXIS2_HTTP_RESPONSE_ACK_CODE_VAL, + AXIS2_HTTP_RESPONSE_ACK_CODE_NAME); + } + } + else + { + axis2_http_simple_response_set_status_line( + response, env, http_version, + AXIS2_HTTP_RESPONSE_ACK_CODE_VAL, + AXIS2_HTTP_RESPONSE_ACK_CODE_NAME); + } + + if (!response_written) + { + int stream_len = 0; + stream_len = axutil_stream_get_len(out_stream, env); + + /*axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, + stream_len);*/ + + /* This is where it actually write to the wire in the http back channel + * append case. */ + if(out_msg_ctx) + { + axutil_array_list_t *mime_parts = NULL; + mime_parts = axis2_msg_ctx_get_mime_parts(out_msg_ctx, env); + /* If mime_parts is there then that means we send MTOM. So + * in order to send MTOM we are enabling HTTP1.1 and cunk transfer + * encoding */ + + if(mime_parts) + { + axis2_http_header_t *transfer_enc_header = NULL; + axutil_param_t *callback_name_param = NULL; + axis2_char_t *mtom_sending_callback_name = NULL; + + /* Getting the sender callback name paramter if it is + * specified in the configuration file */ + + callback_name_param = axis2_msg_ctx_get_parameter(out_msg_ctx, env , + AXIS2_MTOM_SENDING_CALLBACK); + if(callback_name_param) + { + mtom_sending_callback_name = + (axis2_char_t *) axutil_param_get_value (callback_name_param, env); + if(mtom_sending_callback_name) + { + axis2_http_simple_response_set_mtom_sending_callback_name( + response, env, mtom_sending_callback_name); + } + } + + axis2_http_simple_response_set_mime_parts(response, env, mime_parts); + + axis2_http_simple_response_set_http_version(response, env, + AXIS2_HTTP_HEADER_PROTOCOL_11); + + transfer_enc_header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED); + + axis2_http_simple_response_set_header(response, env, + transfer_enc_header); + + /* In the chunking case content-length is zero */ + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, + 0); + } + else + { + axis2_http_worker_set_response_headers(http_worker, env, svr_conn, + simple_request, response, + stream_len); + } + } + status = axis2_simple_http_svr_conn_write_response(svr_conn, + env, + response); + } + } + } + + if (url_external_form) + { + AXIS2_FREE(env->allocator, url_external_form); + url_external_form = NULL; + } + if (op_ctx) + { + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + axis2_char_t *msg_id = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + + if (out_msg_ctx) + { + axis2_msg_ctx_free(out_msg_ctx, env); + out_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL; + } + + if (in_msg_ctx) + { + msg_id = axutil_strdup(env, axis2_msg_ctx_get_msg_id(in_msg_ctx, env)); + conf_ctx = axis2_msg_ctx_get_conf_ctx(in_msg_ctx, env); + + axis2_msg_ctx_free(in_msg_ctx, env); + in_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = NULL; + } + + if (!axis2_op_ctx_is_in_use(op_ctx, env)) + { + axis2_op_ctx_destroy_mutex(op_ctx, env); + if (conf_ctx && msg_id) + { + axis2_conf_ctx_register_op_ctx(conf_ctx, env, msg_id, NULL); + + AXIS2_FREE(env->allocator, msg_id); + } + axis2_op_ctx_free(op_ctx, env); + } + + } /* Done freeing message contexts */ + + msg_ctx = NULL; + axutil_url_free(request_url, env); + axutil_string_free(soap_action_str, env); + request_url = NULL; + return status; +} + +static axis2_status_t +axis2_http_worker_set_response_headers( + 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, + axis2_http_simple_response_t * simple_response, + axis2_ssize_t content_length) +{ + axis2_http_header_t *conn_header = NULL; + + AXIS2_PARAM_CHECK(env->error, svr_conn, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, simple_request, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, simple_response, AXIS2_FAILURE); + + if(AXIS2_FALSE == axis2_http_simple_response_contains_header(simple_response, env, + AXIS2_HTTP_HEADER_CONNECTION)) + { + conn_header = axis2_http_simple_request_get_first_header(simple_request, env, + AXIS2_HTTP_HEADER_CONNECTION); + if(conn_header) + { + axis2_char_t *value = NULL; + value = axis2_http_header_get_value(conn_header, env); + + if(0 == axutil_strcasecmp(value, AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE)) + { + /* Comment these until keep alive support is completed for simple Axis2/C server */ + /*axis2_http_header_t *header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONNECTION, AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE); + + axis2_http_simple_response_set_header(simple_response, env, header); + axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_TRUE);*/ + } + + if(0 == axutil_strcasecmp(value, AXIS2_HTTP_HEADER_CONNECTION_CLOSE)) + { + axis2_http_header_t *header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONNECTION, AXIS2_HTTP_HEADER_CONNECTION_CLOSE); + + axis2_http_simple_response_set_header(simple_response, env, header); + axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_FALSE); + } + } + else + { /* Connection Header not available */ + axis2_char_t *http_version = NULL; + http_version = axis2_http_simple_response_get_http_version(simple_response, env); + if(http_version && !axutil_strcasecmp(http_version, AXIS2_HTTP_HEADER_PROTOCOL_11)) + { + /* Comment these until keep alive support is completed for simple Axis2/C server */ + /*axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_TRUE);*/ + /* Instead add following to always send close connection header to indicate that + * we don't support http keep alive yet in simple Axis2/C server + */ + axis2_http_header_t *header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONNECTION, AXIS2_HTTP_HEADER_CONNECTION_CLOSE); + + axis2_http_simple_response_set_header(simple_response, env, header); + /*axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_FALSE);*/ + } + else + { + axis2_simple_http_svr_conn_set_keep_alive(svr_conn, env, AXIS2_FALSE); + } + } + + if(!axis2_http_simple_response_contains_header(simple_response, env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING)) + { + if(AXIS2_FALSE == axis2_http_simple_request_contains_header(simple_request, env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING)) + { + if(0 != content_length) + { + axis2_char_t content_len_str[10]; + axis2_http_header_t *content_len_hdr = NULL; + + sprintf(content_len_str, "%d", content_length); + content_len_hdr = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, content_len_str); + axis2_http_simple_response_set_header(simple_response, env, content_len_hdr); + } + } + else + { + /* Having Transfer encoding Header */ + axis2_http_header_t *transfer_enc_header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED); + + axis2_http_simple_response_set_header(simple_response, env, transfer_enc_header); + } + } + } + return AXIS2_SUCCESS; +} + +static axutil_hash_t * +axis2_http_worker_get_headers( + axis2_http_worker_t * http_worker, + const axutil_env_t * env, + axis2_http_simple_request_t * request) +{ + axutil_array_list_t *header_list = NULL; + int hdr_count = 0; + int i = 0; + axutil_hash_t *header_map = NULL; + + AXIS2_PARAM_CHECK(env->error, request, NULL); + + header_list = axis2_http_simple_request_get_headers(request, env); + if(!header_list) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "http simple request" + "doesn't contain a header list"); + return NULL; + } + hdr_count = axutil_array_list_size(header_list, env); + if(0 == hdr_count) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "http simple request , " + "header list contains zero headers"); + return NULL; + } + + for(i = 0; i < hdr_count; i++) + { + axis2_http_header_t *tmp_hdr = NULL; + tmp_hdr = axutil_array_list_get(header_list, env, i); + if(!tmp_hdr) + { + continue; + } + if(!header_map) + { + header_map = axutil_hash_make(env); + if(!header_map) + { + return NULL; + } + } + axutil_hash_set(header_map, axis2_http_header_get_name(tmp_hdr, env), + AXIS2_HASH_KEY_STRING, tmp_hdr); + } + return header_map; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_worker_set_svr_port( + axis2_http_worker_t * worker, + const axutil_env_t * env, + int port) +{ + worker->svr_port = port; + return AXIS2_SUCCESS; +} +#if 0 +static axis2_char_t * +axis2_http_worker_get_server_time( + axis2_http_worker_t * http_worker, + const axutil_env_t * env) +{ + time_t tp; + char *time_str; + tp = time(&tp); + time_str = ctime(&tp); + if(!time_str) + { + return NULL; + } + if(AXIS2_NEW_LINE == time_str[strlen(time_str) - 1]) + { + time_str[strlen(time_str) - 1] = AXIS2_ESC_NULL; + } + /* We use the ANSI C Date Format, which is Legal according to RFC2616, + * Section 3.3.1. We are not a HTTP/1.1 only server, and thus, it suffices. + */ + return time_str; +} +#endif + +static axis2_http_simple_response_t * +axis2_http_worker_create_simple_response( + axis2_http_worker_t *http_worker, + const axutil_env_t *env) +{ + axis2_http_simple_response_t *response = NULL; + response = axis2_http_simple_response_create_default(env); + if(response) + { + axis2_http_header_t *server = NULL; + axis2_http_header_t *server_date = NULL; + axis2_char_t *date_str = NULL; + char *date_str_tmp = NULL; + time_t tp; + size_t date_str_len = 0; + + /* create "Date: xxxx GMT" HTTP header */ + tp = time(&tp); + date_str_tmp = ctime(&tp); + if(!date_str_tmp) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "cannot get server time"); + return NULL; + } + + date_str_len = strlen(date_str_tmp); + if(AXIS2_NEW_LINE == date_str_tmp[date_str_len - 1]) + { + date_str_len -= 1; + date_str_tmp[date_str_len] = AXIS2_ESC_NULL; + } + /* We use the ANSI C Date Format, which is Legal according to RFC2616, + * Section 3.3.1. We are not a HTTP/1.1 only server, and thus, it suffices. + */ + + date_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (date_str_len + 5)); + if(!date_str) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + + } + sprintf(date_str, "%s GMT", date_str_tmp); + server_date = axis2_http_header_create(env, AXIS2_HTTP_HEADER_DATE, date_str); + AXIS2_FREE(env->allocator, date_str); + axis2_http_simple_response_set_header(response, env, server_date); + + /* create "Server: Axis2C/x.x.x (Simple Axis2 HTTP Server)" HTTP Header */ + server = axis2_http_header_create(env, AXIS2_HTTP_HEADER_SERVER, + AXIS2_HTTP_HEADER_SERVER_AXIS2C AXIS2_HTTP_SERVER); + axis2_http_simple_response_set_header(response, env, server); + } + return response; +} + +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) +{ + http_worker->is_application_client_side = application_client_side; +} + + diff --git a/src/core/transport/http/common/simple_http_svr_conn.c b/src/core/transport/http/common/simple_http_svr_conn.c new file mode 100644 index 0000000..a68c48e --- /dev/null +++ b/src/core/transport/http/common/simple_http_svr_conn.c @@ -0,0 +1,504 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_simple_http_svr_conn +{ + int socket; + axutil_stream_t *stream; + axis2_bool_t keep_alive; +}; + +static axis2_char_t * +axis2_simple_http_svr_conn_read_line( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env); + +AXIS2_EXTERN axis2_simple_http_svr_conn_t *AXIS2_CALL +axis2_simple_http_svr_conn_create( + const axutil_env_t * env, + int sockfd) +{ + axis2_simple_http_svr_conn_t *svr_conn = NULL; + svr_conn = (axis2_simple_http_svr_conn_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_simple_http_svr_conn_t)); + if(!svr_conn) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "server connection failed. Insufficient memory"); + return NULL; + } + + memset((void *)svr_conn, 0, sizeof(axis2_simple_http_svr_conn_t)); + svr_conn->socket = sockfd; + + if(-1 != svr_conn->socket) + { + svr_conn->stream = axutil_stream_create_socket(env, svr_conn->socket); + if(!svr_conn->stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "socket creation failed, socket %d", sockfd); + axis2_simple_http_svr_conn_free(svr_conn, env); + return NULL; + } + } + return svr_conn; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_simple_http_svr_conn_free( + axis2_simple_http_svr_conn_t *svr_conn, + const axutil_env_t * env) +{ + axis2_simple_http_svr_conn_close(svr_conn, env); + AXIS2_FREE(env->allocator, svr_conn); +} + +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) +{ + axutil_stream_free(svr_conn->stream, env); + if(-1 != svr_conn->socket) + { + axutil_network_handler_close_socket(env, svr_conn->socket); + svr_conn->socket = -1; + } + return AXIS2_SUCCESS; +} + +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) +{ + if(-1 != svr_conn->socket) + { + return AXIS2_TRUE; + } + return AXIS2_FALSE; +} + +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) +{ + svr_conn->keep_alive = keep_alive; + return AXIS2_SUCCESS; +} + +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) +{ + return svr_conn->keep_alive; +} + +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) +{ + return svr_conn->stream; +} + +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) +{ + return axis2_http_response_writer_create(env, svr_conn->stream); +} + +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) +{ + axis2_char_t* str_line = NULL; + axis2_bool_t end_of_headers = AXIS2_FALSE; + axis2_http_request_line_t *request_line = NULL; + axis2_http_simple_request_t *request = NULL; + + /* read first line of the request (which is CRLF */ + str_line = axis2_simple_http_svr_conn_read_line(svr_conn, env); + if(str_line) + { + request_line = axis2_http_request_line_parse_line(env, str_line); + AXIS2_FREE(env->allocator, str_line); + str_line = NULL; + } + + if(!request_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + return NULL; + } + request = axis2_http_simple_request_create(env, request_line, NULL, 0, svr_conn->stream); + + /* now read the headers until we find a line only having CRLF */ + while(AXIS2_FALSE == end_of_headers) + { + str_line = axis2_simple_http_svr_conn_read_line(svr_conn, env); + if(!str_line) + { + /*if nothing is read, this loop should be broken. Otherwise, going to be endless loop */ + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "reading http header failed"); + break; + } + + if(0 == axutil_strcmp(str_line, AXIS2_HTTP_CRLF)) + { + /* line contains only CRLF, so should be end of headers */ + end_of_headers = AXIS2_TRUE; + } + else + { + axis2_http_header_t *tmp_header = axis2_http_header_create_by_str(env, str_line); + if(tmp_header) + { + axis2_http_simple_request_add_header(request, env, tmp_header); + } + } + + AXIS2_FREE(env->allocator, str_line); + str_line = NULL; + } + return request; +} + +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) +{ + axis2_http_response_writer_t *response_writer = NULL; + axutil_array_list_t *headers = NULL; + axutil_stream_t *response_stream = NULL; + axis2_char_t *response_body = NULL; + int body_size = 0; + + axis2_http_header_t *enc_header = NULL; + axis2_bool_t chuked_encoding = AXIS2_FALSE; + axis2_char_t *status_line = NULL; + axis2_bool_t binary_content = AXIS2_FALSE; + axis2_char_t *content_type = NULL; + + AXIS2_PARAM_CHECK(env->error, response, AXIS2_FAILURE); + + response_writer = axis2_http_response_writer_create(env, svr_conn->stream); + if(!response_writer) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create http response writer"); + return AXIS2_FAILURE; + } + + content_type = (axis2_char_t *)axis2_http_simple_response_get_content_type(response, env); + if(content_type) + { + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED) + && strstr(content_type,AXIS2_HTTP_HEADER_ACCEPT_XOP_XML)) + { + binary_content = AXIS2_TRUE; + } + } + + enc_header = axis2_http_simple_response_get_first_header(response, env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING); + if(enc_header) + { + axis2_char_t *enc_value = axis2_http_header_get_value(enc_header, env); + if(enc_value && (0 == axutil_strcmp(enc_value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))) + { + chuked_encoding = AXIS2_TRUE; + + /* remove the content length header */ + axis2_http_simple_response_remove_headers(response, env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH); + } + } + + /* print status line */ + status_line = axis2_http_simple_response_get_status_line(response, env); + if(!status_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + axis2_http_response_writer_free(response_writer, env); + return AXIS2_FAILURE; + } + axis2_http_response_writer_print_str(response_writer, env, status_line); + + headers = axis2_http_simple_response_get_headers(response, env); + if(headers) + { + int i = 0; + int count = axutil_array_list_size(headers, env); + for(; i < count; i++) + { + axis2_http_header_t *header = + (axis2_http_header_t *)axutil_array_list_get(headers, env, i); + if(header) + { + axis2_char_t *header_ext_form = axis2_http_header_to_external_form(header, env); + axis2_http_response_writer_print_str(response_writer, env, header_ext_form); + AXIS2_FREE(env->allocator, header_ext_form); + } + } + } + + /* write empty line after http headers */ + axis2_http_response_writer_print_str(response_writer, env, AXIS2_HTTP_CRLF); + + /* write the body */ + response_stream = axis2_http_simple_response_get_body(response, env); + if(response_stream) + { + body_size = axutil_stream_get_len(response_stream, env); + response_body = axutil_stream_get_buffer(response_stream, env); + axutil_stream_flush_buffer(response_stream, env); + response_body[body_size] = AXIS2_ESC_NULL; + } + + if(body_size <= 0 && !binary_content) + { + /* no body available to write. Note that this is not an error. We might want to write only + * status information and hence, this is a valid case */ + axis2_http_response_writer_free(response_writer, env); + return AXIS2_SUCCESS; + } + + if(!chuked_encoding && !binary_content) + { + /* This sending a normal SOAP response without chunk transfer encoding */ + axis2_status_t write_stat = AXIS2_FAILURE; + write_stat = axis2_http_response_writer_println_str(response_writer, env, response_body); + if(write_stat != AXIS2_SUCCESS) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_WRITING_RESPONSE, AXIS2_FAILURE); + axis2_http_response_writer_free(response_writer, env); + return AXIS2_FAILURE; + } + } + else if(!binary_content) + { + /* Sending a normal SOAP response enabling http chunking */ + axutil_http_chunked_stream_t *chunked_stream = NULL; + int left = body_size; + chunked_stream = axutil_http_chunked_stream_create(env, svr_conn->stream); + while(left > 0) + { + int len = -1; + len = axutil_http_chunked_stream_write(chunked_stream, env, response_body, body_size); + if(len <= 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "cannot write data to chunked stream"); + axutil_http_chunked_stream_free(chunked_stream, env); + axis2_http_response_writer_free(response_writer, env); + return AXIS2_FAILURE; + } + left -= len; + } + axutil_http_chunked_stream_write_last_chunk(chunked_stream, env); + axutil_http_chunked_stream_free(chunked_stream, env); + } + else + { + /* In the MTOM case we enable chunking in order to send the attachment */ + axutil_http_chunked_stream_t *chunked_stream = NULL; + axis2_status_t write_stat = AXIS2_FAILURE; + axutil_array_list_t *mime_parts = NULL; + axis2_char_t *mtom_sending_callback_name = NULL; + + mime_parts = axis2_http_simple_response_get_mime_parts(response, env); + if(!mime_parts) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No mime parts are given"); + axis2_http_response_writer_free(response_writer, env); + return AXIS2_FAILURE; + } + + /* If the callback name is not there, then we will check whether there + * is any mime_parts which has type callback. If we found then no point + * of continuing we should return a failure */ + mtom_sending_callback_name = axis2_http_simple_response_get_mtom_sending_callback_name( + response, env); + if(!mtom_sending_callback_name) + { + if(axis2_http_transport_utils_is_callback_required(env, mime_parts)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sender callback not specified"); + axis2_http_response_writer_free(response_writer, env); + return AXIS2_FAILURE; + } + } + + chunked_stream = axutil_http_chunked_stream_create(env, svr_conn->stream); + write_stat = axis2_http_transport_utils_send_mtom_message(chunked_stream, env, mime_parts, + mtom_sending_callback_name); + axutil_http_chunked_stream_free(chunked_stream, env); + + if(write_stat != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "writing mime parts failed"); + axis2_http_response_writer_free(response_writer, env); + return AXIS2_FAILURE; + } + } + + axis2_http_response_writer_free(response_writer, env); + return AXIS2_SUCCESS; +} + +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) +{ + return axutil_network_handler_set_sock_option(env, svr_conn->socket, SO_RCVTIMEO, timeout); +} + +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) +{ + return axutil_network_handler_set_sock_option(env, svr_conn->socket, SO_SNDTIMEO, timeout); +} + +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) +{ + return axutil_network_handler_get_svr_ip(env, svr_conn->socket); +} + +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) +{ + return axutil_network_handler_get_peer_ip(env, svr_conn->socket); +} + +static axis2_char_t * +axis2_simple_http_svr_conn_read_line( + axis2_simple_http_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + axis2_char_t* str_line = NULL; + axis2_char_t tmp_buf[2048]; + int read = -1; + + /* peek for 2047 characters to verify whether it contains CRLF character */ + while((read = axutil_stream_peek_socket(svr_conn->stream, env, tmp_buf, 2048 - 1)) > 0) + { + axis2_char_t *start = tmp_buf; + axis2_char_t *end = NULL; + tmp_buf[read] = AXIS2_ESC_NULL; + end = strstr(tmp_buf, AXIS2_HTTP_CRLF); + if(end) + { + axis2_char_t *buffer = NULL; + if(str_line) + { + /* header is more than 2048 character. this is not a common case, and not optimized + * for performance (reading in a temp buffer and then strcat to get final buffer */ + buffer = tmp_buf; + } + else + { + /* header is less than 2048 characters, this is the common case. So to improve + * the performance, the buffer is malloc and then used to read the stream. */ + buffer = (axis2_char_t *)AXIS2_MALLOC(env->allocator, end - start + 3); + } + + /* read the data including CRLF (hence the size = end - start + 2) */ + read = axutil_stream_read(svr_conn->stream, env, buffer, end - start + 2); + if(read > 0) + { + buffer[read] = AXIS2_ESC_NULL; + + if(str_line) + { + axis2_char_t* tmp_str_line = NULL; + tmp_str_line = axutil_stracat(env, str_line, buffer); + if(tmp_str_line) + { + AXIS2_FREE(env->allocator, str_line); + str_line = tmp_str_line; + } + } + else + { + str_line = buffer; + } + } + else + { + /* read returns 0 or negative value, this could be an error */ + if(str_line) + { + AXIS2_FREE(env->allocator, str_line); + str_line = NULL; + } + else + { + AXIS2_FREE(env->allocator, buffer); + } + } + break; + } + else + { + /* not reached end yet */ + read = axutil_stream_read(svr_conn->stream, env, tmp_buf, 2048 - 1); + if(read > 0) + { + axis2_char_t* tmp_str_line = NULL; + tmp_buf[read] = AXIS2_ESC_NULL; + tmp_str_line = axutil_stracat(env, str_line, tmp_buf); + if(tmp_str_line) + { + if(str_line) + { + AXIS2_FREE(env->allocator, str_line); + } + str_line = tmp_str_line; + } + } + } + } + + return str_line; +} diff --git a/src/core/transport/http/receiver/Makefile.am b/src/core/transport/http/receiver/Makefile.am new file mode 100644 index 0000000..0af4e22 --- /dev/null +++ b/src/core/transport/http/receiver/Makefile.am @@ -0,0 +1,21 @@ +lib_LTLIBRARIES = libaxis2_http_receiver.la +libaxis2_http_receiver_la_LIBADD=$(top_builddir)/util/src/libaxutil.la\ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la + + +libaxis2_http_receiver_la_SOURCES = http_receiver.c\ + http_svr_thread.c + + +libaxis2_http_receiver_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport\ + -I$(top_builddir)/src/core/transport/http \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/receiver/http_receiver.c b/src/core/transport/http/receiver/http_receiver.c new file mode 100644 index 0000000..c8517b0 --- /dev/null +++ b/src/core/transport/http/receiver/http_receiver.c @@ -0,0 +1,508 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +/** + * @brief HTTP Client struct impl + * Axis2 HTTP Client impl + */ + +typedef struct axis2_http_server_impl +{ + axis2_transport_receiver_t http_server; + axis2_http_svr_thread_t *svr_thread; + int port; + axis2_char_t *svr_ip; + axis2_conf_ctx_t *conf_ctx; + axis2_conf_ctx_t *conf_ctx_private; + axis2_bool_t is_application_client_side; +} axis2_http_server_impl_t; + +#define AXIS2_INTF_TO_IMPL(http_server) \ + ((axis2_http_server_impl_t *)(http_server)) + +/***************************** Function headers *******************************/ + +static axis2_status_t AXIS2_CALL +axis2_http_server_init( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_in_desc_t * in_desc); + +static axis2_status_t AXIS2_CALL +axis2_http_server_start( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_http_server_stop( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +static axis2_conf_ctx_t *AXIS2_CALL +axis2_http_server_get_conf_ctx( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +static axis2_endpoint_ref_t *AXIS2_CALL +axis2_http_server_get_reply_to_epr( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name); + +static axis2_endpoint_ref_t *AXIS2_CALL +axis2_http_server_get_epr_for_service( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name); + +static axis2_bool_t AXIS2_CALL +axis2_http_server_is_running( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +static void AXIS2_CALL +axis2_http_server_set_is_application_client_side( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_bool_t is_application_client_side); + +static void AXIS2_CALL +axis2_http_server_free( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +static axis2_char_t* AXIS2_CALL +axis2_http_server_get_server_ip( +axis2_transport_receiver_t *transport_receiver, +const axutil_env_t *env); + +static void AXIS2_CALL +axis2_http_server_set_server_ip( +axis2_transport_receiver_t *transport_receiver, +const axutil_env_t *env, + axis2_char_t *serverip); + +static const axis2_transport_receiver_ops_t http_transport_receiver_ops_var = { + axis2_http_server_init, + axis2_http_server_start, + axis2_http_server_get_reply_to_epr, + axis2_http_server_get_epr_for_service, + axis2_http_server_get_server_ip, + axis2_http_server_set_server_ip, + axis2_http_server_get_conf_ctx, + axis2_http_server_is_running, + axis2_http_server_set_is_application_client_side, + axis2_http_server_stop, + axis2_http_server_free }; + +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_http_server_impl_t *server_impl = NULL; + + server_impl = (axis2_http_server_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_server_impl_t)); + + if(!server_impl) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + server_impl->svr_thread = NULL; + server_impl->conf_ctx = NULL; + server_impl->conf_ctx_private = NULL; + server_impl->port = port; + server_impl->svr_ip = NULL; + server_impl->is_application_client_side = AXIS2_FALSE; + + server_impl->http_server.ops = &http_transport_receiver_ops_var; + + if(repo) + { + axis2_transport_in_desc_t *transport_in = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_receiver_t *receiver = NULL; + /** + * We first create a private conf ctx which is owned by this server + * we only free this private conf context. We should never free the + * server_impl->conf_ctx because it may own to any other object which + * may lead to double free + */ + server_impl->conf_ctx_private = axis2_build_conf_ctx(env, repo); + + if(!server_impl->conf_ctx_private) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "unable to create private configuration context for repo path %s", repo); + axis2_http_server_free((axis2_transport_receiver_t *)server_impl, env); + return NULL; + } + conf = axis2_conf_ctx_get_conf(server_impl->conf_ctx_private, env); + transport_in = axis2_conf_get_transport_in(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + receiver = axis2_transport_in_desc_get_recv(transport_in, env); + AXIS2_INTF_TO_IMPL(receiver)->port = port; + + server_impl->conf_ctx = server_impl->conf_ctx_private; + } + + return &(server_impl->http_server); +} + +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_http_server_impl_t *server_impl = NULL; + + server_impl = (axis2_http_server_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_server_impl_t)); + + if(!server_impl) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + server_impl->svr_thread = NULL; + server_impl->conf_ctx = NULL; + server_impl->conf_ctx_private = NULL; + server_impl->port = port; + server_impl->svr_ip = NULL; + server_impl->http_server.ops = &http_transport_receiver_ops_var; + + if(file) + { + axis2_transport_in_desc_t *transport_in = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_receiver_t *receiver = NULL; + /** + * We first create a private conf ctx which is owned by this server + * we only free this private conf context. We should never free the + * server_impl->conf_ctx because it may own to any other object which + * may lead to double free + */ + server_impl->conf_ctx_private = axis2_build_conf_ctx_with_file(env, file); + + if(!server_impl->conf_ctx_private) + { + axis2_http_server_free((axis2_transport_receiver_t *)server_impl, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "unable to create configuration context for file %s", file); + return NULL; + } + conf = axis2_conf_ctx_get_conf(server_impl->conf_ctx_private, env); + transport_in = axis2_conf_get_transport_in(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + receiver = axis2_transport_in_desc_get_recv(transport_in, env); + AXIS2_INTF_TO_IMPL(receiver)->port = port; + + + server_impl->conf_ctx = server_impl->conf_ctx_private; + } + + return &(server_impl->http_server); +} + +static void AXIS2_CALL +axis2_http_server_free( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + axis2_http_server_impl_t *server_impl = NULL; + + if(!server) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failure, server value is null , nothing to free"); + return; + } + + server_impl = AXIS2_INTF_TO_IMPL(server); + if(server_impl->svr_thread) + { + axis2_http_svr_thread_destroy(server_impl->svr_thread, env); + axis2_http_svr_thread_free(server_impl->svr_thread, env); + server_impl->svr_thread = NULL; + } + + if(server_impl->conf_ctx_private) + { + axis2_conf_ctx_free(server_impl->conf_ctx_private, env); + server_impl->conf_ctx_private = NULL; + } + + /** + * Do not free this. It may own to some other object + */ + server_impl->conf_ctx = NULL; + + AXIS2_FREE(env->allocator, server_impl); +} + +static axis2_status_t AXIS2_CALL +axis2_http_server_init( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_in_desc_t * in_desc) +{ + axis2_http_server_impl_t *server_impl = NULL; + axis2_char_t *port_str = NULL; + axutil_param_t *param = NULL; + + AXIS2_PARAM_CHECK(env->error, server, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, in_desc, AXIS2_FAILURE); + + server_impl = AXIS2_INTF_TO_IMPL(server); + + server_impl->conf_ctx = conf_ctx; + param = (axutil_param_t *)axutil_param_container_get_param( + axis2_transport_in_desc_param_container(in_desc, env), env, AXIS2_PORT_STRING); + if(param) + { + port_str = axutil_param_get_value(param, env); + } + + if(port_str) + { + server_impl->port = atoi(port_str); + } + return AXIS2_SUCCESS; +} + +static axis2_status_t AXIS2_CALL +axis2_http_server_start( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + axis2_http_server_impl_t *server_impl = NULL; + axis2_http_worker_t *worker = NULL; + + server_impl = AXIS2_INTF_TO_IMPL(server); + server_impl->svr_thread = axis2_http_svr_thread_create(env, server_impl->port); + if(!server_impl->svr_thread) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "unable to create server thread for port %d", + server_impl->port); + return AXIS2_FAILURE; + } + + worker = axis2_http_worker_create(env, server_impl->conf_ctx); + if(!worker) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2 http worker creation failed"); + axis2_http_svr_thread_free(server_impl->svr_thread, env); + return AXIS2_FAILURE; + } + axis2_http_worker_set_is_application_client_side(worker, env, + server_impl->is_application_client_side); + axis2_http_worker_set_svr_port(worker, env, server_impl->port); + {/** Obtain server IP and set it + axis2_transport_in_desc_t *transport_in = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_receiver_t *receiver = NULL; + conf = axis2_conf_ctx_get_conf(server_impl->conf_ctx_private, env); + transport_in = axis2_conf_get_transport_in(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + receiver = axis2_transport_in_desc_get_recv(transport_in, env); + if(receiver) + { + int listen_socket = axis2_http_svr_thread_get_listen_socket(server_impl->svr_thread, env); + server_impl->svr_ip = axutil_network_handler_get_svr_ip(env, listen_socket); + AXIS2_INTF_TO_IMPL(receiver)->svr_ip = server_impl->svr_ip; + } + */ + } + AXIS2_LOG_INFO(env->log, "Starting HTTP server thread"); + axis2_http_svr_thread_set_worker(server_impl->svr_thread, env, worker); + axis2_http_svr_thread_run(server_impl->svr_thread, env); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_server_stop( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + AXIS2_LOG_INFO(env->log, "Terminating HTTP server thread"); + if(AXIS2_INTF_TO_IMPL(server)->svr_thread) + { + axis2_http_svr_thread_destroy(AXIS2_INTF_TO_IMPL(server)->svr_thread, env); + } + AXIS2_LOG_INFO(env->log, "Successfully terminated HTTP server thread"); + return AXIS2_SUCCESS; +} + +static axis2_conf_ctx_t *AXIS2_CALL +axis2_http_server_get_conf_ctx( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + return AXIS2_INTF_TO_IMPL(server)->conf_ctx; +} + +static axis2_endpoint_ref_t *AXIS2_CALL +axis2_http_server_get_reply_to_epr( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name) +{ + axis2_endpoint_ref_t *epr = NULL; + const axis2_char_t *host_address = NULL; + axis2_char_t *svc_path = NULL; + axutil_url_t *url = NULL; + + host_address = AXIS2_DEFAULT_HOST_ADDRESS; /* TODO : get from axis2.xml */ + svc_path = axutil_stracat(env, AXIS2_DEFAULT_SVC_PATH, svc_name); + url = axutil_url_create(env, AXIS2_HTTP_PROTOCOL, host_address, + AXIS2_INTF_TO_IMPL(server)->port, svc_path); + + AXIS2_FREE(env->allocator, svc_path); + if(!url) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create reply to epr for service %s.", + svc_name); + return NULL; + } + epr = axis2_endpoint_ref_create(env, axutil_url_to_external_form(url, env)); + axutil_url_free(url, env); + return epr; +} + +static axis2_endpoint_ref_t *AXIS2_CALL +axis2_http_server_get_epr_for_service( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name) +{ + axis2_endpoint_ref_t *epr = NULL; + const axis2_char_t *host_address = NULL; + axis2_char_t *svc_path = NULL; + axutil_url_t *url = NULL; + + if(AXIS2_INTF_TO_IMPL(server)->svr_ip) + { + host_address = AXIS2_INTF_TO_IMPL(server)->svr_ip; + }else + { + host_address = AXIS2_DEFAULT_HOST_ADDRESS; /* TODO : get from axis2.xml */ + } + svc_path = axutil_stracat(env, AXIS2_DEFAULT_SVC_PATH, svc_name); + + url = axutil_url_create(env, AXIS2_HTTP_PROTOCOL, host_address, + AXIS2_INTF_TO_IMPL(server)->port, svc_path); + + AXIS2_FREE(env->allocator, svc_path); + if(!url) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create reply to epr for service %s.", + svc_name); + return NULL; + } + epr = axis2_endpoint_ref_create(env, axutil_url_to_external_form(url, env)); + axutil_url_free(url, env); + return epr; +} + +static axis2_bool_t AXIS2_CALL +axis2_http_server_is_running( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + axis2_http_server_impl_t *server_impl = NULL; + server_impl = AXIS2_INTF_TO_IMPL(server); + if(server_impl->svr_thread) + { + return axis2_http_svr_thread_is_running(server_impl->svr_thread, env); + } + return AXIS2_FALSE; +} + +static void AXIS2_CALL +axis2_http_server_set_is_application_client_side( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_bool_t is_application_client_side) +{ + axis2_http_server_impl_t *server_impl = NULL; + server_impl = AXIS2_INTF_TO_IMPL(server); + server_impl->is_application_client_side = is_application_client_side; +} + +static axis2_char_t* AXIS2_CALL +axis2_http_server_get_server_ip( +axis2_transport_receiver_t *server, +const axutil_env_t *env) +{ + return AXIS2_INTF_TO_IMPL(server)->svr_ip; +} + +static void AXIS2_CALL +axis2_http_server_set_server_ip( +axis2_transport_receiver_t *server, +const axutil_env_t *env, + axis2_char_t *serverip) +{ + AXIS2_INTF_TO_IMPL(server)->svr_ip = serverip; +} + +/** + * Following block distinguish the exposed part of the dll. + */ +AXIS2_EXPORT int +axis2_get_instance( + struct axis2_transport_receiver **inst, + const axutil_env_t * env) +{ + *inst = axis2_http_server_create(env, NULL, -1); + if(!(*inst)) + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT int +axis2_remove_instance( + axis2_transport_receiver_t * inst, + const axutil_env_t * env) +{ + if(inst) + { + axis2_transport_receiver_free(inst, env); + } + return AXIS2_SUCCESS; +} + diff --git a/src/core/transport/http/receiver/http_svr_thread.c b/src/core/transport/http/receiver/http_svr_thread.c new file mode 100644 index 0000000..1806815 --- /dev/null +++ b/src/core/transport/http/receiver/http_svr_thread.c @@ -0,0 +1,315 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +AXIS2_EXPORT int axis2_http_socket_read_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT; + +struct axis2_http_svr_thread +{ + int listen_socket; + axis2_bool_t stopped; + axis2_http_worker_t *worker; + int port; +}; + +typedef struct axis2_http_svr_thd_args +{ + axutil_env_t *env; + axis2_socket_t socket; + axis2_http_worker_t *worker; + axutil_thread_t *thread; +} axis2_http_svr_thd_args_t; + +static void *AXIS2_THREAD_FUNC +axis2_svr_thread_worker_func( + axutil_thread_t * thd, + void *data); + +axis2_http_svr_thread_t *AXIS2_CALL +axis2_http_svr_thread_create( + const axutil_env_t * env, + int port) +{ + axis2_http_svr_thread_t *svr_thread = NULL; + + svr_thread = (axis2_http_svr_thread_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_svr_thread_t)); + + if(!svr_thread) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)svr_thread, 0, sizeof(axis2_http_svr_thread_t)); + + svr_thread->port = port; + svr_thread->listen_socket = (int)axutil_network_handler_create_server_socket(env, + svr_thread->port); + if(-1 == svr_thread->listen_socket) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Http server thread socket creation failed."); + axis2_http_svr_thread_free((axis2_http_svr_thread_t *)svr_thread, env); + return NULL; + } + + return svr_thread; +} + +void AXIS2_CALL +axis2_http_svr_thread_free( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + if(!svr_thread) + { + return; + } + + if(svr_thread->worker) + { + axis2_http_worker_free(svr_thread->worker, env); + svr_thread->worker = NULL; + } + if(-1 != svr_thread->listen_socket) + { + axutil_network_handler_close_socket(env, svr_thread->listen_socket); + svr_thread->listen_socket = -1; + } + svr_thread->stopped = AXIS2_TRUE; + + AXIS2_FREE(env->allocator, svr_thread); +} + +axis2_status_t AXIS2_CALL +axis2_http_svr_thread_run( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + while(AXIS2_FALSE == svr_thread->stopped) + { + int socket = -1; + axis2_http_svr_thd_args_t *arg_list = NULL; +#ifdef AXIS2_SVR_MULTI_THREADED + axutil_thread_t *worker_thread = NULL; +#endif + + socket = (int)axutil_network_handler_svr_socket_accept(env, svr_thread-> listen_socket); + if(!svr_thread->worker) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "Worker not ready yet. Cannot serve the request"); + axutil_network_handler_close_socket(env, socket); + continue; + } + + arg_list = AXIS2_MALLOC(env->allocator, sizeof(axis2_http_svr_thd_args_t)); + if(!arg_list) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Memory allocation error in the svr thread loop"); + continue; + } + + arg_list->env = (axutil_env_t *)env; + arg_list->socket = socket; + arg_list->worker = svr_thread->worker; +#ifdef AXIS2_SVR_MULTI_THREADED + worker_thread = axutil_thread_pool_get_thread(env->thread_pool, + axis2_svr_thread_worker_func, (void *) arg_list); + if (!worker_thread) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Thread creation failed server thread loop"); + continue; + } + axutil_thread_pool_thread_detach(env->thread_pool, worker_thread); +#else + axis2_svr_thread_worker_func(NULL, (void *)arg_list); +#endif + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_svr_thread_destroy( + axis2_http_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + if(AXIS2_TRUE == svr_thread->stopped) + { + return AXIS2_SUCCESS; + } + + svr_thread->stopped = AXIS2_TRUE; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Terminating HTTP server thread."); + if(svr_thread->listen_socket) + { + axutil_network_handler_close_socket(env, svr_thread->listen_socket); + svr_thread->listen_socket = -1; + } + return AXIS2_SUCCESS; +} + +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) +{ + return svr_thread->port; +} + +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) +{ + return !(svr_thread->stopped); +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, worker, AXIS2_FAILURE); + svr_thread->worker = worker; + return AXIS2_SUCCESS; +} + +/** + * Thread worker function. + */ +static void *AXIS2_THREAD_FUNC +axis2_svr_thread_worker_func( + axutil_thread_t * thd, + void *data) +{ + struct AXIS2_PLATFORM_TIMEB t1, t2; + axis2_simple_http_svr_conn_t *svr_conn = NULL; + axis2_http_simple_request_t *request = NULL; + int millisecs = 0; + double secs = 0; + axis2_http_worker_t *tmp = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_env_t *env = NULL; + axis2_socket_t socket; + axutil_env_t *thread_env = NULL; + axis2_http_svr_thd_args_t *arg_list = NULL; + +#ifndef WIN32 +#ifdef AXIS2_SVR_MULTI_THREADED + signal(SIGPIPE, SIG_IGN); +#endif +#endif + + if(!data) + { + return NULL; + } + arg_list = (axis2_http_svr_thd_args_t *)data; + + env = arg_list->env; + thread_env = axutil_init_thread_env(env); + + IF_AXIS2_LOG_DEBUG_ENABLED(env->log) + { + AXIS2_PLATFORM_GET_TIME_IN_MILLIS(&t1); + } + + socket = arg_list->socket; + svr_conn = axis2_simple_http_svr_conn_create(thread_env, (int)socket); + if(!svr_conn) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "creating simple_http_svr_connection failed"); + return NULL; + } + + axis2_simple_http_svr_conn_set_rcv_timeout(svr_conn, thread_env, axis2_http_socket_read_timeout); + + /* read HTTPMethod, URL, HTTP Version and http headers. Leave the remaining in the stream */ + request = axis2_simple_http_svr_conn_read_request(svr_conn, thread_env); + if(!request) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create request"); + return NULL; + } + + tmp = arg_list->worker; + status = axis2_http_worker_process_request(tmp, thread_env, svr_conn, request); + axis2_simple_http_svr_conn_free(svr_conn, thread_env); + axis2_http_simple_request_free(request, thread_env); + + IF_AXIS2_LOG_DEBUG_ENABLED(env->log) + { + AXIS2_PLATFORM_GET_TIME_IN_MILLIS(&t2); + millisecs = t2.millitm - t1.millitm; + secs = difftime(t2.time, t1.time); + if(millisecs < 0) + { + millisecs += 1000; + secs--; + } + secs += millisecs / 1000.0; + +#if defined(WIN32) + AXIS2_LOG_DEBUG(thread_env->log, AXIS2_LOG_SI, "Request processed..."); +#else + AXIS2_LOG_DEBUG(thread_env->log, AXIS2_LOG_SI, "Request processed in %.3f seconds", secs); +#endif + } + + if(status == AXIS2_SUCCESS) + { + AXIS2_LOG_DEBUG(thread_env->log, AXIS2_LOG_SI, "Request served successfully"); + } + else + { + AXIS2_LOG_WARNING(thread_env->log, AXIS2_LOG_SI, "Error occurred in processing request "); + } + + AXIS2_FREE(thread_env->allocator, arg_list); + axutil_free_thread_env(thread_env); + thread_env = NULL; + +#ifdef AXIS2_SVR_MULTI_THREADED + axutil_thread_pool_exit_thread(env->thread_pool, thd); +#endif + + return NULL; +} + +AXIS2_EXTERN int AXIS2_CALL + axis2_http_svr_thread_get_listen_socket( + axis2_http_svr_thread_t *svr_thread, + const axutil_env_t *env) +{ + return svr_thread->listen_socket; + +} diff --git a/src/core/transport/http/sender/Makefile.am b/src/core/transport/http/sender/Makefile.am new file mode 100644 index 0000000..399ed39 --- /dev/null +++ b/src/core/transport/http/sender/Makefile.am @@ -0,0 +1,51 @@ +SUBDIRS=ssl libcurl +lib_LTLIBRARIES = libaxis2_http_sender.la + + + +if AXIS2_LIBCURL_ENABLED +LIBCURL_SOURCES=libcurl/axis2_libcurl.c\ + libcurl/libcurl_stream.c +LIBCURL_LIBS=-lssl -lcrypto -lcurl -ldl -lz +else +LIBCURL_SOURCES= +LIBCURL_LIBS= +endif + + +if AXIS2_SSL_ENABLED +SSL_SOURCES = ssl/ssl_stream.c\ + ssl/ssl_utils.c +SSL_LIBS = -lssl -lcrypto +else +SSL_SOURCES= +SSL_LIBS= +endif + +libaxis2_http_sender_la_SOURCES = http_transport_sender.c \ + http_sender.c \ + http_client.c \ + $(SSL_SOURCES) \ + $(LIBCURL_SOURCES) + +libaxis2_http_sender_la_LIBADD = $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la\ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la\ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la\ + $(top_builddir)/util/src/libaxutil.la\ + $(LIBCURL_LIBS)\ + $(SSL_LIBS) + + +libaxis2_http_sender_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport\ + -I$(top_builddir)/src/core/transport/http \ + -I$(top_builddir)/src/core/transport/http/sender/libcurl \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/sender/http_client.c b/src/core/transport/http/sender/http_client.c new file mode 100644 index 0000000..80e7ee3 --- /dev/null +++ b/src/core/transport/http/sender/http_client.c @@ -0,0 +1,965 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef AXIS2_SSL_ENABLED +#include "ssl/ssl_stream.h" +#endif + +struct axis2_http_client +{ + int sockfd; + axutil_stream_t *data_stream; + axutil_url_t *url; + axis2_http_simple_response_t *response; + axis2_bool_t request_sent; + int timeout; + axis2_bool_t proxy_enabled; + axis2_char_t *proxy_host; + int proxy_port; + axis2_char_t *proxy_host_port; + axis2_bool_t dump_input_msg; + axis2_char_t *server_cert; + axis2_char_t *key_file; + axis2_char_t *req_body; + int req_body_size; + + /* These are for mtom case */ + axutil_array_list_t *mime_parts; + axis2_bool_t doing_mtom; + axis2_char_t *mtom_sending_callback_name; +}; + +AXIS2_EXTERN axis2_http_client_t *AXIS2_CALL +axis2_http_client_create( + const axutil_env_t * env, + axutil_url_t * url) +{ + axis2_http_client_t *http_client = NULL; + + http_client = (axis2_http_client_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_http_client_t)); + + if(!http_client) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset(http_client, 0, sizeof(axis2_http_client_t)); + + http_client->url = url; + http_client->data_stream = NULL; + http_client->sockfd = -1; + http_client->response = NULL; + http_client->request_sent = AXIS2_FALSE; + + /* default timeout is 60000 milliseconds */ + http_client->timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT; + http_client->proxy_enabled = AXIS2_FALSE; + http_client->proxy_port = 0; + http_client->proxy_host = NULL; + http_client->proxy_host_port = NULL; + http_client->dump_input_msg = AXIS2_FALSE; + http_client->server_cert = NULL; + http_client->key_file = NULL; + http_client->req_body = NULL; + http_client->req_body_size = 0; + http_client->mime_parts = NULL; + http_client->doing_mtom = AXIS2_FALSE; + http_client->mtom_sending_callback_name = NULL; + + return http_client; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_client_free( + axis2_http_client_t * http_client, + const axutil_env_t * env) +{ + if(http_client->proxy_host) + { + AXIS2_FREE(env->allocator, http_client->proxy_host); + } + if(http_client->proxy_host_port) + { + AXIS2_FREE(env->allocator, http_client->proxy_host_port); + } + if(http_client->url) + { + axutil_url_free(http_client->url, env); + } + if(http_client->response) + { + axis2_http_simple_response_free(http_client->response, env); + } + if(-1 != http_client->sockfd) + { + axutil_network_handler_close_socket(env, http_client->sockfd); + http_client->sockfd = -1; + } + + if(http_client->req_body) + { + AXIS2_FREE(env->allocator, http_client->req_body); + } + + /* There is no other appropriate place to free the mime_part list when a + * particular client send requests. */ + + if(http_client->mime_parts) + { + int i = 0; + for(i = 0; i < axutil_array_list_size(http_client->mime_parts, env); i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *)axutil_array_list_get(http_client->mime_parts, env, i); + if(mime_part) + { + axiom_mime_part_free(mime_part, env); + } + } + axutil_array_list_free(http_client->mime_parts, env); + } + + AXIS2_FREE(env->allocator, http_client); + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_client_free_void_arg( + void *client, + const axutil_env_t * env) +{ + axis2_http_client_t *client_l = NULL; + + client_l = (axis2_http_client_t *)client; + axis2_http_client_free(client_l, env); + return; +} + +/* This is the main method which writes to the socket in the case of a client + * sends an http_request. Previously this method does not distinguish between a + * mtom request and non mtom request. Because what finally it had was the + * complete buffer with the request. But now MTOM invocations are done + * differently in order to support large attachments so this method should + * distinguish those invocations */ + +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) +{ + char *wire_format = NULL; + axutil_array_list_t *headers = NULL; + char *str_header = NULL; + char *str_request_line = NULL; + int written = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_bool_t chunking_enabled = AXIS2_FALSE; + axis2_char_t *host = NULL; + unsigned int port = 0; + + /* In the MTOM case request body is not set. Instead mime_parts + array_list is there */ + + if(client->req_body) + { + AXIS2_FREE(env->allocator, client->req_body); + client->req_body = NULL; + } + if(!client->req_body && !(client->doing_mtom)) + { + client->req_body_size = axis2_http_simple_request_get_body_bytes(request, env, + &client->req_body); + } + + if(client->dump_input_msg == AXIS2_TRUE) + { + return AXIS2_SUCCESS; + } + + if(!client->url) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_URL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Request url not set"); + return AXIS2_FAILURE; + } + + host = axutil_url_get_host(client->url, env); + port = axutil_url_get_port(client->url, env); + + if(client->proxy_enabled) + { + if(!client->proxy_host || client->proxy_port <= 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Proxy port or Host not set"); + return AXIS2_FAILURE; + } + + if(client->sockfd < 0) + { + client->sockfd = (int)axutil_network_handler_open_socket(env, client->proxy_host, + client->proxy_port); + } + } + else + { + /*Proxy is not enabled*/ + + if(client->sockfd < 0) + { + client->sockfd = (int)axutil_network_handler_open_socket(env, host, port); + } + } + + if(client->sockfd < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Socket Creation failed."); + return AXIS2_FAILURE; + } + + if(client->timeout > 0) + { + /*Set the receiving time out*/ + axutil_network_handler_set_sock_option(env, client->sockfd, SO_RCVTIMEO, client->timeout); + /*Set the sending time out*/ + + axutil_network_handler_set_sock_option(env, client->sockfd, SO_SNDTIMEO, client->timeout); + } + + if(0 == axutil_strcasecmp(axutil_url_get_protocol(client->url, env), AXIS2_TRANSPORT_URL_HTTPS)) + { +#ifdef AXIS2_SSL_ENABLED + if (client->proxy_enabled) + { + if (AXIS2_SUCCESS != axis2_http_client_connect_ssl_host(client, env, host, port)) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "HTTPS connection creation failed"); + return AXIS2_FAILURE; + } + } + client->data_stream = + axutil_stream_create_ssl(env, client->sockfd, axis2_http_client_get_server_cert(client, + env), axis2_http_client_get_key_file(client, env), ssl_pp); +#else + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_TRANSPORT_PROTOCOL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid Transport Protocol, HTTPS transport not enabled."); + + return AXIS2_FAILURE; +#endif + } + else + { + client->data_stream = axutil_stream_create_socket(env, client->sockfd); + } + + if(!client->data_stream) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Data stream creation failed for Host %s and %d port", host, port); + + return AXIS2_FAILURE; + } + + /*Accessing HTTP headers*/ + + headers = axis2_http_simple_request_get_headers(request, env); + if(headers) + { + int header_count = axutil_array_list_size(headers, env); + int i = 0; + char *str_header2 = NULL; + for(i = 0; i < header_count; i++) + { + axis2_char_t *header_ext_form = NULL; + axis2_http_header_t *tmp_header = (axis2_http_header_t *)axutil_array_list_get(headers, + env, i); + + if(!tmp_header) + { + /* This continue is added as a safey mechanism, + * However I see a problem with this logic, AFAIC + * see there can't be null headers in the headers + * array list, because number of headers in "headers" + * array list count with axutil_array_list_size, + * therefore this check and continue might not have a + * real effect.*/ + + continue; + } + + /* check whether we have transfer encoding and then see whether the + * value is "chunked" */ + if(!axutil_strcmp(axis2_http_header_get_name(tmp_header, env), + AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && !axutil_strcmp(axis2_http_header_get_value( + tmp_header, env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + chunking_enabled = AXIS2_TRUE; + } + + header_ext_form = axis2_http_header_to_external_form(tmp_header, env); + + /* str_header2 is to hold intermediate value of str_header */ + str_header2 = axutil_stracat(env, str_header, header_ext_form); + if(str_header) + { + AXIS2_FREE(env->allocator, str_header); + str_header = NULL; + } + if(header_ext_form) + { + AXIS2_FREE(env->allocator, header_ext_form); + header_ext_form = NULL; + } + + /* str_header has all HTTP headers to send. */ + str_header = str_header2; + } + } + + if(AXIS2_FALSE == client->proxy_enabled) + { + str_request_line = axis2_http_request_line_to_string( + axis2_http_simple_request_get_request_line(request, env), env); + } + else + { + /* proxy enabled case */ + + /* we need the request line in the format + * POST http://host:port/path HTTP/1.x if we have enabled proxies + */ + axis2_char_t *host_port_str = NULL; + axis2_char_t *host = axutil_url_get_host(client->url, env); + axis2_http_request_line_t *request_line = axis2_http_simple_request_get_request_line( + request, env); + axis2_char_t *path = axis2_http_request_line_get_uri(request_line, env); + + host_port_str = AXIS2_MALLOC(env->allocator, axutil_strlen(host) + axutil_strlen(path) + 20 + * sizeof(axis2_char_t)); + + if(!host_port_str) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Memory allocation failed for host %s and %s path", host, path); + + return AXIS2_FAILURE; + } + + sprintf(host_port_str, "http://%s:%d%s", host, axutil_url_get_port(client->url, env), path); + str_request_line = AXIS2_MALLOC(env->allocator, axutil_strlen(host_port_str) + 20 + * sizeof(axis2_char_t)); + + if(!str_request_line) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_FREE(env->allocator, host_port_str); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "memory allocation failed for host %s and %s path", host, path); + + return AXIS2_FAILURE; + } + + sprintf(str_request_line, "%s %s %s\r\n", axis2_http_request_line_get_method(request_line, + env), host_port_str, axis2_http_request_line_get_http_version(request_line, env)); + + AXIS2_FREE(env->allocator, host_port_str); + host_port_str = NULL; + + } + + /* Here first we send the http header part */ + + wire_format = axutil_stracat(env, str_request_line, str_header); + AXIS2_FREE(env->allocator, str_header); + str_header = NULL; + AXIS2_FREE(env->allocator, str_request_line); + str_request_line = NULL; + written + = axutil_stream_write(client->data_stream, env, wire_format, axutil_strlen(wire_format)); + AXIS2_FREE(env->allocator, wire_format); + wire_format = NULL; + + /* Then we write the two new line charaters before the http body*/ + + written = axutil_stream_write(client->data_stream, env, AXIS2_HTTP_CRLF, 2); + + /* When sending MTOM it is bit different. We keep the attachment + other + mime headers in an array_list and send them one by one */ + + if(client->doing_mtom) + { + axis2_status_t status = AXIS2_SUCCESS; + axutil_http_chunked_stream_t *chunked_stream = NULL; + + /* If the callback name is not there, then we will check whether there + * is any mime_parts which has type callback. If we found then no point + * of continuing we should return a failure */ + + if(!(client->mtom_sending_callback_name)) + { + if(axis2_http_transport_utils_is_callback_required(env, client->mime_parts)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sender callback not specified"); + return AXIS2_FAILURE; + } + } + + /* For MTOM we automatically enabled chunking */ + chunked_stream = axutil_http_chunked_stream_create(env, client->data_stream); + + /* This method will write the Attachment + data to the wire */ + + status = axis2_http_transport_utils_send_mtom_message(chunked_stream, env, + client->mime_parts, client->mtom_sending_callback_name); + + axutil_http_chunked_stream_free(chunked_stream, env); + chunked_stream = NULL; + + } + /* Non MTOM case */ + else if(client->req_body_size > 0 && client->req_body) + { + int len = 0; + written = 0; + + /* Keep on writing data in a loop until we finised + with all the data in the buffer */ + + if(!chunking_enabled) + { + status = AXIS2_SUCCESS; + while(written < client->req_body_size) + { + len = 0; + len = axutil_stream_write(client->data_stream, env, client->req_body + written, + client->req_body_size - written); + if(-1 == len) + { + status = AXIS2_FAILURE; + break; + } + else + { + written += len; + } + } + } + else + { + /* Not MTOM but chunking is enabled */ + axutil_http_chunked_stream_t *chunked_stream = NULL; + chunked_stream = axutil_http_chunked_stream_create(env, client->data_stream); + status = AXIS2_SUCCESS; + if(!chunked_stream) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creatoin of chunked stream failed"); + return AXIS2_FAILURE; + } + + while(written < client->req_body_size) + { + written = axutil_http_chunked_stream_write(chunked_stream, env, client->req_body, + client->req_body_size); + + if(-1 == written) + { + status = AXIS2_FAILURE; + break; + } + } + + if(AXIS2_SUCCESS == status) + { + /* Writing the trailing null charactor */ + axutil_http_chunked_stream_write_last_chunk(chunked_stream, env); + } + + axutil_http_chunked_stream_free(chunked_stream, env); + } + } + + client->request_sent = AXIS2_TRUE; + return status; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_client_recieve_header( + axis2_http_client_t * client, + const axutil_env_t * env) +{ + int status_code = -1; + axis2_http_status_line_t *status_line = NULL; + axis2_char_t str_status_line[512]; + axis2_char_t tmp_buf[3]; + axis2_char_t str_header[512]; + int read = 0; + int http_status = 0; + axis2_bool_t end_of_line = AXIS2_FALSE; + axis2_bool_t end_of_headers = AXIS2_FALSE; + + if(-1 == client->sockfd || !client->data_stream || AXIS2_FALSE == client->request_sent) + { + axis2_char_t *host; + unsigned int port; + host = axutil_url_get_host(client->url, env); + port = axutil_url_get_port(client->url, env); + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "client data stream null or socket error for host \ +%s and %d port", host, port); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_REQUEST_NOT_SENT, AXIS2_FAILURE); + return -1; + } + + /* read the status line */ + do + { + memset(str_status_line, 0, 512); + while((read = axutil_stream_read(client->data_stream, env, tmp_buf, 1)) > 0) + { + /* "read" variable is number of characters read by stream */ + tmp_buf[read] = '\0'; + strcat(str_status_line, tmp_buf); + if(0 != strstr(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_line = AXIS2_TRUE; + break; + } + } + + if(read < 0) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "http client , response timed out"); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_RESPONSE_TIMED_OUT, AXIS2_FAILURE); + return -1; + } + else if(read == 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_RESPONSE_SERVER_SHUTDOWN, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Response error, Server Shutdown"); + return 0; + } + + status_line = axis2_http_status_line_create(env, str_status_line); + if(!status_line) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2_http_status_line_create failed for \ +str_status_line %s", str_status_line); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + http_status = 0; + continue; + + } + http_status = axis2_http_status_line_get_status_code(status_line, env); + + } + while(AXIS2_HTTP_RESPONSE_OK_CODE_VAL > http_status); + + if(client->response) + axis2_http_simple_response_free(client->response, env); + client->response = axis2_http_simple_response_create_default(env); + axis2_http_simple_response_set_status_line(client->response, env, + axis2_http_status_line_get_http_version(status_line, env), + axis2_http_status_line_get_status_code(status_line, env), + axis2_http_status_line_get_reason_phrase(status_line, env)); + + /* now read the headers */ + memset(str_header, 0, 512); + end_of_line = AXIS2_FALSE; + while(AXIS2_FALSE == end_of_headers) + { + while((read = axutil_stream_read(client->data_stream, env, tmp_buf, 1)) > 0) + { + tmp_buf[read] = '\0'; + strcat(str_header, tmp_buf); + if(0 != strstr(str_header, AXIS2_HTTP_CRLF)) + { + end_of_line = AXIS2_TRUE; + break; + } + } + if(AXIS2_TRUE == end_of_line) + { + if(0 == axutil_strcmp(str_header, AXIS2_HTTP_CRLF)) + { + end_of_headers = AXIS2_TRUE; + } + else + { + axis2_http_header_t *tmp_header = axis2_http_header_create_by_str(env, str_header); + memset(str_header, 0, 512); + if(tmp_header) + { + axis2_http_simple_response_set_header(client->response, env, tmp_header); + } + } + } + end_of_line = AXIS2_FALSE; + } + axis2_http_simple_response_set_body_stream(client->response, env, client->data_stream); + if(status_line) + { + status_code = axis2_http_status_line_get_status_code(status_line, env); + axis2_http_status_line_free(status_line, env); + status_line = NULL; + } + + if(AXIS2_FALSE == axis2_http_simple_response_contains_header(client->response, env, + AXIS2_HTTP_HEADER_CONTENT_TYPE) && 202 != status_code + && axis2_http_simple_response_get_content_length(client->response, env) > 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_RESPONSE_CONTENT_TYPE_MISSING, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Response does not contain" " Content-Type"); + return -1; + } + return status_code; +} + +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) +{ + return client->response; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, url, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + + if(client->url) + { + axutil_url_free(client->url, env); + client->url = NULL; + } + client->url = url; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_url_t *AXIS2_CALL +axis2_http_client_get_url( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, client, NULL); + return client->url; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + client->timeout = timeout_ms; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_client_get_timeout( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + return client->timeout; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, proxy_host, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + + if(proxy_port <= 0) + { + return AXIS2_FAILURE; + } + + client->proxy_port = proxy_port; + if(client->proxy_host) + { + AXIS2_FREE(env->allocator, client->proxy_host); + client->proxy_host = NULL; + } + + if(client->proxy_host_port) + { + AXIS2_FREE(env->allocator, client->proxy_host_port); + client->proxy_host_port = NULL; + } + + client->proxy_host = axutil_strdup(env, proxy_host); + if(!client->proxy_host) + { + return AXIS2_FAILURE; + } + + client->proxy_host_port = AXIS2_MALLOC(env->allocator, axutil_strlen(proxy_host) + 10 + * sizeof(axis2_char_t)); + + sprintf(client->proxy_host_port, "%s:%d", proxy_host, proxy_port); + client->proxy_enabled = AXIS2_TRUE; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_client_get_proxy( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, client, NULL); + return client->proxy_host_port; +} + +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) +{ + axutil_stream_t *tmp_stream = NULL; + axis2_char_t *connect_string = NULL; + axis2_char_t str_status_line[512]; + axis2_char_t tmp_buf[3]; + int read = 0; + axis2_bool_t end_of_line = AXIS2_FALSE; + axis2_bool_t end_of_response = AXIS2_FALSE; + axis2_http_status_line_t *status_line = NULL; + + AXIS2_PARAM_CHECK(env->error, host, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client->url, AXIS2_FAILURE); + /* This host and port will use for give undersandable log messages + * */ + + if(port <= 0) + { + return AXIS2_FAILURE; + } + + tmp_stream = axutil_stream_create_socket(env, client->sockfd); + if(!tmp_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "unable to create open socket for ssl host %s and %d \ +port", host, port); + return AXIS2_FAILURE; + } + + connect_string = AXIS2_MALLOC(env->allocator, axutil_strlen(host) * sizeof(axis2_char_t) + 30 + * sizeof(axis2_char_t)); + sprintf(connect_string, "CONNECT %s:%d HTTP/1.0\r\n\r\n", host, port); + axutil_stream_write(tmp_stream, env, connect_string, axutil_strlen(connect_string) + * sizeof(axis2_char_t)); + + memset(str_status_line, 0, 512); + while((read = axutil_stream_read(tmp_stream, env, tmp_buf, 1)) > 0) + { + tmp_buf[read] = '\0'; + strcat(str_status_line, tmp_buf); + if(0 != strstr(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_line = AXIS2_TRUE; + break; + } + } + if(read < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_RESPONSE_TIMED_OUT, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_FAILURE; + } + status_line = axis2_http_status_line_create(env, str_status_line); + if(!status_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_FAILURE; + } + if(200 != axis2_http_status_line_get_status_code(status_line, env)) + { + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_FAILURE; + } + /* We need to empty the stream before we return + */ + memset(str_status_line, 0, 512); + while(AXIS2_FALSE == end_of_response) + { + while((read = axutil_stream_read(tmp_stream, env, tmp_buf, 1)) > 0) + { + tmp_buf[read] = '\0'; + strcat(str_status_line, tmp_buf); + if(0 != strstr(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_line = AXIS2_TRUE; + break; + } + } + if(AXIS2_TRUE == end_of_line) + { + if(0 == axutil_strcmp(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_response = AXIS2_TRUE; + } + } + } + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_SUCCESS; +} + +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) +{ + client->dump_input_msg = dump_input_msg; + return AXIS2_SUCCESS; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, server_cert, AXIS2_FAILURE); + client->server_cert = server_cert; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_client_get_server_cert( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + return client->server_cert; +} + +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) +{ + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, key_file, AXIS2_FAILURE); + client->key_file = key_file; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_client_get_key_file( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + return client->key_file; +} + +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) +{ + client->mime_parts = mime_parts; + return AXIS2_SUCCESS; +} + +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) +{ + return client->mime_parts; +} + +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) +{ + client->doing_mtom = doing_mtom; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_client_get_doing_mtom( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + return client->doing_mtom; +} + +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) +{ + client->mtom_sending_callback_name = callback_name; + return AXIS2_SUCCESS; +} diff --git a/src/core/transport/http/sender/http_sender.c b/src/core/transport/http/sender/http_sender.c new file mode 100644 index 0000000..56f11e0 --- /dev/null +++ b/src/core/transport/http/sender/http_sender.c @@ -0,0 +1,3332 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef AXIS2_LIBCURL_ENABLED +#include "libcurl/axis2_libcurl.h" +#else +#define CLIENT_NONCE_LENGTH 8 +#endif + +struct axis2_http_sender +{ + axis2_char_t *http_version; + axis2_bool_t chunked; + int so_timeout; + axiom_output_t *om_output; + axis2_http_client_t *client; + axis2_bool_t is_soap; + axis2_bool_t keep_alive; +}; + +#ifndef AXIS2_LIBCURL_ENABLED +static void +axis2_http_sender_add_header_list( + axis2_http_simple_request_t * request, + const axutil_env_t * env, + axutil_array_list_t * array_list); + +static axis2_status_t +axis2_http_sender_configure_proxy( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +static axis2_status_t +axis2_http_sender_configure_server_cert( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +static axis2_status_t +axis2_http_sender_configure_key_file( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +static axis2_status_t +axis2_http_sender_configure_http_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request); + +static axis2_status_t +axis2_http_sender_configure_proxy_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request); + +static axis2_status_t +axis2_http_sender_set_http_auth_type( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request); + +static axis2_status_t +axis2_http_sender_set_proxy_auth_type( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request); + +static axis2_status_t +axis2_http_sender_configure_http_basic_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request); + +static axis2_status_t +axis2_http_sender_configure_proxy_basic_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request); + +static axis2_status_t +axis2_http_sender_configure_http_digest_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request, + axis2_char_t * header_data); + +static axis2_status_t +axis2_http_sender_configure_proxy_digest_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request, + axis2_char_t * header_data); + + + +#endif + +static axutil_hash_t * +axis2_http_sender_connection_map_create( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx); + +static void +axis2_http_sender_connection_map_remove( + axutil_hash_t *connection_map, + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_http_client_t *http_client); + +static void +axis2_http_sender_connection_map_add( + axutil_hash_t *connection_map, + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_http_client_t *http_client); + +static axis2_http_client_t * +axis2_http_sender_connection_map_get( + axutil_hash_t *connection_map, + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx); + +static void AXIS2_CALL +axis2_http_sender_connection_map_free( + void *cm_void, + const axutil_env_t *env); + +AXIS2_EXTERN axis2_http_sender_t *AXIS2_CALL +axis2_http_sender_create( + const axutil_env_t * env) +{ + axis2_http_sender_t *sender = NULL; + + sender = (axis2_http_sender_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_http_sender_t)); + + if(!sender) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset(sender, 0, sizeof(axis2_http_sender_t)); + sender->http_version = (axis2_char_t *)AXIS2_HTTP_HEADER_PROTOCOL_11; + sender->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT; + /* unlike the java impl we don't have a default om output + * it should be explicitly set and it's a MUST + */ + sender->om_output = NULL; + sender->chunked = AXIS2_FALSE; + sender->client = NULL; + sender->keep_alive = AXIS2_TRUE; + + return sender; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_sender_free( + axis2_http_sender_t * sender, + const axutil_env_t * env) +{ + if(sender->http_version) + { + AXIS2_FREE(env->allocator, sender->http_version); + } + + /* Do not free this here since it will be required in later processing + * of the response soap message + */ + sender->client = NULL; + AXIS2_FREE(env->allocator, sender); + return; +} + +#ifndef AXIS2_LIBCURL_ENABLED +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) +{ + axis2_http_simple_request_t *request = NULL; + axis2_http_request_line_t *request_line = NULL; + + /* url is to hold url given in str_url */ + axutil_url_t *url = NULL; + axiom_xml_writer_t *xml_writer = NULL; + axis2_char_t *buffer = NULL; + unsigned int buffer_size = 0; + const axis2_char_t *char_set_enc = NULL; + axutil_string_t *char_set_enc_str = NULL; + int status_code = -1; + axis2_http_simple_response_t *response = NULL; + axis2_char_t *content_type = NULL; + axis2_bool_t content_type_deepl_copy = AXIS2_TRUE; + axis2_byte_t *output_stream = NULL; + int output_stream_size = 0; + axis2_bool_t doing_mtom = AXIS2_FALSE; + axutil_property_t *dump_property = NULL; + axutil_param_t *ssl_pp_param = NULL; + /* ssl passphrase */ + axis2_char_t *ssl_pp = NULL; + axutil_property_t *ssl_pp_property = NULL; + axutil_property_t *test_auth_property = NULL; + axis2_char_t *test_auth_property_value = NULL; + axis2_bool_t test_proxy_auth = AXIS2_FALSE; + axis2_bool_t test_http_auth = AXIS2_FALSE; + + /* http proxy authentication */ + axutil_property_t *proxy_auth_property = NULL; + axis2_char_t *proxy_auth_property_value = NULL; + axis2_bool_t force_proxy_auth = AXIS2_FALSE; + axis2_bool_t force_proxy_auth_with_head = AXIS2_FALSE; + axutil_property_t *http_auth_property = NULL; + axis2_char_t *http_auth_property_value = NULL; + axis2_bool_t force_http_auth = AXIS2_FALSE; + axis2_bool_t force_http_auth_with_head = AXIS2_FALSE; + axutil_property_t *content_type_property = NULL; + axutil_hash_t *content_type_hash = NULL; + axis2_char_t *content_type_value = NULL; + axutil_property_t *method = NULL; + axis2_char_t *method_value = NULL; + + /* handling REST requests */ + axis2_bool_t send_via_get = AXIS2_FALSE; + axis2_bool_t send_via_head = AXIS2_FALSE; + axis2_bool_t send_via_delete = AXIS2_FALSE; + axis2_bool_t send_via_put = AXIS2_FALSE; + axiom_node_t *data_out = NULL; + axiom_node_t *body_node = NULL; + axiom_soap_body_t *soap_body = NULL; + axis2_bool_t is_soap = AXIS2_TRUE; + axis2_bool_t add_keepalive_header = AXIS2_FALSE; + + /* http header property to get HTTP headers from msg_ctx and give + * it to http_sender */ + axutil_property_t *http_property = NULL; + axutil_array_list_t *array_list; + axis2_bool_t http_auth_header_added = AXIS2_FALSE; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *write_xml_declaration_param = NULL; + axutil_hash_t *transport_attrs = NULL; + axis2_bool_t write_xml_declaration = AXIS2_FALSE; + axutil_property_t *property = NULL;/* Property for holding http client */ + /*axis2_char_t *header_value = NULL;*/ + axis2_char_t *cookie_str = NULL; + axutil_hash_t *connection_map = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_sender_send"); + soap_body = axiom_soap_envelope_get_body(out, env); + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, str_url, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, soap_action, AXIS2_FAILURE); + + if(AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + is_soap = AXIS2_FALSE; + } + else + { + is_soap = AXIS2_TRUE; + } + + url = axutil_url_parse_string(env, str_url); + + if(!is_soap) + { + if(soap_body) + { + body_node = axiom_soap_body_get_base_node(soap_body, env); + } + if(body_node) + { + data_out = axiom_node_get_first_element(body_node, env); + } + + method = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_METHOD); + if(method) + { + method_value = (axis2_char_t *)axutil_property_get_value(method, env); + } + + /* The default is POST */ + if(method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_GET)) + { + send_via_get = AXIS2_TRUE; + } + else if(method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_HEAD)) + { + send_via_head = AXIS2_TRUE; + } + else if(method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_PUT)) + { + send_via_put = AXIS2_TRUE; + } + else if(method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_DELETE)) + { + send_via_delete = AXIS2_TRUE; + } + } + + if(!url) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "url is null for string %s", str_url); + return AXIS2_FAILURE; + } + + /*if(sender->client) + { + axis2_http_client_free(sender->client, env); + sender->client = NULL; + }*/ + + /* This property may be set by the application client. This get the priority over the keep alive + * parameter set in the axix2.xml + */ + property = (axutil_property_t *) axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE); + if(property) + { + axis2_char_t *keep_alive_value = NULL; + + keep_alive_value = axutil_property_get_value(property, env); + if(!axutil_strcmp(keep_alive_value, AXIS2_VALUE_FALSE)) + { + sender->keep_alive = AXIS2_FALSE; + } + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + } + + /* Because keep alive is not still supported at callback receiver we check + * for client side + */ + if(sender->keep_alive && !axis2_msg_ctx_get_server_side(msg_ctx, env)) + { + axutil_property_t *connection_map_property = NULL; + + connection_map_property = axis2_conf_ctx_get_property(conf_ctx, env, + AXIS2_HTTP_CONNECTION_MAP); + if(!connection_map_property) + { + connection_map = axis2_http_sender_connection_map_create(env, msg_ctx); + if(!connection_map) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + else + { + connection_map = axutil_property_get_value(connection_map_property, env); + if(connection_map) + { + sender->client = axis2_http_sender_connection_map_get(connection_map, env, msg_ctx); + } + } + if(!axutil_strcasecmp(sender->http_version, AXIS2_HTTP_HEADER_PROTOCOL_10)) + { + add_keepalive_header = AXIS2_TRUE; + } + } /* End if sender->keep_alive */ + if(!sender->client) + { + sender->client = axis2_http_client_create(env, url); + } + if(!sender->client) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sender->client creation failed for url %s", url); + return AXIS2_FAILURE; + } + /* configure proxy settings if we have set so + */ + + axis2_http_sender_configure_proxy(sender, env, msg_ctx); + + if(conf) + { + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + } + + if(trans_desc) + { + /* get xml declaration details from axis2.xml */ + write_xml_declaration_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, AXIS2_XML_DECLARATION); + } + + if(write_xml_declaration_param) + { + /* accessing attributes of the HTTP transport's , xml + * declaration element from axis2.xml*/ + + transport_attrs = axutil_param_get_attributes(write_xml_declaration_param, env); + if(transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *write_xml_declaration_attr = NULL; + axis2_char_t *write_xml_declaration_attr_value = NULL; + + obj + = axutil_hash_get(transport_attrs, AXIS2_ADD_XML_DECLARATION, AXIS2_HASH_KEY_STRING); + if(obj) + { + write_xml_declaration_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, + env); + } + + if(write_xml_declaration_attr) + { + write_xml_declaration_attr_value = axiom_attribute_get_value( + write_xml_declaration_attr, env); + } + + if(write_xml_declaration_attr_value && 0 == axutil_strcasecmp( + write_xml_declaration_attr_value, AXIS2_VALUE_TRUE)) + { + write_xml_declaration = AXIS2_TRUE; + } + } + } + + if(write_xml_declaration) + { + axiom_output_write_xml_version_encoding(sender->om_output, env); + } + + if(!send_via_get && !send_via_head && !send_via_delete) + { + /* processing POST and PUT methods */ + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "msg_ctx_id:%s", axis2_msg_ctx_get_msg_id(msg_ctx, + env)); + + doing_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env); + + if(!sender->om_output) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_OM_OUTPUT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", AXIS2_ERROR_GET_MESSAGE(env->error)); + return AXIS2_FAILURE; + } + + xml_writer = axiom_output_get_xml_writer(sender->om_output, env); + + char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env); + + if(!char_set_enc_str) + { + /* if there is no character encoding details available + * use default one. + * #define AXIS2_DEFAULT_CHAR_SET_ENCODING "UTF-8" + */ + char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; + } + else + { + char_set_enc = axutil_string_get_buffer(char_set_enc_str, env); + } + + if(!send_via_put && is_soap) + { + /* HTTP POST case */ + /* dump property use to dump message without sending */ + dump_property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_DUMP_INPUT_MSG_TRUE); + if(dump_property) + { + axis2_char_t *dump_true = axutil_property_get_value(dump_property, env); + if(0 == axutil_strcmp(dump_true, AXIS2_VALUE_TRUE)) + { + axis2_http_client_set_dump_input_msg(sender->client, env, AXIS2_TRUE); + } + } + + axiom_output_set_do_optimize(sender->om_output, env, doing_mtom); + axiom_soap_envelope_serialize(out, env, sender->om_output, AXIS2_FALSE); + } + else if(is_soap) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Attempt to send SOAP message using HTTP PUT failed"); + return AXIS2_FAILURE; + } + else + { + if(!data_out) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "body node payload is NULL"); + return AXIS2_FAILURE; + } + axiom_node_serialize(data_out, env, sender->om_output); + } + + if(doing_mtom) + { + axutil_param_t *callback_name_param = NULL; + axis2_status_t mtom_status = AXIS2_FAILURE; + axutil_array_list_t *mime_parts = NULL; + axis2_char_t *mtom_sending_callback_name = NULL; + + /* Getting the sender callback name paramter if it is + * specified in the configuration file */ + + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_MTOM_SENDING_CALLBACK); + if(callback_name_param) + { + mtom_sending_callback_name = (axis2_char_t *)axutil_param_get_value( + callback_name_param, env); + if(mtom_sending_callback_name) + { + axis2_http_client_set_mtom_sending_callback_name(sender->client, env, + mtom_sending_callback_name); + } + } + + /* Here we put all the attachment related stuff in a array_list + After this method we have the message in parts */ + + mtom_status = axiom_output_flush(sender->om_output, env); + if(mtom_status == AXIS2_FAILURE) + { + return mtom_status; + } + /* HTTP client should distinguish an MTOM invocation because the way + of sending the message in MTOM case is different */ + axis2_http_client_set_doing_mtom(sender->client, env, doing_mtom); + + /* HTTP client will keep this mime_parts, which it will send in chunks at + th end */ + mime_parts = axiom_output_get_mime_parts(sender->om_output, env); + if(mime_parts) + { + axis2_http_client_set_mime_parts(sender->client, env, mime_parts); + } + } + else + { + buffer = axiom_xml_writer_get_xml(xml_writer, env); + } + + if(!(buffer || doing_mtom)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL xml returned from xml writer"); + return AXIS2_FAILURE; + } + + if(!send_via_put) + { + /* HTTP POST */ + axis2_char_t *path_with_query = NULL; + + path_with_query = axutil_strcat(env, axutil_url_get_path(url, env), + axutil_url_get_query(url, env), NULL); + request_line = axis2_http_request_line_create(env, AXIS2_HTTP_POST, path_with_query, + sender->http_version); + AXIS2_FREE(env->allocator, path_with_query); + } + else + { + /* HTTP PUT */ + request_line = axis2_http_request_line_create(env, AXIS2_HTTP_PUT, axutil_url_get_path( + url, env), sender->http_version); + } + } + else + { + /* Processing HTTP GET, HEAD and DELETE */ + + axis2_char_t *request_params = NULL; + axis2_char_t *path = NULL; + + request_params = axis2_http_sender_get_param_string(sender, env, msg_ctx); + + if(request_params) + { + /* substituting AXIS2_Q_MARK for "?" */ + path = axutil_strcat(env, axutil_url_get_path(url, env), AXIS2_Q_MARK_STR, + request_params, NULL); + AXIS2_FREE(env->allocator, request_params); + request_params = NULL; + } + else + { + path = axutil_strdup(env, axutil_url_get_path(url, env)); + } + + if(send_via_get) + { + request_line = axis2_http_request_line_create(env, AXIS2_HTTP_GET, path, + sender->http_version); + } + else if(send_via_head) + { + request_line = axis2_http_request_line_create(env, AXIS2_HTTP_HEAD, path, + sender->http_version); + } + else if(send_via_delete) + { + request_line = axis2_http_request_line_create(env, AXIS2_HTTP_DELETE, path, + sender->http_version); + } + + if(path) + { + AXIS2_FREE(env->allocator, path); + path = NULL; + } + } + + request = axis2_http_simple_request_create(env, request_line, NULL, 0, NULL); + if(add_keepalive_header) + { + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_CONNECTION, + AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE); + } + /** + * If there is a session related stuff handle it + */ + /*header_value = axis2_http_transport_utils_get_session(env, msg_ctx); + if(header_value) + { + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_SET_COOKIE, header_value); + }*/ + + /** + * In the client side sender if a cookie is sent by server add it to the http header + */ + cookie_str = axis2_http_transport_utils_read_from_cookie_store(env, msg_ctx); + if(cookie_str) + { + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_COOKIE, cookie_str); + } + + /* User-Agent:Axis2/C header */ + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_USER_AGENT, AXIS2_USER_AGENT); + + http_property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_TRANSPORT_HEADER_PROPERTY); + if(http_property) + { + array_list = (axutil_array_list_t *)axutil_property_get_value(http_property, env); + axis2_http_sender_add_header_list(request, env, array_list); + } + + if(!send_via_get && !send_via_head && !send_via_put && !send_via_delete && AXIS2_TRUE + == axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + if(AXIS2_ESC_DOUBLE_QUOTE != *soap_action) + { + axis2_char_t *tmp_soap_action = NULL; + tmp_soap_action = AXIS2_MALLOC(env->allocator, (axutil_strlen(soap_action) + 5) + * sizeof(axis2_char_t)); + sprintf(tmp_soap_action, "\"%s\"", soap_action); + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_SOAP_ACTION, + tmp_soap_action); + AXIS2_FREE(env->allocator, tmp_soap_action); + } + else + { + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_SOAP_ACTION, + (const axis2_char_t *)soap_action); + } + } + else if(AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding of SOAP Action Failed for REST request"); + + return AXIS2_FAILURE; + } + + if(!send_via_get && !send_via_head && !send_via_delete) + { + /* processing PUT and POST */ + buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); + + if(AXIS2_FALSE == sender->chunked) + { + axis2_char_t tmp_buf[10]; + if(!buffer) + { + buffer_size = output_stream_size; + } + + if(buffer_size) + { + sprintf(tmp_buf, "%d", buffer_size); + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_CONTENT_LENGTH, + tmp_buf); + } + } + else + { + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_TRANSFER_ENCODING, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED); + } + + if(!send_via_put && is_soap) + { + /* HTTP POST */ + if(doing_mtom) + { + content_type = (axis2_char_t *)axiom_output_get_content_type(sender-> om_output, + env); + if(AXIS2_TRUE != axis2_msg_ctx_get_is_soap_11(msg_ctx, env) && axutil_strcmp( + soap_action, "")) + { + /* handle SOAP action for SOAP 1.2 case */ + axis2_char_t *temp_content_type = NULL; + temp_content_type + = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_ACTION); + content_type = temp_content_type; + temp_content_type = axutil_stracat(env, content_type, soap_action); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + temp_content_type = axutil_stracat(env, content_type, + AXIS2_ESC_DOUBLE_QUOTE_STR); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + } + else + { + content_type_deepl_copy = AXIS2_FALSE; + } + } + else if(AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + /* SOAP 1.1 without MTOM */ + axis2_char_t *temp_content_type = NULL; + content_type = (axis2_char_t *)AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + content_type = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_CHARSET); + temp_content_type = axutil_stracat(env, content_type, char_set_enc); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + } + else + { + /* SOAP 1.2 without MTOM */ + axis2_char_t *temp_content_type = NULL; + content_type = (axis2_char_t *)AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP; + content_type = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_CHARSET); + temp_content_type = axutil_stracat(env, content_type, char_set_enc); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + if(axutil_strcmp(soap_action, "")) + { + temp_content_type + = axutil_stracat(env, content_type, AXIS2_CONTENT_TYPE_ACTION); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + temp_content_type = axutil_stracat(env, content_type, soap_action); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + temp_content_type = axutil_stracat(env, content_type, + AXIS2_ESC_DOUBLE_QUOTE_STR); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + } + } + } + else if(is_soap) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Attempt to send SOAP message using HTTP PUT failed"); + return AXIS2_FAILURE; + } + else + { + content_type_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE); + + if(content_type_property) + { + content_type_hash = (axutil_hash_t *)axutil_property_get_value( + content_type_property, env); + if(content_type_hash) + { + content_type_value = (char *)axutil_hash_get(content_type_hash, + AXIS2_HTTP_HEADER_CONTENT_TYPE, AXIS2_HASH_KEY_STRING); + } + } + + if(content_type_value) + { + content_type = content_type_value; + } + else + { + content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + } + + content_type_deepl_copy = AXIS2_FALSE; + } + + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_CONTENT_TYPE, + content_type); + + if(content_type_deepl_copy && content_type) + { + AXIS2_FREE(env->allocator, content_type); + content_type = NULL; + } + /* Finished Processing PUT and POST */ + } + + if(0 == axutil_strcasecmp(sender->http_version, AXIS2_HTTP_HEADER_PROTOCOL_11)) + { + /* HTTP 1.1 */ + axis2_char_t *header = NULL; + int host_len = 0; + host_len = axutil_strlen(axutil_url_get_host(url, env)); + header = AXIS2_MALLOC(env->allocator, host_len + 10 * sizeof(axis2_char_t)); + sprintf(header, "%s:%d", axutil_url_get_host(url, env), axutil_url_get_port(url, env)); + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_HOST, header); + AXIS2_FREE(env->allocator, header); + header = NULL; + } + + /* If this is a normal invocation the buffer has the full SOAP message + which needs to be send. In the MTOM case instead of this buffer + it has the mime_parts array_list */ + + if(!doing_mtom) + { + axis2_http_simple_request_set_body_string(request, env, buffer, buffer_size); + } + + /* HTTPS request processing */ + axis2_http_sender_configure_server_cert(sender, env, msg_ctx); + + axis2_http_sender_configure_key_file(sender, env, msg_ctx); + + axis2_http_sender_get_timeout_values(sender, env, msg_ctx); + axis2_http_client_set_timeout(sender->client, env, sender->so_timeout); + + ssl_pp_property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SSL_PASSPHRASE); + + if(ssl_pp_property) + { + ssl_pp = (axis2_char_t *)axutil_property_get_value(ssl_pp_property, env); + } + else + { + ssl_pp_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_SSL_PASSPHRASE); + + if(ssl_pp_param) + { + ssl_pp = axutil_param_get_value(ssl_pp_param, env); + } + } + + test_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_TEST_PROXY_AUTH); + if(test_auth_property) + { + test_auth_property_value = (axis2_char_t *)axutil_property_get_value(test_auth_property, + env); + } + + if(test_auth_property_value && 0 == axutil_strcmp(test_auth_property_value, AXIS2_VALUE_TRUE)) + { + test_proxy_auth = AXIS2_TRUE; + } + + test_auth_property = NULL; + test_auth_property_value = NULL; + + test_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_TEST_HTTP_AUTH); + if(test_auth_property) + { + test_auth_property_value = (axis2_char_t *)axutil_property_get_value(test_auth_property, + env); + } + + if(test_auth_property_value && 0 == axutil_strcmp(test_auth_property_value, AXIS2_VALUE_TRUE)) + { + test_http_auth = AXIS2_TRUE; + } + + if(!test_proxy_auth) + { + proxy_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_FORCE_PROXY_AUTH); + } + if(proxy_auth_property) + { + proxy_auth_property_value = (axis2_char_t *)axutil_property_get_value(proxy_auth_property, + env); + } + + if(proxy_auth_property_value && 0 == axutil_strcmp(proxy_auth_property_value, AXIS2_VALUE_TRUE)) + { + force_proxy_auth = AXIS2_TRUE; + } + + proxy_auth_property = NULL; + proxy_auth_property_value = NULL; + + if(force_proxy_auth) + { + proxy_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_PROXY_AUTH_TYPE); + } + + if(proxy_auth_property) + { + proxy_auth_property_value = (axis2_char_t *)axutil_property_get_value(proxy_auth_property, + env); + } + + if(proxy_auth_property_value && 0 == axutil_strcmp(proxy_auth_property_value, + AXIS2_PROXY_AUTH_TYPE_DIGEST)) + { + force_proxy_auth = AXIS2_FALSE; + force_proxy_auth_with_head = AXIS2_TRUE; + } + + if(!test_http_auth) + { + http_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_FORCE_HTTP_AUTH); + } + + if(http_auth_property) + { + http_auth_property_value = (axis2_char_t *)axutil_property_get_value(http_auth_property, + env); + } + + if(http_auth_property_value && 0 == axutil_strcmp(http_auth_property_value, AXIS2_VALUE_TRUE)) + { + force_http_auth = AXIS2_TRUE; + } + + http_auth_property = NULL; + http_auth_property_value = NULL; + + if(force_http_auth) + { + http_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_HTTP_AUTH_TYPE); + } + + if(http_auth_property) + { + http_auth_property_value = (axis2_char_t *)axutil_property_get_value(http_auth_property, + env); + } + + if(http_auth_property_value && 0 == axutil_strcmp(http_auth_property_value, + AXIS2_HTTP_AUTH_TYPE_DIGEST)) + { + force_http_auth = AXIS2_FALSE; + force_http_auth_with_head = AXIS2_TRUE; + } + + axis2_msg_ctx_set_auth_type(msg_ctx, env, NULL); + + if(force_proxy_auth || force_proxy_auth_with_head) + { + status_code = AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL; + } + else + { + /* NOT forcing proxy authentication */ + if(force_http_auth) + { + axis2_status_t auth_status; + auth_status = axis2_http_sender_configure_http_auth(sender, env, msg_ctx, request); + + if(auth_status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in setting HTTP Authentication header"); + } + http_auth_header_added = AXIS2_TRUE; + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + } + + else if(force_http_auth_with_head) + { + axis2_http_request_line_t *head_request_line = NULL; + axis2_http_request_line_t *temp = NULL; + + temp = axis2_http_simple_request_get_request_line(request, env); + head_request_line = axis2_http_request_line_create(env, AXIS2_HTTP_HEAD, + axis2_http_request_line_get_uri(temp, env), + axis2_http_request_line_get_http_version(temp, env)); + axis2_http_simple_request_set_request_line(request, env, head_request_line); + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + axis2_http_simple_request_set_request_line(request, env, temp); + axis2_http_request_line_free(head_request_line, env); + + if(status_code == AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL) + { + axis2_status_t auth_status; + auth_status = axis2_http_sender_configure_http_auth(sender, env, msg_ctx, request); + + if(auth_status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in setting HTTP Authentication\ + header"); + } + http_auth_header_added = AXIS2_TRUE; + } + + if(status_code != AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL) + { + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + + if(status_code == AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL) + { + http_auth_header_added = AXIS2_FALSE; + force_http_auth_with_head = AXIS2_FALSE; + } + } + } + else + { + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + } + } + + if(AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL == status_code + && !test_proxy_auth) + { + if(force_proxy_auth_with_head) + { + axis2_http_request_line_t *head_request_line = NULL; + axis2_http_request_line_t *temp = NULL; + + temp = axis2_http_simple_request_get_request_line(request, env); + head_request_line = axis2_http_request_line_create(env, AXIS2_HTTP_HEAD, + axis2_http_request_line_get_uri(temp, env), + axis2_http_request_line_get_http_version(temp, env)); + axis2_http_simple_request_set_request_line(request, env, head_request_line); + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + axis2_http_simple_request_set_request_line(request, env, temp); + axis2_http_request_line_free(head_request_line, env); + + if(status_code == AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL) + { + axis2_status_t auth_status; + auth_status = axis2_http_sender_configure_proxy_auth(sender, env, msg_ctx, request); + + if(auth_status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in setting Proxy Authentication\ + header"); + } + + if((force_http_auth_with_head || force_http_auth) && !http_auth_header_added) + { + status_code = AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL; + } + else + { + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + } + } + else if(status_code != AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL) + { + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + } + + /* Proxies have no idea about HTTP Methods therefore, if + * it fails no need to re-check */ + if(AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL == status_code) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Proxy Authentication failed"); + axis2_msg_ctx_set_auth_failed(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_required_auth_is_http(msg_ctx, env, AXIS2_FALSE); + } + } + else + { + + /* not forcing proxy auth with head */ + axis2_status_t auth_status; + auth_status = axis2_http_sender_configure_proxy_auth(sender, env, msg_ctx, request); + + if(auth_status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in setting Proxy Authentication \ +header"); + } + + if((force_http_auth_with_head || force_http_auth) && !http_auth_header_added) + { + status_code = AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL; + } + else + { + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + + if(AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL == status_code) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Proxy Authentication failed"); + axis2_msg_ctx_set_auth_failed(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_required_auth_is_http(msg_ctx, env, AXIS2_FALSE); + } + } + } + } + else if(AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL == status_code) + { + axis2_msg_ctx_set_auth_failed(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_required_auth_is_http(msg_ctx, env, AXIS2_FALSE); + axis2_http_sender_set_proxy_auth_type(sender, env, msg_ctx, request); + } + + if(AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL == status_code && !test_http_auth) + { + if(!http_auth_header_added) + { + if(force_proxy_auth_with_head) + { + axis2_http_request_line_t *head_request_line = NULL; + axis2_http_request_line_t *temp = NULL; + + temp = axis2_http_simple_request_get_request_line(request, env); + head_request_line = axis2_http_request_line_create(env, AXIS2_HTTP_HEAD, + axis2_http_request_line_get_uri(temp, env), + axis2_http_request_line_get_http_version(temp, env)); + axis2_http_simple_request_set_request_line(request, env, head_request_line); + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + axis2_http_simple_request_set_request_line(request, env, temp); + axis2_http_request_line_free(head_request_line, env); + + if(status_code == AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL) + { + axis2_status_t auth_status; + auth_status = axis2_http_sender_configure_http_auth(sender, env, msg_ctx, + request); + + if(auth_status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in setting HTTP Authentication \ +header"); + } + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + if(status_code == AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL) + { + axis2_status_t auth_status; + auth_status = axis2_http_sender_configure_http_auth(sender, env, msg_ctx, + request); + + if(auth_status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in setting HTTP \ +Authentication header"); + } + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + } + + } + } + else + { + axis2_status_t auth_status; + auth_status = axis2_http_sender_configure_http_auth(sender, env, msg_ctx, request); + + if(auth_status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in setting HTTP Authentication \ +header"); + } + + status_code = axis2_http_client_send(sender->client, env, request, ssl_pp); + + status_code = axis2_http_client_recieve_header(sender->client, env); + } + + if(AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL == status_code) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "HTTP Authentication failed"); + axis2_msg_ctx_set_auth_failed(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_required_auth_is_http(msg_ctx, env, AXIS2_TRUE); + } + + if(AXIS2_HTTP_RESPONSE_PROXY_AUTHENTICATION_REQUIRED_CODE_VAL == status_code) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Proxy Authentication failed"); + axis2_msg_ctx_set_auth_failed(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_required_auth_is_http(msg_ctx, env, AXIS2_FALSE); + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "HTTP Authentication failed"); + axis2_msg_ctx_set_auth_failed(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_required_auth_is_http(msg_ctx, env, AXIS2_TRUE); + } + } + else if(AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL == status_code) + { + axis2_msg_ctx_set_auth_failed(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_required_auth_is_http(msg_ctx, env, AXIS2_TRUE); + axis2_http_sender_set_http_auth_type(sender, env, msg_ctx, request); + } + + axis2_http_simple_request_free(request, env); + request = NULL; + + if(output_stream) + { + AXIS2_FREE(env->allocator, output_stream); + output_stream = NULL; + } + + if(status_code < 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "status_code < 0"); + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_status_code(msg_ctx, env, status_code); + + /* Start processing response */ + response = axis2_http_client_get_response(sender->client, env); + if(!is_soap) + { + return axis2_http_sender_process_response(sender, env, msg_ctx, response); + } + else if(AXIS2_HTTP_RESPONSE_OK_CODE_VAL == status_code || AXIS2_HTTP_RESPONSE_ACK_CODE_VAL + == status_code) + { + return axis2_http_sender_process_response(sender, env, msg_ctx, response); + } + else if(AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL == status_code) + { + axis2_http_header_t *tmp_header = NULL; + axis2_char_t *tmp_header_val = NULL; + axis2_op_t *op = NULL; + + op = axis2_msg_ctx_get_op(msg_ctx, env); + if(op) + { + const axis2_char_t *mep = axis2_op_get_msg_exchange_pattern(op, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + /* handle one way case */ + + if(!axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "mep is AXIS2_MEP_URI_OUT_ONLY"); + return AXIS2_FAILURE; + } + } + + /* set an error to indicate error code status */ + tmp_header = axis2_http_simple_response_get_first_header(response, env, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(tmp_header) + { + tmp_header_val = axis2_http_header_get_value(tmp_header, env); + } + + if(tmp_header_val && (axutil_strstr(tmp_header_val, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP) + || axutil_strstr(tmp_header_val, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML))) + { + return axis2_http_sender_process_response(sender, env, msg_ctx, response); + } + } + + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_sender_send"); + return AXIS2_FAILURE; +} +#endif + +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) +{ + sender->chunked = chunked; + return AXIS2_SUCCESS; +} + +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) +{ + sender->om_output = om_output; + return AXIS2_SUCCESS; +} + +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) +{ + axutil_array_list_t *headers = NULL; + axis2_char_t *charset = NULL; + int i = 0; + axis2_bool_t response_chunked = AXIS2_FALSE; + int *content_length = NULL; + axutil_property_t *property = NULL; + axis2_char_t *content_type = NULL; + int status_code = 0; + axis2_bool_t set_cookie_header_present = AXIS2_FALSE; + axis2_bool_t connection_header_present = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, response, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, sender, AXIS2_FAILURE); + + headers = axis2_http_simple_response_get_headers(response, env); + if(headers == NULL) + { + return AXIS2_SUCCESS; + } + + for(i = 0; i < axutil_array_list_size(headers, env); i++) + { + axis2_http_header_t *header = axutil_array_list_get(headers, env, i); + axis2_char_t *name = axis2_http_header_get_name((axis2_http_header_t *)header, env); + if(name) + { + if(0 == axutil_strcasecmp(name, AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && 0 + == axutil_strcasecmp(axis2_http_header_get_value(header, env), + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + axis2_char_t *transfer_encoding = NULL; + transfer_encoding = axutil_strdup(env, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED); + response_chunked = AXIS2_TRUE; + axis2_msg_ctx_set_transfer_encoding(msg_ctx, env, transfer_encoding); + + } + if(0 != axutil_strcasecmp(name, AXIS2_HTTP_HEADER_CONTENT_TYPE)) + { + axis2_char_t *tmp_charset = NULL; + axis2_char_t *content_type = axis2_http_header_get_value(header, env); + tmp_charset = strstr(content_type, AXIS2_HTTP_CHAR_SET_ENCODING); + if(charset) + { + charset = axutil_strdup(env, tmp_charset); + break; + } + } + if(!axutil_strcasecmp(name, AXIS2_HTTP_HEADER_SET_COOKIE)) + { + axis2_char_t *cookie_str = axis2_http_header_get_value(header, env); + if(cookie_str) + { + axis2_http_transport_utils_store_cookie(env, msg_ctx, cookie_str); + } + set_cookie_header_present = AXIS2_TRUE; + } + + if(!axutil_strcasecmp(name, AXIS2_HTTP_HEADER_CONNECTION)) + { + axis2_char_t *connection_header_value = NULL; + axutil_property_t *connection_map_property = NULL; + axutil_hash_t *connection_map = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + connection_header_present = AXIS2_TRUE; + connection_header_value = axis2_http_header_get_value(header, env); + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + connection_map_property = axis2_conf_ctx_get_property(conf_ctx, env, + AXIS2_HTTP_CONNECTION_MAP); + + if(connection_map_property) + { + connection_map = axutil_property_get_value(connection_map_property, env); + } + /** + * In HTTP1.1 if connection header has value close then drop the connection + */ + if(connection_header_value && !axutil_strcasecmp(connection_header_value, "close")) + { + if(connection_map) + { + axis2_http_sender_connection_map_remove(connection_map, env, + msg_ctx, sender->client); + } + } + else if(connection_header_value && !axutil_strcasecmp(connection_header_value, + "Keep-Alive")) + { + if(connection_map) + { + axis2_http_sender_connection_map_add(connection_map, env, + msg_ctx, sender->client); + } + } + } /* End if name is connection */ + } /* End if name of the header present */ + } + if(!set_cookie_header_present) /* We need to remove any cookie set previously for this endpoint */ + { + axis2_http_transport_utils_store_cookie(env, msg_ctx, NULL); + } + if(!connection_header_present) /* No connection header present */ + { + /** In HTTP1.0 if there is no keep alive header sent back from server we drop the + * connection + */ + axutil_property_t *connection_map_property = NULL; + axutil_hash_t *connection_map = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + connection_map_property = axis2_conf_ctx_get_property(conf_ctx, env, + AXIS2_HTTP_CONNECTION_MAP); + if(connection_map_property) + { + connection_map = axutil_property_get_value(connection_map_property, env); + } /* End if connectin_map_property */ + if(!axutil_strcasecmp(sender->http_version, AXIS2_HTTP_HEADER_PROTOCOL_10)) + { + if(connection_map) + { + axis2_http_sender_connection_map_remove(connection_map, env, msg_ctx, + sender->client); + } + } /* End if http version 1.0 */ + else if(!axutil_strcasecmp(sender->http_version, AXIS2_HTTP_HEADER_PROTOCOL_11)) + { + /** + * If keep alive enabled we store the http client for reuse. + */ + if(connection_map) + { + axis2_http_sender_connection_map_add(connection_map, env, msg_ctx, + sender->client); + } + } /* End if http version 1.1 */ + } /* End if !connection_header_present */ + + content_type = (axis2_char_t *)axis2_http_simple_response_get_content_type(response, env); + if(content_type) + { + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED) && strstr(content_type, + AXIS2_HTTP_HEADER_ACCEPT_XOP_XML)) + { + axis2_ctx_t *axis_ctx = axis2_op_ctx_get_base(axis2_msg_ctx_get_op_ctx(msg_ctx, env), + env); + property = axutil_property_create(env); + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value(property, env, axutil_strdup(env, content_type)); + axis2_ctx_set_property(axis_ctx, env, MTOM_RECIVED_CONTENT_TYPE, property); + } + } + + if(charset) + { + axis2_ctx_t *axis_ctx = axis2_op_ctx_get_base(axis2_msg_ctx_get_op_ctx(msg_ctx, env), env); + if(axis_ctx) + { + property = axutil_property_create(env); + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value(property, env, charset); + axis2_ctx_set_property(axis_ctx, env, AXIS2_CHARACTER_SET_ENCODING, property); + } + } + + if(AXIS2_FALSE == response_chunked) + { + int tmp_len = 0; + content_length = AXIS2_MALLOC(env->allocator, sizeof(int)); + if(!content_length) + { + return AXIS2_FAILURE; + } + tmp_len = axis2_http_simple_response_get_content_length(response, env); + memcpy(content_length, &tmp_len, sizeof(int)); + property = axutil_property_create(env); + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value(property, env, content_length); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_HEADER_CONTENT_LENGTH, property); + } + + status_code = axis2_http_simple_response_get_status_code(response, env); + return AXIS2_SUCCESS; +} + +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) +{ + axutil_stream_t *in_stream = NULL; + axutil_property_t *property = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_sender_process_response"); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, response, AXIS2_FAILURE); + + in_stream = axis2_http_simple_response_get_body(response, env); + if(!in_stream) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_STREAM_IN_RESPONSE_BODY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + axis2_http_sender_get_header_info(sender, env, msg_ctx, response); + axis2_msg_ctx_set_http_output_headers(msg_ctx, env, axis2_http_simple_response_extract_headers( + response, env)); + property = axutil_property_create(env); + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_free_func(property, env, axutil_stream_free_void_arg); + axutil_property_set_value(property, env, in_stream); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, property); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_sender_process_response"); + return AXIS2_SUCCESS; +} + +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_char_t *so_str = NULL; + axis2_char_t *connection_str = NULL; + axutil_param_t *tmp_param = NULL; + axutil_property_t *property = NULL; + + AXIS2_PARAM_CHECK(env->error, sender, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + /* check if timeout has been set by user using options + * with axis2_options_set_timeout_in_milli_seconds + */ + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_CONNECTION_TIMEOUT); + if(property) + { + axis2_char_t *value = axutil_property_get_value(property, env); + if(value) + { + sender->so_timeout = AXIS2_ATOI(value); + return AXIS2_SUCCESS; + } + } + + tmp_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_HTTP_SO_TIMEOUT); + + if(tmp_param) + { + so_str = (axis2_char_t *)axutil_param_get_value(tmp_param, env); + if(so_str) + { + sender->so_timeout = AXIS2_ATOI(so_str); + return AXIS2_SUCCESS; + } + } + + tmp_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_HTTP_CONNECTION_TIMEOUT); + if(tmp_param) + { + connection_str = (axis2_char_t *)axutil_param_get_value(tmp_param, env); + if(connection_str) + { + sender->so_timeout = AXIS2_ATOI(connection_str); + return AXIS2_SUCCESS; + } + } + return 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) +{ + sender->http_version = axutil_strdup(env, version); + if(!sender->http_version) + { + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} + +#ifndef AXIS2_LIBCURL_ENABLED +static void +axis2_http_sender_add_header_list( + axis2_http_simple_request_t * request, + const axutil_env_t * env, + axutil_array_list_t * array_list) +{ + int ii = 0; + int kk = 0; + axis2_http_header_t *http_header = NULL; + ii = axutil_array_list_size(array_list, env); + for(; kk < ii; kk++) + { + http_header = (axis2_http_header_t *)axutil_array_list_get(array_list, env, kk); + axis2_http_simple_request_add_header(request, env, http_header); + } +} + +static axis2_status_t +axis2_http_sender_configure_proxy( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *proxy_param = NULL; + axutil_hash_t *transport_attrs = NULL; + axis2_char_t *proxy_host = NULL; + axis2_char_t *proxy_port = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(!conf_ctx) + { + return AXIS2_FAILURE; + } + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(!conf) + { + return AXIS2_FAILURE; + } + + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + if(!trans_desc) + { + return AXIS2_FAILURE; + } + + proxy_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container( + trans_desc, env), env, AXIS2_HTTP_PROXY_API); + if(!proxy_param) + { + proxy_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container( + trans_desc, env), env, AXIS2_HTTP_PROXY); + } + if(proxy_param) + { + transport_attrs = axutil_param_get_attributes(proxy_param, env); + if(transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *host_attr = NULL; + axiom_attribute_t *port_attr = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_HOST, AXIS2_HASH_KEY_STRING); + if(!obj) + { + return AXIS2_FAILURE; + } + host_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + if(!host_attr) + { + return AXIS2_FAILURE; + } + proxy_host = axiom_attribute_get_value(host_attr, env); + if(!proxy_host) + { + return AXIS2_FAILURE; + } + /* Now we get the port */ + obj = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PORT, AXIS2_HASH_KEY_STRING); + port_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + if(!port_attr) + { + return AXIS2_FAILURE; + } + proxy_port = axiom_attribute_get_value(port_attr, env); + if(!proxy_port) + { + return AXIS2_FAILURE; + } + } + } + if(proxy_port && proxy_host) + { + axis2_http_client_set_proxy(sender->client, env, proxy_host, AXIS2_ATOI(proxy_port)); + } + return AXIS2_SUCCESS; +} +#endif + +#ifndef AXIS2_LIBCURL_ENABLED +static axis2_status_t +axis2_http_sender_configure_server_cert( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axutil_property_t *server_cert_property = NULL; + axutil_param_t *server_cert_param = NULL; + axis2_char_t *server_cert = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + server_cert_property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SSL_SERVER_CERT); + if(server_cert_property) + { + server_cert = (axis2_char_t *)axutil_property_get_value(server_cert_property, env); + } + else + { + server_cert_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_SSL_SERVER_CERT); + if(server_cert_param) + { + server_cert = (axis2_char_t *)axutil_param_get_value(server_cert_param, env); + } + } + + if(server_cert) + { + status = axis2_http_client_set_server_cert(sender->client, env, server_cert); + } + + return status; +} +#endif + +#ifndef AXIS2_LIBCURL_ENABLED +static axis2_status_t +axis2_http_sender_configure_key_file( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axutil_property_t *key_file_property = NULL; + axutil_param_t *key_file_param = NULL; + axis2_char_t *key_file = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + key_file_property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SSL_KEY_FILE); + if(key_file_property) + { + key_file = (axis2_char_t *)axutil_property_get_value(key_file_property, env); + } + else + { + key_file_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_SSL_KEY_FILE); + if(key_file_param) + { + key_file = (axis2_char_t *)axutil_param_get_value(key_file_param, env); + } + } + + if(key_file) + { + status = axis2_http_client_set_key_file(sender->client, env, key_file); + } + + return status; +} +#endif + +#ifndef AXIS2_LIBCURL_ENABLED +static axis2_status_t +axis2_http_sender_configure_http_basic_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request) +{ + axutil_property_t *http_auth_un = NULL; + axutil_property_t *http_auth_pw = NULL; + axis2_char_t *uname = NULL; + axis2_char_t *passwd = NULL; + + http_auth_un = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_AUTH_UNAME); + http_auth_pw = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_AUTH_PASSWD); + if(http_auth_un && http_auth_pw) + { + uname = (axis2_char_t *)axutil_property_get_value(http_auth_un, env); + passwd = (axis2_char_t *)axutil_property_get_value(http_auth_pw, env); + } + if(!uname || !passwd) + { + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *http_auth_param = NULL; + axutil_hash_t *transport_attrs = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + } + } + if(trans_desc) + { + http_auth_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, + AXIS2_HTTP_AUTHENTICATION); + if(http_auth_param) + { + transport_attrs = axutil_param_get_attributes(http_auth_param, env); + if(transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *username_attr = NULL; + axiom_attribute_t *password_attr = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_AUTHENTICATION_USERNAME, + AXIS2_HASH_KEY_STRING); + if(obj) + { + username_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(username_attr) + { + uname = axiom_attribute_get_value(username_attr, env); + } + obj = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_AUTHENTICATION_PASSWORD, + AXIS2_HASH_KEY_STRING); + if(obj) + { + password_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(password_attr) + { + passwd = axiom_attribute_get_value(password_attr, env); + } + } + } + } + } + if(uname && passwd) + { + int elen; + int plen = axutil_strlen(uname) + axutil_strlen(passwd) + 1; + axis2_char_t *to_encode = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * plen + 1)); + axis2_char_t *encoded = NULL; + axis2_char_t *auth_str = NULL; + sprintf(to_encode, "%s:%s", uname, passwd); + elen = axutil_base64_encode_len(plen); + encoded = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * elen)); + auth_str + = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (elen + 6))); + axutil_base64_encode(encoded, to_encode, plen); + sprintf(auth_str, "%s %s", AXIS2_HTTP_AUTH_TYPE_BASIC, encoded); + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_AUTHORIZATION, auth_str); + + AXIS2_FREE(env->allocator, to_encode); + to_encode = NULL; + AXIS2_FREE(env->allocator, encoded); + encoded = NULL; + AXIS2_FREE(env->allocator, auth_str); + auth_str = NULL; + + return AXIS2_SUCCESS; + } + + return AXIS2_FAILURE; + +} + +static axis2_status_t +axis2_http_sender_configure_proxy_basic_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request) +{ + axutil_property_t *proxy_auth_un = NULL; + axutil_property_t *proxy_auth_pw = NULL; + axis2_char_t *uname = NULL; + axis2_char_t *passwd = NULL; + + proxy_auth_un = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_UNAME); + proxy_auth_pw = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_PASSWD); + + if(proxy_auth_un && proxy_auth_pw) + { + uname = (axis2_char_t *)axutil_property_get_value(proxy_auth_un, env); + passwd = (axis2_char_t *)axutil_property_get_value(proxy_auth_pw, env); + } + if(!uname || !passwd) + { + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *proxy_param = NULL; + axutil_hash_t *transport_attrs = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + } + } + if(trans_desc) + { + proxy_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, + AXIS2_HTTP_PROXY_API); + if(!proxy_param) + { + proxy_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, + AXIS2_HTTP_PROXY); + } + if(proxy_param) + { + transport_attrs = axutil_param_get_attributes(proxy_param, env); + if(transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *username_attr = NULL; + axiom_attribute_t *password_attr = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_USERNAME, + AXIS2_HASH_KEY_STRING); + if(obj) + { + username_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(username_attr) + { + uname = axiom_attribute_get_value(username_attr, env); + } + obj = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PASSWORD, + AXIS2_HASH_KEY_STRING); + if(obj) + { + password_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(password_attr) + { + passwd = axiom_attribute_get_value(password_attr, env); + } + } + } + } + } + if(uname && passwd) + { + int elen; + int plen = axutil_strlen(uname) + axutil_strlen(passwd) + 1; + axis2_char_t *to_encode = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * plen + 1)); + axis2_char_t *encoded = NULL; + axis2_char_t *auth_str = NULL; + sprintf(to_encode, "%s:%s", uname, passwd); + elen = axutil_base64_encode_len(plen); + encoded = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * elen)); + auth_str + = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (elen + 6))); + axutil_base64_encode(encoded, to_encode, plen); + sprintf(auth_str, "%s %s", AXIS2_PROXY_AUTH_TYPE_BASIC, encoded); + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_PROXY_AUTHORIZATION, + auth_str); + + AXIS2_FREE(env->allocator, to_encode); + to_encode = NULL; + AXIS2_FREE(env->allocator, encoded); + encoded = NULL; + AXIS2_FREE(env->allocator, auth_str); + auth_str = NULL; + + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} +#endif + +#ifndef AXIS2_LIBCURL_ENABLED +static axis2_status_t +axis2_http_sender_configure_http_digest_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request, + axis2_char_t * header_data) +{ + axutil_property_t *http_auth_un = NULL; + axutil_property_t *http_auth_pw = NULL; + axis2_char_t *uname = NULL; + axis2_char_t *passwd = NULL; + + if(!header_data || !*header_data) + return AXIS2_FAILURE; + + http_auth_un = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_AUTH_UNAME); + http_auth_pw = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_AUTH_PASSWD); + if(http_auth_un && http_auth_pw) + { + uname = (axis2_char_t *)axutil_property_get_value(http_auth_un, env); + passwd = (axis2_char_t *)axutil_property_get_value(http_auth_pw, env); + } + if(!uname || !passwd) + { + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *http_auth_param = NULL; + axutil_hash_t *transport_attrs = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + } + } + if(trans_desc) + { + http_auth_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, + AXIS2_HTTP_AUTHENTICATION); + if(http_auth_param) + { + transport_attrs = axutil_param_get_attributes(http_auth_param, env); + if(transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *username_attr = NULL; + axiom_attribute_t *password_attr = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_AUTHENTICATION_USERNAME, + AXIS2_HASH_KEY_STRING); + if(obj) + { + username_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(username_attr) + { + uname = axiom_attribute_get_value(username_attr, env); + } + obj = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_AUTHENTICATION_PASSWORD, + AXIS2_HASH_KEY_STRING); + if(obj) + { + password_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(password_attr) + { + passwd = axiom_attribute_get_value(password_attr, env); + } + } + } + } + } + if(uname && passwd) + { + int elen = 0; /* length of header content */ + int print_const = 5; /* constant accounts for printing the + quoatation marks, comma, and space */ + int response_length = 32; + axis2_char_t *temp = NULL; + axis2_char_t *alloc_temp = NULL; + axis2_char_t *algo = AXIS2_HTTP_AUTHORIZATION_REQUEST_ALGORITHM_MD5; + axis2_char_t *realm = NULL; + axis2_char_t *qop = NULL; + axis2_char_t *nonce = NULL; + axis2_char_t *opaque = NULL; + axis2_char_t *cnonce = NULL; + axis2_char_t *nc = NULL; + axutil_digest_hash_hex_t h_a1; + axutil_digest_hash_hex_t h_a2; + axutil_digest_hash_hex_t response; + axis2_char_t *auth_str = NULL; + axutil_property_t *method = NULL; + axis2_char_t *method_value = NULL; + axis2_char_t *url = NULL; + + url = axis2_http_request_line_get_uri(axis2_http_simple_request_get_request_line(request, + env), env); + + if(!url) + { + return AXIS2_FAILURE; + } + + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_URI) + + axutil_strlen(url); + + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_USERNAME) + + axutil_strlen(uname); + + method = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_METHOD); + if(method) + { + method_value = (axis2_char_t *)axutil_property_get_value(method, env); + } + else + { + method_value = AXIS2_HTTP_POST; + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM); + if(temp) + { + realm = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(realm) + { + realm++; + temp = axutil_strchr(realm, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - realm + 1))); + strncpy(alloc_temp, realm, (temp - realm)); + if(alloc_temp) + alloc_temp[temp - realm] = AXIS2_ESC_NULL; + realm = alloc_temp; + alloc_temp = NULL; + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM) + + axutil_strlen(realm); + } + else + { + return AXIS2_FAILURE; + } + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP); + if(temp) + { + qop = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(qop) + { + qop++; + temp = axutil_strchr(qop, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - qop + 1))); + strncpy(alloc_temp, qop, (temp - qop)); + if(alloc_temp) + alloc_temp[temp - qop] = AXIS2_ESC_NULL; + qop = alloc_temp; + alloc_temp = NULL; + } + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE); + if(temp) + { + nonce = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(nonce) + { + nonce++; + temp = axutil_strchr(nonce, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - nonce + 1))); + strncpy(alloc_temp, nonce, (temp - nonce)); + if(alloc_temp) + alloc_temp[temp - nonce] = AXIS2_ESC_NULL; + nonce = alloc_temp; + alloc_temp = NULL; + + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE) + + axutil_strlen(nonce); + } + else + { + if(realm) + AXIS2_FREE(env->allocator, realm); + return AXIS2_FAILURE; + } + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE); + if(temp) + { + opaque = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(opaque) + { + opaque++; + temp = axutil_strchr(opaque, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - opaque + 1))); + strncpy(alloc_temp, opaque, (temp - opaque)); + if(alloc_temp) + alloc_temp[temp - opaque] = AXIS2_ESC_NULL; + opaque = alloc_temp; + alloc_temp = NULL; + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE) + + axutil_strlen(opaque); + } + else + { + if(realm) + AXIS2_FREE(env->allocator, realm); + if(nonce) + AXIS2_FREE(env->allocator, nonce); + return AXIS2_FAILURE; + } + } + + if(qop) + { + nc = AXIS2_HTTP_AUTHORIZATION_REQUEST_DEFAULT_CLIENT_NONCE; + temp = qop; + if(!axutil_strstr(temp, AXIS2_HTTP_AUTHORIZATION_REQUEST_QOP_OPTION_AUTH)) + { + return AXIS2_FAILURE; + } + AXIS2_FREE(env->allocator, qop); + qop = AXIS2_HTTP_AUTHORIZATION_REQUEST_QOP_OPTION_AUTH; + temp = axutil_uuid_gen(env); + cnonce = temp; + temp += CLIENT_NONCE_LENGTH; + if(temp) + *temp = AXIS2_ESC_NULL; + elen += 11 + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_DEFAULT_CLIENT_NONCE) + + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT) + + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE) + + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP) + CLIENT_NONCE_LENGTH + + axutil_strlen(qop); + } + + axutil_digest_calc_get_h_a1(env, algo, uname, realm, passwd, cnonce, nonce, h_a1); + axutil_digest_calc_get_response(env, h_a1, nonce, nc, cnonce, qop, method_value, url, h_a2, + response); + + elen += 4 + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_RESPONSE) + axutil_strlen( + AXIS2_HTTP_AUTH_TYPE_DIGEST) + response_length; + + auth_str + = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (elen + 1))); + temp = auth_str; + sprintf(temp, "%s %s=\"%s\", ", AXIS2_HTTP_AUTH_TYPE_DIGEST, + AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_USERNAME, uname); + temp += ((int)strlen(AXIS2_HTTP_AUTH_TYPE_DIGEST) + (int)strlen( + AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_USERNAME) + (int)strlen(uname) + 6); + if(realm) + { + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM, realm); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM) + (int)strlen(realm) + + 5); + } + if(nonce) + { + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE, nonce); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE) + (int)strlen(nonce) + + 5); + } + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_URI, url); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_URI) + (int)strlen(url) + 5); + if(qop) + { + sprintf(temp, "%s=%s, %s=%s, %s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP, + qop, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT, nc, + AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE, cnonce); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP) + (int)strlen(qop) + + (int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT) + (int)strlen(nc) + + (int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE) + (int)strlen( + cnonce) + 11); + } + if(opaque) + { + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE, opaque); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE) + (int)strlen( + opaque) + 5); + } + sprintf(temp, "%s=\"%s\"", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_RESPONSE, response); + + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_AUTHORIZATION, auth_str); + if(realm) + AXIS2_FREE(env->allocator, realm); + if(nonce) + AXIS2_FREE(env->allocator, nonce); + if(cnonce) + AXIS2_FREE(env->allocator, cnonce); + if(opaque) + AXIS2_FREE(env->allocator, opaque); + if(auth_str) + AXIS2_FREE(env->allocator, auth_str); + auth_str = NULL; + + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +static axis2_status_t +axis2_http_sender_configure_proxy_digest_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request, + axis2_char_t * header_data) +{ + axutil_property_t *proxy_auth_un = NULL; + axutil_property_t *proxy_auth_pw = NULL; + axis2_char_t *uname = NULL; + axis2_char_t *passwd = NULL; + + if(!header_data || !*header_data) + return AXIS2_FAILURE; + + proxy_auth_un = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_UNAME); + proxy_auth_pw = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_PASSWD); + + if(proxy_auth_un && proxy_auth_pw) + { + uname = (axis2_char_t *)axutil_property_get_value(proxy_auth_un, env); + passwd = (axis2_char_t *)axutil_property_get_value(proxy_auth_pw, env); + } + if(!uname || !passwd) + { + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *proxy_param = NULL; + axutil_hash_t *transport_attrs = NULL; + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + } + } + if(trans_desc) + { + proxy_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, + AXIS2_HTTP_PROXY_API); + if(!proxy_param) + { + proxy_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, + AXIS2_HTTP_PROXY); + } + if(proxy_param) + { + transport_attrs = axutil_param_get_attributes(proxy_param, env); + + if(transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *username_attr = NULL; + axiom_attribute_t *password_attr = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_USERNAME, + AXIS2_HASH_KEY_STRING); + if(obj) + { + username_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(username_attr) + { + uname = axiom_attribute_get_value(username_attr, env); + } + + obj = NULL; + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PASSWORD, + AXIS2_HASH_KEY_STRING); + if(obj) + { + password_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if(password_attr) + { + passwd = axiom_attribute_get_value(password_attr, env); + } + } + } + } + } + if(uname && passwd) + { + int elen = 0; /* length of header content */ + int print_const = 5; /* constant accounts for printing the + quoatation marks, comma, and space */ + int response_length = 32; + axis2_char_t *temp = NULL; + axis2_char_t *alloc_temp = NULL; + axis2_char_t *algo = AXIS2_HTTP_AUTHORIZATION_REQUEST_ALGORITHM_MD5; + axis2_char_t *realm = NULL; + axis2_char_t *qop = NULL; + axis2_char_t *nonce = NULL; + axis2_char_t *opaque = NULL; + axis2_char_t *cnonce = NULL; + axis2_char_t *nc = NULL; + axutil_digest_hash_hex_t h_a1; + axutil_digest_hash_hex_t h_a2; + axutil_digest_hash_hex_t response; + axis2_char_t *auth_str = NULL; + axutil_property_t *method = NULL; + axis2_char_t *method_value = NULL; + axis2_char_t *url = NULL; + + url = axis2_http_request_line_get_uri(axis2_http_simple_request_get_request_line(request, + env), env); + + if(!url) + { + return AXIS2_FAILURE; + } + + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_URI) + + axutil_strlen(url); + + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_USERNAME) + + axutil_strlen(uname); + + method = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_METHOD); + if(method) + { + method_value = (axis2_char_t *)axutil_property_get_value(method, env); + } + else + { + method_value = AXIS2_HTTP_POST; + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM); + if(temp) + { + realm = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(realm) + { + realm++; + temp = axutil_strchr(realm, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - realm + 1))); + strncpy(alloc_temp, realm, (temp - realm)); + if(alloc_temp) + alloc_temp[temp - realm] = AXIS2_ESC_NULL; + realm = alloc_temp; + alloc_temp = NULL; + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM) + + axutil_strlen(realm); + } + else + { + return AXIS2_FAILURE; + } + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP); + if(temp) + { + qop = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(qop) + { + qop++; + temp = axutil_strchr(qop, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - qop + 1))); + strncpy(alloc_temp, qop, (temp - qop)); + if(alloc_temp) + alloc_temp[temp - qop] = AXIS2_ESC_NULL; + qop = alloc_temp; + alloc_temp = NULL; + } + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE); + if(temp) + { + nonce = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(nonce) + { + nonce++; + temp = axutil_strchr(nonce, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - nonce + 1))); + strncpy(alloc_temp, nonce, (temp - nonce)); + if(alloc_temp) + alloc_temp[temp - nonce] = AXIS2_ESC_NULL; + nonce = alloc_temp; + alloc_temp = NULL; + + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE) + + axutil_strlen(nonce); + } + else + { + if(realm) + AXIS2_FREE(env->allocator, realm); + return AXIS2_FAILURE; + } + } + + temp = axutil_strstr(header_data, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE); + if(temp) + { + opaque = axutil_strchr(temp, AXIS2_ESC_DOUBLE_QUOTE); + if(opaque) + { + opaque++; + temp = axutil_strchr(opaque, AXIS2_ESC_DOUBLE_QUOTE); + alloc_temp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) + * (temp - opaque + 1))); + strncpy(alloc_temp, opaque, (temp - opaque)); + if(alloc_temp) + alloc_temp[temp - opaque] = AXIS2_ESC_NULL; + opaque = alloc_temp; + alloc_temp = NULL; + elen += print_const + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE) + + axutil_strlen(opaque); + } + else + { + if(realm) + AXIS2_FREE(env->allocator, realm); + if(nonce) + AXIS2_FREE(env->allocator, nonce); + return AXIS2_FAILURE; + } + } + + if(qop) + { + nc = AXIS2_HTTP_AUTHORIZATION_REQUEST_DEFAULT_CLIENT_NONCE; + temp = qop; + if(!axutil_strstr(temp, AXIS2_HTTP_AUTHORIZATION_REQUEST_QOP_OPTION_AUTH)) + { + return AXIS2_FAILURE; + } + AXIS2_FREE(env->allocator, qop); + qop = AXIS2_HTTP_AUTHORIZATION_REQUEST_QOP_OPTION_AUTH; + temp = axutil_uuid_gen(env); + cnonce = temp; + temp += CLIENT_NONCE_LENGTH; + if(temp) + *temp = AXIS2_ESC_NULL; + elen += 11 + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_DEFAULT_CLIENT_NONCE) + + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT) + + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE) + + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP) + CLIENT_NONCE_LENGTH + + axutil_strlen(qop); + } + + axutil_digest_calc_get_h_a1(env, algo, uname, realm, passwd, cnonce, nonce, h_a1); + axutil_digest_calc_get_response(env, h_a1, nonce, nc, cnonce, qop, method_value, url, h_a2, + response); + + elen += 4 + axutil_strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_RESPONSE) + axutil_strlen( + AXIS2_PROXY_AUTH_TYPE_DIGEST) + response_length; + + auth_str + = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (elen + 1))); + temp = auth_str; + sprintf(temp, "%s %s=\"%s\", ", AXIS2_PROXY_AUTH_TYPE_DIGEST, + AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_USERNAME, uname); + temp += ((int)strlen(AXIS2_HTTP_AUTH_TYPE_DIGEST) + (int)strlen( + AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_USERNAME) + (int)strlen(uname) + 6); + if(realm) + { + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM, realm); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_REALM) + (int)strlen(realm) + + 5); + } + if(nonce) + { + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE, nonce); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE) + (int)strlen(nonce) + + 5); + } + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_URI, url); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_URI) + (int)strlen(url) + 5); + if(qop) + { + sprintf(temp, "%s=%s, %s=%s, %s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP, + qop, AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT, nc, + AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE, cnonce); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_QOP) + (int)strlen(qop) + + (int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_NONCE_COUNT) + (int)strlen(nc) + + (int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_CLIENT_NONCE) + (int)strlen( + cnonce) + 11); + } + if(opaque) + { + sprintf(temp, "%s=\"%s\", ", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE, opaque); + temp += ((int)strlen(AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_OPAQUE) + (int)strlen( + opaque) + 5); + } + sprintf(temp, "%s=\"%s\"", AXIS2_HTTP_AUTHORIZATION_REQUEST_PARAM_RESPONSE, response); + axis2_http_sender_util_add_header(env, request, AXIS2_HTTP_HEADER_PROXY_AUTHORIZATION, + auth_str); + if(realm) + { + AXIS2_FREE(env->allocator, realm); + } + + if(nonce) + { + AXIS2_FREE(env->allocator, nonce); + } + + if(cnonce) + { + AXIS2_FREE(env->allocator, cnonce); + } + + if(opaque) + { + AXIS2_FREE(env->allocator, opaque); + } + + if(auth_str) + { + AXIS2_FREE(env->allocator, auth_str); + } + + auth_str = NULL; + + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} +#endif + +#ifndef AXIS2_LIBCURL_ENABLED +static axis2_status_t +axis2_http_sender_configure_http_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request) +{ + axis2_char_t *auth_type = NULL; + axis2_status_t status = AXIS2_FALSE; + axutil_property_t *http_auth_property = NULL; + axis2_char_t *http_auth_property_value = NULL; + axis2_bool_t force_http_auth = AXIS2_FALSE; + axutil_property_t *http_auth_type_property = NULL; + axis2_char_t *http_auth_type_property_value = NULL; + axis2_char_t *auth_type_end = NULL; + + http_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_FORCE_HTTP_AUTH); + if(http_auth_property) + { + http_auth_property_value = (axis2_char_t *)axutil_property_get_value(http_auth_property, + env); + } + + if(http_auth_property_value && 0 == axutil_strcmp(http_auth_property_value, AXIS2_VALUE_TRUE)) + { + force_http_auth = AXIS2_TRUE; + } + + if(force_http_auth) + { + http_auth_type_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_HTTP_AUTH_TYPE); + if(http_auth_type_property) + { + http_auth_type_property_value = (axis2_char_t *)axutil_property_get_value( + http_auth_type_property, env); + } + + if(http_auth_type_property_value) + { + auth_type = http_auth_type_property_value; + } + } + if(!force_http_auth || axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) == 0) + { + axis2_http_header_t *auth_header = NULL; + axis2_http_simple_response_t *response = NULL; + + response = axis2_http_client_get_response(sender->client, env); + + if(response) + { + auth_header = axis2_http_simple_response_get_first_header(response, env, + AXIS2_HTTP_HEADER_WWW_AUTHENTICATE); + } + + if(auth_header) + { + auth_type = axis2_http_header_get_value(auth_header, env); + } + + if(auth_type) + { + auth_type_end = axutil_strchr(auth_type, ' '); + *auth_type_end = AXIS2_ESC_NULL; + auth_type_end++; + /*Read the realm and the rest stuff now from auth_type_end */ + } + if(force_http_auth && axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) != 0) + { + auth_type = NULL; + } + } + if(auth_type) + { + if(axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_BASIC) == 0) + { + status = axis2_http_sender_configure_http_basic_auth(sender, env, msg_ctx, request); + } + else if(axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) == 0) + { + status = axis2_http_sender_configure_http_digest_auth(sender, env, msg_ctx, request, + auth_type_end); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Authtype %s is not" + "supported", auth_type); + } + } + else + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + } + + return status; +} + +static axis2_status_t +axis2_http_sender_configure_proxy_auth( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request) +{ + axis2_char_t *auth_type = NULL; + axis2_status_t status = AXIS2_FALSE; + axutil_property_t *proxy_auth_property = NULL; + axis2_char_t *proxy_auth_property_value = NULL; + axis2_bool_t force_proxy_auth = AXIS2_FALSE; + axutil_property_t *proxy_auth_type_property = NULL; + axis2_char_t *proxy_auth_type_property_value = NULL; + axis2_char_t *auth_type_end = NULL; + + proxy_auth_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_FORCE_PROXY_AUTH); + if(proxy_auth_property) + { + proxy_auth_property_value = (axis2_char_t *)axutil_property_get_value(proxy_auth_property, + env); + } + + if(proxy_auth_property_value && 0 == axutil_strcmp(proxy_auth_property_value, AXIS2_VALUE_TRUE)) + { + force_proxy_auth = AXIS2_TRUE; + } + + if(force_proxy_auth) + { + proxy_auth_type_property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_PROXY_AUTH_TYPE); + if(proxy_auth_type_property) + { + proxy_auth_type_property_value = (axis2_char_t *)axutil_property_get_value( + proxy_auth_type_property, env); + } + + if(proxy_auth_type_property_value) + { + auth_type = proxy_auth_type_property_value; + } + } + else + { + axis2_http_header_t *auth_header = NULL; + axis2_http_simple_response_t *response = NULL; + + response = axis2_http_client_get_response(sender->client, env); + + if(response) + { + auth_header = axis2_http_simple_response_get_first_header(response, env, + AXIS2_HTTP_HEADER_PROXY_AUTHENTICATE); + } + + if(auth_header) + { + auth_type = axis2_http_header_get_value(auth_header, env); + } + + if(auth_type) + { + auth_type_end = axutil_strchr(auth_type, ' '); + *auth_type_end = AXIS2_ESC_NULL; + auth_type_end++; + /*Read the realm and the rest stuff now from auth_type_end */ + } + } + if(auth_type) + { + if(axutil_strcasecmp(auth_type, AXIS2_PROXY_AUTH_TYPE_BASIC) == 0) + { + status = axis2_http_sender_configure_proxy_basic_auth(sender, env, msg_ctx, request); + } + else if(axutil_strcasecmp(auth_type, AXIS2_PROXY_AUTH_TYPE_DIGEST) == 0) + { + status = axis2_http_sender_configure_proxy_digest_auth(sender, env, msg_ctx, request, + auth_type_end); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Authtype %s is not supported", auth_type); + } + } + else + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + } + + return status; +} +#endif + +#ifndef AXIS2_LIBCURL_ENABLED +static axis2_status_t +axis2_http_sender_set_http_auth_type( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request) +{ + axis2_char_t *auth_type = NULL; + axis2_status_t status = AXIS2_FALSE; + axis2_char_t *auth_type_end = NULL; + axis2_http_header_t *auth_header = NULL; + axis2_http_simple_response_t *response = NULL; + + response = axis2_http_client_get_response(sender->client, env); + + if(response) + { + auth_header = axis2_http_simple_response_get_first_header(response, env, + AXIS2_HTTP_HEADER_WWW_AUTHENTICATE); + } + + if(auth_header) + { + auth_type = axis2_http_header_get_value(auth_header, env); + } + + if(auth_type) + { + auth_type_end = axutil_strchr(auth_type, ' '); + *auth_type_end = AXIS2_ESC_NULL; + auth_type_end++; + /*Read the realm and the rest stuff now from auth_type_end */ + } + + if(auth_type) + { + if(axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_BASIC) == 0) + { + status = axis2_msg_ctx_set_auth_type(msg_ctx, env, AXIS2_HTTP_AUTH_TYPE_BASIC); + } + else if(axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) == 0) + { + status = axis2_msg_ctx_set_auth_type(msg_ctx, env, AXIS2_HTTP_AUTH_TYPE_DIGEST); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Authtype %s is not supported", auth_type); + } + } + else + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + } + return status; +} + +static axis2_status_t +axis2_http_sender_set_proxy_auth_type( + axis2_http_sender_t * sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_http_simple_request_t * request) +{ + axis2_char_t *auth_type = NULL; + axis2_status_t status = AXIS2_FALSE; + axis2_char_t *auth_type_end = NULL; + axis2_http_header_t *auth_header = NULL; + axis2_http_simple_response_t *response = NULL; + + response = axis2_http_client_get_response(sender->client, env); + + if(response) + { + auth_header = axis2_http_simple_response_get_first_header(response, env, + AXIS2_HTTP_HEADER_PROXY_AUTHENTICATE); + } + + if(auth_header) + { + auth_type = axis2_http_header_get_value(auth_header, env); + } + + if(auth_type) + { + auth_type_end = axutil_strchr(auth_type, ' '); + *auth_type_end = AXIS2_ESC_NULL; + auth_type_end++; + /*Read the realm and the rest stuff now from auth_type_end */ + } + + if(auth_type) + { + if(axutil_strcasecmp(auth_type, AXIS2_PROXY_AUTH_TYPE_BASIC) == 0) + { + status = axis2_msg_ctx_set_auth_type(msg_ctx, env, AXIS2_PROXY_AUTH_TYPE_BASIC); + } + else if(axutil_strcasecmp(auth_type, AXIS2_PROXY_AUTH_TYPE_DIGEST) == 0) + { + status = axis2_msg_ctx_set_auth_type(msg_ctx, env, AXIS2_PROXY_AUTH_TYPE_DIGEST); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Authtype %s is not supported", auth_type); + } + } + else + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE); + } + return status; +} +#endif + +#ifdef AXIS2_LIBCURL_ENABLED +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) +{ + return axis2_libcurl_send (curl, sender->om_output, + env, msg_ctx, out, str_url, soap_action); +} +#endif + +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) +{ + axiom_soap_envelope_t *soap_env = NULL; + axiom_soap_body_t *soap_body = NULL; + axiom_node_t *body_node = NULL; + axiom_node_t *data_node = NULL; + axiom_element_t *data_element = NULL; + axiom_child_element_iterator_t *iterator = NULL; + axutil_array_list_t *param_list = NULL; + axis2_char_t *param_string = NULL; + int i = 0; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + + soap_env = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + if(!soap_env) + { + return NULL; + } + soap_body = axiom_soap_envelope_get_body(soap_env, env); + body_node = axiom_soap_body_get_base_node(soap_body, env); + if(!body_node) + { + /* This could be the situation where service client does not provide + * a xml payload and instead add url parameters to the endpoint url + */ + return NULL; + } + data_node = axiom_node_get_first_child(body_node, env); + if(!data_node) + { + return NULL; + } + + param_list = axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY); + + data_element = axiom_node_get_data_element(data_node, env); + + iterator = axiom_element_get_child_elements(data_element, env, data_node); + + if(iterator) + { + while(AXIS2_TRUE == AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(iterator, env)) + { + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + axis2_char_t *encoded_value = NULL; + + node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(iterator, env); + element = axiom_node_get_data_element(node, env); + name = axiom_element_get_localname(element, env); + value = axiom_element_get_text(element, env, node); + if(value) + { + encoded_value = (axis2_char_t *)AXIS2_MALLOC(env->allocator, strlen(value)); + memset(encoded_value, 0, strlen(value)); + encoded_value = axutil_url_encode(env, encoded_value, value, (int)strlen(value)); + /* We are sure that the difference lies within the int range */ + + axutil_array_list_add(param_list, env, axutil_strcat(env, name, "=", encoded_value, + NULL)); + AXIS2_FREE(env->allocator, encoded_value); + encoded_value = NULL; + } + } + } + for(i = 0; i < axutil_array_list_size(param_list, env); i++) + { + axis2_char_t *tmp_string = NULL; + axis2_char_t *pair = NULL; + + pair = axutil_array_list_get(param_list, env, i); + if(i == 0) + { + tmp_string = axutil_stracat(env, param_string, pair); + } + else + { + tmp_string = axutil_strcat(env, param_string, AXIS2_AND_SIGN, pair, NULL); + } + + if(param_string) + { + AXIS2_FREE(env->allocator, param_string); + param_string = NULL; + } + AXIS2_FREE(env->allocator, pair); + param_string = tmp_string; + } + axutil_array_list_free(param_list, env); + return param_string; +} + +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) +{ + axis2_http_header_t *http_header; + http_header = axis2_http_header_create(env, header_name, header_value); + axis2_http_simple_request_add_header(request, env, http_header); +} + +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) +{ + sender->keep_alive = 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) +{ + return sender->keep_alive; +} + +static axutil_hash_t * +axis2_http_sender_connection_map_create( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx) +{ + axutil_hash_t *connection_map = NULL; + connection_map = axutil_hash_make(env); + if(!connection_map) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + } + else + { + axis2_conf_ctx_t *conf_ctx = NULL; + axutil_property_t *connection_map_property = NULL; + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + connection_map_property = axutil_property_create_with_args(env, AXIS2_SCOPE_SESSION, + AXIS2_TRUE, axis2_http_sender_connection_map_free, connection_map); + axis2_conf_ctx_set_property(conf_ctx, env, AXIS2_HTTP_CONNECTION_MAP, + connection_map_property); + } + return connection_map; +} + +static void +axis2_http_sender_connection_map_remove( + axutil_hash_t *connection_map, + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_http_client_t *http_client) +{ + axutil_property_t *property = NULL; + axis2_endpoint_ref_t *endpoint = NULL; + /** + * Put the http client into message context with own value true so that it will be freed + * after response processed + */ + property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_TRUE, + axis2_http_client_free_void_arg, http_client); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_CLIENT, property); + endpoint = axis2_msg_ctx_get_to(msg_ctx, env); + if(endpoint) + { + const axis2_char_t *address = NULL; + address = axis2_endpoint_ref_get_address(endpoint, env); + if(address) + { + axutil_url_t *url = NULL; + url = axutil_url_parse_string(env, address); + if(url) + { + axis2_char_t *server = axutil_url_get_server(url, env); + if(server) + { + axutil_hash_set(connection_map, server, AXIS2_HASH_KEY_STRING, NULL); + } + axutil_url_free(url, env); + } + } + } +} + +static void +axis2_http_sender_connection_map_add( + axutil_hash_t *connection_map, + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx, + axis2_http_client_t *http_client) +{ + axutil_property_t *property = NULL; + axis2_endpoint_ref_t *endpoint = NULL; + /** + * Put the http client into message context. Is this neccessary? + */ + property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST, AXIS2_FALSE, + axis2_http_client_free_void_arg, http_client); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_CLIENT, property); + endpoint = axis2_msg_ctx_get_to(msg_ctx, env); + if(endpoint) + { + const axis2_char_t *address = NULL; + address = axis2_endpoint_ref_get_address(endpoint, env); + if(address) + { + axutil_url_t *url = NULL; + url = axutil_url_parse_string(env, address); + if(url) + { + axis2_char_t *server = axutil_url_get_server(url, env); + if(server) + { + axutil_hash_set(connection_map, axutil_strdup(env, server), + AXIS2_HASH_KEY_STRING, http_client); + } + axutil_url_free(url, env); + } + } + } +} + +static axis2_http_client_t * +axis2_http_sender_connection_map_get( + axutil_hash_t *connection_map, + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx) +{ + axis2_http_client_t *http_client = NULL; + axis2_endpoint_ref_t *endpoint = NULL; + endpoint = axis2_msg_ctx_get_to(msg_ctx, env); + if(endpoint) + { + const axis2_char_t *address = NULL; + address = axis2_endpoint_ref_get_address(endpoint, env); + if(address) + { + axutil_url_t *url = NULL; + url = axutil_url_parse_string(env, address); + if(url) + { + axis2_char_t *server = axutil_url_get_server(url, env); + if(server) + { + http_client = axutil_hash_get(connection_map, server, AXIS2_HASH_KEY_STRING); + } + axutil_url_free(url, env); + } + } + } + return http_client; +} + +static void AXIS2_CALL +axis2_http_sender_connection_map_free( + void *cm_void, + const axutil_env_t *env) +{ + void *val = NULL; + const void *key = NULL; + axutil_hash_index_t *hi = NULL; + axutil_hash_t *ht = (axutil_hash_t *)cm_void; + + for(hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_char_t *name = NULL; + axis2_http_client_t *value = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + name = (axis2_char_t *) key; + if(name) + { + AXIS2_FREE(env->allocator, name); + } + value = (axis2_http_client_t *) val; + if(value) + { + axis2_http_client_free(value, env); + } + } + axutil_hash_free(ht, env); +} + diff --git a/src/core/transport/http/sender/http_transport_sender.c b/src/core/transport/http/sender/http_transport_sender.c new file mode 100644 index 0000000..3ef55b0 --- /dev/null +++ b/src/core/transport/http/sender/http_transport_sender.c @@ -0,0 +1,859 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef AXIS2_LIBCURL_ENABLED +#include "libcurl/axis2_libcurl.h" +#endif + +/** + * HTTP Transport Sender struct impl + * Axis2 HTTP Transport Sender impl + */ + +typedef struct axis2_http_transport_sender_impl +{ + axis2_transport_sender_t transport_sender; + axis2_char_t *http_version; + axis2_bool_t chunked; + int connection_timeout; + int so_timeout; + axis2_bool_t keep_alive; +#ifdef AXIS2_LIBCURL_ENABLED + axis2_libcurl_t *libcurl; +#endif +} axis2_http_transport_sender_impl_t; + +#define AXIS2_WS_RM_ANONYMOUS_URL "http://docs.oasis-open.org/ws-rx/wsmc/200702/anonymous?id=" +#define AXIS2_INTF_TO_IMPL(transport_sender) \ + ((axis2_http_transport_sender_impl_t *)\ + (transport_sender)) + +/***************************** Function headers *******************************/ +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_invoke( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_clean_up( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_init( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_out_desc_t * out_desc); + +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_write_message( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_endpoint_ref_t * epr, + axiom_soap_envelope_t * out, + axiom_output_t * om_output); + +void AXIS2_CALL axis2_http_transport_sender_free( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env); + +static const axis2_transport_sender_ops_t http_transport_sender_ops_var = { + axis2_http_transport_sender_init, axis2_http_transport_sender_invoke, + axis2_http_transport_sender_clean_up, axis2_http_transport_sender_free }; + +axis2_transport_sender_t *AXIS2_CALL +axis2_http_transport_sender_create( + const axutil_env_t * env) +{ + axis2_http_transport_sender_impl_t *transport_sender_impl = NULL; + + transport_sender_impl = (axis2_http_transport_sender_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_http_transport_sender_impl_t)); + + if(!transport_sender_impl) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)transport_sender_impl, 0, sizeof(axis2_http_transport_sender_impl_t)); + + transport_sender_impl->http_version = axutil_strdup(env, AXIS2_HTTP_HEADER_PROTOCOL_11); + transport_sender_impl->chunked = AXIS2_TRUE; + transport_sender_impl->connection_timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT; + transport_sender_impl->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT; + transport_sender_impl->keep_alive = AXIS2_TRUE; + transport_sender_impl->transport_sender.ops = &http_transport_sender_ops_var; + +#ifdef AXIS2_LIBCURL_ENABLED + transport_sender_impl->libcurl = axis2_libcurl_create(env); + if (!transport_sender_impl->libcurl) + { + AXIS2_FREE(env->allocator, transport_sender_impl); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } +#endif + + return &(transport_sender_impl->transport_sender); +} + +void AXIS2_CALL +axis2_http_transport_sender_free( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env) +{ + + axis2_http_transport_sender_impl_t *transport_sender_impl = NULL; + if(!transport_sender) + { + return; + } + + transport_sender_impl = AXIS2_INTF_TO_IMPL(transport_sender); + + if(transport_sender_impl->http_version) + { + AXIS2_FREE(env->allocator, transport_sender_impl->http_version); + transport_sender_impl->http_version = NULL; + } + +#ifdef AXIS2_LIBCURL_ENABLED + if (transport_sender_impl->libcurl) + { + axis2_libcurl_free(transport_sender_impl->libcurl, env); + } +#endif + + AXIS2_FREE(env->allocator, transport_sender_impl); + return; +} + +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_invoke( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + const axis2_char_t *char_set_enc = NULL; + axutil_string_t *char_set_enc_str = NULL; + axis2_endpoint_ref_t *epr = NULL; + axis2_char_t *transport_url = NULL; + axiom_xml_writer_t *xml_writer = NULL; + axiom_output_t *om_output = NULL; + axis2_char_t *buffer = NULL; + axiom_soap_envelope_t *soap_data_out = NULL; + axis2_bool_t do_mtom; + axutil_property_t *property = NULL; + axiom_node_t *data_out = NULL; + int buffer_size = 0; + axis2_status_t status = AXIS2_SUCCESS; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *write_xml_declaration_param = NULL; + axutil_hash_t *transport_attrs = NULL; + axis2_bool_t write_xml_declaration = AXIS2_FALSE; + axis2_bool_t fault = AXIS2_FALSE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_sender_invoke"); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env); + if(char_set_enc_str) + { + char_set_enc = axutil_string_get_buffer(char_set_enc_str, env); + } + + if(!char_set_enc) + { + axis2_op_ctx_t *op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_ctx_t *ctx = axis2_op_ctx_get_base(op_ctx, env); + if(ctx) + { + property = axis2_ctx_get_property(ctx, env, AXIS2_CHARACTER_SET_ENCODING); + if(property) + { + char_set_enc = axutil_property_get_value(property, env); + property = NULL; + } + } + } + } + + /** + * If we still can't find the char set enc we will + * use default + */ + if(!char_set_enc) + { + char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; + } + + do_mtom = axis2_http_transport_utils_do_write_mtom(env, msg_ctx); + + transport_url = axis2_msg_ctx_get_transport_url(msg_ctx, env); + if(transport_url) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "transport_url:%s", transport_url); + epr = axis2_endpoint_ref_create(env, transport_url); + } + else + { + /* when transport url is not available in msg_ctx */ + axis2_endpoint_ref_t *ctx_epr = axis2_msg_ctx_get_to(msg_ctx, env); + if(ctx_epr) + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "ctx_epr:%s", axis2_endpoint_ref_get_address( + ctx_epr, env)); + + if(ctx_epr && axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL_SUBMISSION, + axis2_endpoint_ref_get_address(ctx_epr, env)) && axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL, + axis2_endpoint_ref_get_address(ctx_epr, env)) && !(axutil_strstr( + axis2_endpoint_ref_get_address(ctx_epr, env), AXIS2_WS_RM_ANONYMOUS_URL))) + { + epr = ctx_epr; + } + } + + soap_data_out = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + if(!soap_data_out) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_SOAP_ENVELOPE_IN_MSG_CTX, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", AXIS2_ERROR_GET_MESSAGE(env->error)); + return AXIS2_SUCCESS; + } + + xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, + AXIS2_XML_PARSER_TYPE_BUFFER); + if(!xml_writer) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Could not create xml_writer for \ +AXIS2_XML_PARSER_TYPE_BUFFER"); + return AXIS2_FAILURE; + } + + om_output = axiom_output_create(env, xml_writer); + if(!om_output) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Could not create om_output for xml writer of \ +AXIS2_XML_PARSER_TYPE_BUFFER"); + axiom_xml_writer_free(xml_writer, env); + xml_writer = NULL; + return AXIS2_FAILURE; + } + + /* setting SOAP version for OM_OUTPUT. */ + axiom_output_set_soap11(om_output, env, axis2_msg_ctx_get_is_soap_11(msg_ctx, env)); + + /* This is the case where normal client send the requet using a http_client*/ + + if(epr) + { + if(axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, axis2_endpoint_ref_get_address(epr, env)) + == 0 || axutil_strcmp(AXIS2_WSA_NONE_URL, axis2_endpoint_ref_get_address(epr, env)) + == 0) + { + epr = NULL; + } + else + { + status = axis2_http_transport_sender_write_message(transport_sender, env, msg_ctx, epr, + soap_data_out, om_output); + } + } + + /* If no endpoint reference could be derived from the the message context. It could well be the + * single channel two way scenario in the application server side send. + */ + if(!epr) + { + axutil_stream_t *out_stream = axis2_msg_ctx_get_transport_out_stream(msg_ctx, env); + + if(AXIS2_TRUE == axis2_msg_ctx_get_server_side(msg_ctx, env)) + { + axis2_http_out_transport_info_t *out_info = NULL; + axis2_bool_t is_soap11 = AXIS2_FALSE; + axis2_op_ctx_t *op_ctx = NULL; + /*axis2_char_t *header_value = NULL;*/ + + out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info( + msg_ctx, env); + + if(!out_info) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE); + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + return AXIS2_FAILURE; + } + /*header_value = axis2_http_transport_utils_get_session(env, msg_ctx); + if(header_value) + { + AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_info, env, header_value); + }*/ + + is_soap11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + + AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(out_info, env, char_set_enc); + if(AXIS2_TRUE == is_soap11) + { + /* SOAP1.1 */ + AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env, + AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML); + } + else + { + /* SOAP1.2 */ + AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env, + AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP); + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + } + + if(conf) + { + /* get access to HTTP transport for sending */ + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + } + + if(trans_desc) + { + + /* accessing parameter in axis2.xml which set to have + * an ability to send xml versoin processing + * instruction */ + write_xml_declaration_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, + AXIS2_XML_DECLARATION); + } + + if(write_xml_declaration_param) + { + transport_attrs = axutil_param_get_attributes(write_xml_declaration_param, env); + if(transport_attrs) + { + /* Accessing attribute values */ + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *write_xml_declaration_attr = NULL; + axis2_char_t *write_xml_declaration_attr_value = NULL; + + obj = axutil_hash_get(transport_attrs, AXIS2_ADD_XML_DECLARATION, + AXIS2_HASH_KEY_STRING); + if(obj) + { + write_xml_declaration_attr + = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + + if(write_xml_declaration_attr) + { + write_xml_declaration_attr_value = axiom_attribute_get_value( + write_xml_declaration_attr, env); + } + + if(write_xml_declaration_attr_value && 0 == axutil_strcasecmp( + write_xml_declaration_attr_value, AXIS2_VALUE_TRUE)) + { + write_xml_declaration = AXIS2_TRUE; + } + } + } + + if(write_xml_declaration) + { + axiom_output_write_xml_version_encoding(om_output, env); + } + + if(AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + axiom_node_t *body_node = NULL; + /* axis2_bool_t fault = AXIS2_FALSE;*/ + axiom_soap_fault_t *soap_fault; + axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_data_out, env); + axiom_soap_fault_detail_t *soap_fault_detial; + + if(!soap_body) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, + AXIS2_FAILURE); + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + return AXIS2_FAILURE; + } + + fault = axiom_soap_body_has_fault(soap_body, env); + + if(fault == AXIS2_TRUE) + { + soap_fault = axiom_soap_body_get_fault(soap_body, env); + + if(!soap_fault) + { + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Rest fault has occur, error described below"); + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + return AXIS2_FAILURE; + } + + soap_fault_detial = axiom_soap_fault_get_detail(soap_fault, env); + + if(!soap_fault_detial) + { + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Returning failure to obtain soap_fault_detail from soap_fault"); + return AXIS2_FAILURE; + } + + body_node = axiom_soap_fault_detail_get_base_node(soap_fault_detial, env); + if(!body_node) + { + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "failure to get base node from soap_fault_detail."); + return AXIS2_FAILURE; + } + + } + else + { + + body_node = axiom_soap_body_get_base_node(soap_body, env); + if(!body_node) + { + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "failure to get base node from soap_body."); + return AXIS2_FAILURE; + } + } + + data_out = axiom_node_get_first_element(body_node, env); + + if(!data_out || axiom_node_get_node_type(data_out, env) != AXIOM_ELEMENT) + { + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "unable to get first element from soap_body, base node."); + return AXIS2_FAILURE; + } + + axiom_node_serialize(data_out, env, om_output); + buffer = (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env); + buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); + axutil_stream_write(out_stream, env, buffer, buffer_size); + /* Finish Rest Processing */ + + } + else + { + axiom_soap_body_t *body = NULL; + + body = axiom_soap_envelope_get_body(soap_data_out, env); + fault = axiom_soap_body_has_fault(body, env); + + /* SOAP Processing */ + axiom_output_set_do_optimize(om_output, env, do_mtom); + axiom_soap_envelope_serialize(soap_data_out, env, om_output, AXIS2_FALSE); + if(do_mtom && !fault) + { + axis2_status_t mtom_status = AXIS2_FAILURE; + axis2_char_t *content_type = NULL; + axutil_array_list_t *mime_parts = NULL; + + /*Create the attachment related data and put them to an + *array_list */ + mtom_status = axiom_output_flush(om_output, env); + if(mtom_status == AXIS2_SUCCESS) + { + mime_parts = axiom_output_get_mime_parts(om_output, env); + if(!mime_parts) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Unable to create the mime_part list from om_output"); + return AXIS2_FAILURE; + } + else + { + axis2_msg_ctx_set_mime_parts(msg_ctx, env, mime_parts); + } + } + /*om_out put has the details of content_type */ + content_type = (axis2_char_t *)axiom_output_get_content_type(om_output, env); + AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env, content_type); + } + else + { + buffer = (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env); + buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); + + /* This is where it actually fill the buffer in out_stream. In application server + * side this is the out_stream passed to the in message context from http_worker + * function and then copied to the out message context. + */ + axutil_stream_write(out_stream, env, buffer, buffer_size); + } + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); + } + } + + axiom_output_free(om_output, env); + om_output = NULL; + xml_writer = NULL; + + if(transport_url) + { + if(epr) + { + axis2_endpoint_ref_free(epr, env); + epr = NULL; + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_sender_invoke"); + return status; +} + +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_clean_up( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE); + /* + * Clean up is not used. If the http sender needs + * to be cleaned up it should be done here. + */ + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_init( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_out_desc_t * out_desc) +{ + axutil_param_t *version_param = NULL; + axis2_char_t *version = NULL; + axis2_char_t *temp = NULL; + axutil_param_t *temp_param = NULL; + + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE); + + /* Getting HTTP version from axis2.xml */ + version_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container( + out_desc, env), env, AXIS2_HTTP_PROTOCOL_VERSION); + + if(version_param) + { + version = axutil_param_get_value(version_param, env); + } + + if(version) + { + /* handling HTTP 1.1 */ + if(0 == axutil_strcmp(version, AXIS2_HTTP_HEADER_PROTOCOL_11)) + { + axis2_char_t *encoding = NULL; + axutil_param_t *encoding_param = NULL; + if(AXIS2_INTF_TO_IMPL(transport_sender)->http_version) + { + AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(transport_sender)->http_version); + } + + AXIS2_INTF_TO_IMPL(transport_sender)->http_version = axutil_strdup(env, version); + AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive = AXIS2_TRUE; + encoding_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(out_desc, env), env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING); + + if(encoding_param) + { + encoding = axutil_param_get_value(encoding_param, env); + } + + if(encoding && 0 + == axutil_strcmp(encoding, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_TRUE; + } + else + { + AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE; + } + + } + else if(0 == axutil_strcmp(version, AXIS2_HTTP_HEADER_PROTOCOL_10)) + { + axutil_param_t *keepalive_param = NULL; + + /* Handling HTTP 1.0 */ + if(AXIS2_INTF_TO_IMPL(transport_sender)->http_version) + { + AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(transport_sender)->http_version); + } + AXIS2_INTF_TO_IMPL(transport_sender)->http_version = axutil_strdup(env, version); + AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE; + keepalive_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(out_desc, env), env, + AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE); + if(keepalive_param) + { + axis2_char_t *keepalive_value = NULL; + keepalive_value = axutil_param_get_value(keepalive_param, env); + if(!axutil_strcmp(keepalive_value, AXIS2_VALUE_FALSE)) + { + AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive = AXIS2_FALSE; + } + } + } + } + else + { + /* HTTP version is not available in axis2.xml */ + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + /* Getting HTTP_SO_TIMEOUT value from axis2.xml */ + temp_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container( + out_desc, env), env, AXIS2_HTTP_SO_TIMEOUT); + + if(temp_param) + { + temp = axutil_param_get_value(temp_param, env); + } + + if(temp) + { + AXIS2_INTF_TO_IMPL(transport_sender)->so_timeout = AXIS2_ATOI(temp); + } + + /* Getting HTTP_CONNECTION_TIMEOUT from axis2.xml */ + temp + = (axis2_char_t *)axutil_param_container_get_param( + axis2_transport_out_desc_param_container(out_desc, env), env, + AXIS2_HTTP_CONNECTION_TIMEOUT); + if(temp_param) + { + temp = axutil_param_get_value(temp_param, env); + } + + /* set axis2.xml connection timeout value to http_sender */ + if(temp) + { + AXIS2_INTF_TO_IMPL(transport_sender)->connection_timeout = AXIS2_ATOI(temp); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_http_transport_sender_write_message( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_endpoint_ref_t * epr, + axiom_soap_envelope_t * out, + axiom_output_t * om_output) +{ + const axis2_char_t *soap_action = NULL; + const axis2_char_t *url = NULL; + axis2_http_sender_t *sender = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axis2_char_t *soap_ns_uri = NULL; + axiom_soap_envelope_t *response_envelope = NULL; + axis2_op_t *op = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, epr, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out, AXIS2_FAILURE); + + /* epr is already passed NULL checking */ + url = axis2_endpoint_ref_get_address(epr, env); + + soap_action = axutil_string_get_buffer(axis2_msg_ctx_get_soap_action(msg_ctx, env), env); + + if(!soap_action) + { + soap_action = ""; + } + + sender = axis2_http_sender_create(env); + + if(!sender) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "http sender creation failed"); + return AXIS2_FAILURE; + } + axis2_http_sender_set_keep_alive(sender, env, AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive); + + /* For the MTOM case we should on chunking. And for chunking to work the + * protocol should be http 1.1*/ + + if(axis2_msg_ctx_get_doing_mtom(msg_ctx, env)) + { + AXIS2_HTTP_SENDER_SET_CHUNKED(sender, env, AXIS2_TRUE); + AXIS2_HTTP_SENDER_SET_HTTP_VERSION(sender, env, AXIS2_HTTP_HEADER_PROTOCOL_11); + } + else + { + AXIS2_HTTP_SENDER_SET_CHUNKED(sender, env, AXIS2_INTF_TO_IMPL(transport_sender)->chunked); + AXIS2_HTTP_SENDER_SET_HTTP_VERSION(sender, env, + AXIS2_INTF_TO_IMPL(transport_sender)->http_version); + } + AXIS2_HTTP_SENDER_SET_OM_OUTPUT(sender, env, om_output); + +#ifdef AXIS2_LIBCURL_ENABLED + AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "using axis2 libcurl http sender."); + status = + axis2_libcurl_http_send(AXIS2_INTF_TO_IMPL(transport_sender)->libcurl, + sender, env, msg_ctx, out, url, soap_action); +#else + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "using axis2 native http sender."); + status = AXIS2_HTTP_SENDER_SEND(sender, env, msg_ctx, out, url, soap_action); +#endif + + AXIS2_HTTP_SENDER_FREE(sender, env); + sender = NULL; + + /* if the send was not successful, do not process any response */ + if(status != AXIS2_SUCCESS) + return status; + + op = axis2_msg_ctx_get_op(msg_ctx, env); + if(op) + { + /* handle one way case */ + const axis2_char_t *mep = axis2_op_get_msg_exchange_pattern(op, env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "OP name axutil_qname_get_localpart = %s", mep); + if(axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY) == 0 || axutil_strcmp(mep, + AXIS2_MEP_URI_ROBUST_OUT_ONLY) == 0 || axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) == 0) + { + return status; + } + else + { + /* AXIS2_MEP_URI_IN_OUT case , we have a response this + * time */ + soap_ns_uri + = axis2_msg_ctx_get_is_soap_11(msg_ctx, env) ? AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI + : AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; + response_envelope = axis2_http_transport_utils_create_soap_msg(env, msg_ctx, + soap_ns_uri); + if(response_envelope) + { + axis2_msg_ctx_set_response_soap_envelope(msg_ctx, env, response_envelope); + } + } + } + + return status; +} + +/** + * Following block distinguish the exposed part of the dll. + */ + +/* When building for static deployment, give the get and remove methods + * unique names. This avoids having the linker fail with duplicate symbol + * errors. + */ + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_get_instance( +#else + axis2_http_transport_sender_get_instance( +#endif + struct axis2_transport_sender **inst, + const axutil_env_t * env) +{ + *inst = axis2_http_transport_sender_create(env); + if(!(*inst)) + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_remove_instance( +#else + axis2_http_transport_sender_remove_instance( +#endif + axis2_transport_sender_t * inst, + const axutil_env_t * env) +{ + if(inst) + { + AXIS2_TRANSPORT_SENDER_FREE(inst, env); + } + return AXIS2_SUCCESS; +} + diff --git a/src/core/transport/http/sender/libcurl/Makefile.am b/src/core/transport/http/sender/libcurl/Makefile.am new file mode 100644 index 0000000..90e5ce6 --- /dev/null +++ b/src/core/transport/http/sender/libcurl/Makefile.am @@ -0,0 +1,2 @@ +EXTRA_DIST= axis2_libcurl.h axis2_libcurl.c libcurl_stream.h libcurl_stream.c + diff --git a/src/core/transport/http/sender/libcurl/axis2_libcurl.c b/src/core/transport/http/sender/libcurl/axis2_libcurl.c new file mode 100644 index 0000000..834e69b --- /dev/null +++ b/src/core/transport/http/sender/libcurl/axis2_libcurl.c @@ -0,0 +1,1169 @@ +/* + * 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. + */ +#ifdef AXIS2_LIBCURL_ENABLED + +#include "axis2_libcurl.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "libcurl_stream.h" + +static int ref = 0; + +struct axis2_libcurl +{ + axis2_char_t *memory; + axutil_array_list_t *alist; + unsigned int size; + const axutil_env_t *env; + char errorbuffer[CURL_ERROR_SIZE]; + CURL *handler; + axis2_bool_t cookies; +}; + +static size_t +axis2_libcurl_write_memory_callback( + void *ptr, + size_t size, + size_t nmemb, + void *data); + +static size_t +axis2_libcurl_header_callback( + void *ptr, + size_t size, + size_t nmemb, + void *data); + +static axis2_char_t * +axis2_libcurl_get_content_type( + axis2_libcurl_t *curl, + const axutil_env_t * env); + +static int +axis2_libcurl_get_content_length( + axis2_libcurl_t *curl, + const axutil_env_t * env); + +static axis2_http_header_t * +axis2_libcurl_get_first_header( + axis2_libcurl_t *curl, + const axutil_env_t * env, + const axis2_char_t * str); + +static void +axis2_libcurl_free_headers( + axis2_libcurl_t *curl, + const axutil_env_t * env); + +static axis2_status_t +axis2_libcurl_set_options( + CURL *handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +axis2_status_t AXIS2_CALL +axis2_libcurl_send( + axis2_libcurl_t *data, + axiom_output_t * om_output, + 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) +{ + struct curl_slist *headers = NULL; + axiom_soap_body_t *soap_body; + axis2_bool_t is_soap = AXIS2_TRUE; + axis2_bool_t send_via_get = AXIS2_FALSE; + axis2_bool_t send_via_head = AXIS2_FALSE; + axis2_bool_t send_via_put = AXIS2_FALSE; + axis2_bool_t send_via_delete = AXIS2_FALSE; + axis2_bool_t doing_mtom = AXIS2_FALSE; + axiom_node_t *body_node = NULL; + axiom_node_t *data_out = NULL; + axutil_property_t *method = NULL; + axis2_char_t *method_value = NULL; + axiom_xml_writer_t *xml_writer = NULL; + axis2_char_t *buffer = NULL; + unsigned int buffer_size = 0; + int content_length = -1; + axis2_char_t *content_type = NULL; + axis2_char_t *content_len = AXIS2_HTTP_HEADER_CONTENT_LENGTH_; + const axis2_char_t *char_set_enc = NULL; + axis2_char_t *content = AXIS2_HTTP_HEADER_CONTENT_TYPE_; + axis2_char_t *soap_action_header = AXIS2_HTTP_HEADER_SOAP_ACTION_; + axutil_stream_t *in_stream; + axutil_property_t *trans_in_property; + axutil_string_t *char_set_enc_str; + axis2_byte_t *output_stream = NULL; + int output_stream_size = 0; + CURL *handler; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *write_xml_declaration_param = NULL; + axutil_hash_t *transport_attrs = NULL; + axis2_bool_t write_xml_declaration = AXIS2_FALSE; + axutil_property_t *property; + int *response_length = NULL; + axis2_http_status_line_t *status_line = NULL; + axis2_char_t *status_line_str = NULL; + axis2_char_t *tmp_strcat = NULL; + int status_code = 0; + + AXIS2_PARAM_CHECK(env->error, data, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, data->handler, AXIS2_FAILURE); + + handler = data->handler; + curl_easy_reset(handler); + curl_easy_setopt(handler, CURLOPT_ERRORBUFFER, &data->errorbuffer); + headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_USER_AGENT_AXIS2C); + headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_ACCEPT_); + headers = curl_slist_append(headers, AXIS2_HTTP_HEADER_EXPECT_); + + if(AXIS2_FAILURE == axis2_libcurl_set_options(handler, env, msg_ctx)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[axis2libcurl]Setting options in Libcurl failed"); + return AXIS2_FAILURE; + } + + if (AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + is_soap = AXIS2_FALSE; + } + else + { + is_soap = AXIS2_TRUE; + } + + if (!is_soap) + { + soap_body = axiom_soap_envelope_get_body(out, env); + if (!soap_body) + { + AXIS2_HANDLE_ERROR(env, + AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + body_node = axiom_soap_body_get_base_node(soap_body, env); + if (!body_node) + { + AXIS2_HANDLE_ERROR(env, + AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, + AXIS2_FAILURE); + + return AXIS2_FAILURE; + } + data_out = axiom_node_get_first_element(body_node, env); + + method = (axutil_property_t *) axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_HTTP_METHOD); + + if (method) + { + method_value = + (axis2_char_t *) axutil_property_get_value(method, env); + } + + /* The default is POST */ + if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_GET)) + { + send_via_get = AXIS2_TRUE; + } + else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_HEAD)) + { + send_via_head = AXIS2_TRUE; + } + else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_PUT)) + { + send_via_put = AXIS2_TRUE; + } + else if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_DELETE)) + { + send_via_delete = AXIS2_TRUE; + } + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx (msg_ctx, env); + if (conf_ctx) + { + conf = axis2_conf_ctx_get_conf (conf_ctx, env); + } + + if (conf) + { + trans_desc = axis2_conf_get_transport_out (conf, + env, AXIS2_TRANSPORT_ENUM_HTTP); + } + + if (trans_desc) + { + write_xml_declaration_param = + axutil_param_container_get_param + (axis2_transport_out_desc_param_container (trans_desc, env), env, + AXIS2_XML_DECLARATION); + } + + if (write_xml_declaration_param) + { + transport_attrs = + axutil_param_get_attributes (write_xml_declaration_param, env); + if (transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *write_xml_declaration_attr = NULL; + axis2_char_t *write_xml_declaration_attr_value = NULL; + + obj = axutil_hash_get (transport_attrs, AXIS2_ADD_XML_DECLARATION, + AXIS2_HASH_KEY_STRING); + if (obj) + { + write_xml_declaration_attr = (axiom_attribute_t *) + axutil_generic_obj_get_value (obj, + env); + } + if (write_xml_declaration_attr) + { + write_xml_declaration_attr_value = + axiom_attribute_get_value (write_xml_declaration_attr, env); + } + if (write_xml_declaration_attr_value && + 0 == axutil_strcasecmp (write_xml_declaration_attr_value, + AXIS2_VALUE_TRUE)) + { + write_xml_declaration = AXIS2_TRUE; + } + } + } + + if (write_xml_declaration) + { + axiom_output_write_xml_version_encoding (om_output, env); + } + + if (!send_via_get && !send_via_head && !send_via_delete) + { + xml_writer = axiom_output_get_xml_writer(om_output, env); + + char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env); + + if (!char_set_enc_str) + { + char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; + } + else + { + char_set_enc = axutil_string_get_buffer(char_set_enc_str, env); + } + + if (!send_via_put && is_soap) + { + doing_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env); + + axiom_output_set_do_optimize(om_output, env, doing_mtom); + axiom_soap_envelope_serialize(out, env, om_output, AXIS2_FALSE); + if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + if (AXIS2_ESC_DOUBLE_QUOTE != *soap_action) + { + axis2_char_t *tmp_soap_action = NULL; + tmp_soap_action = + AXIS2_MALLOC(env->allocator, + (axutil_strlen(soap_action) + + 5) * sizeof(axis2_char_t)); + sprintf(tmp_soap_action, "\"%s\"", soap_action); + tmp_strcat = axutil_stracat(env, soap_action_header,tmp_soap_action); + headers = curl_slist_append(headers, tmp_strcat); + AXIS2_FREE(env->allocator, tmp_strcat); + AXIS2_FREE(env->allocator, tmp_soap_action); + } + else + { + tmp_strcat = axutil_stracat(env, soap_action_header, soap_action); + headers = curl_slist_append(headers, tmp_strcat ); + AXIS2_FREE(env->allocator, tmp_strcat); + } + } + + if (doing_mtom) + { + /*axiom_output_flush(om_output, env, &output_stream, + &output_stream_size);*/ + axiom_output_flush(om_output, env); + content_type = + (axis2_char_t *) axiom_output_get_content_type(om_output, + env); + if (AXIS2_TRUE != axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + if (axutil_strcmp(soap_action, "")) + { + /* handle SOAP action for SOAP 1.2 case */ + axis2_char_t *temp_content_type = NULL; + temp_content_type = axutil_stracat (env, + content_type, + AXIS2_CONTENT_TYPE_ACTION); + content_type = temp_content_type; + temp_content_type = axutil_stracat (env, + content_type, + soap_action); + AXIS2_FREE (env->allocator, content_type); + content_type = temp_content_type; + temp_content_type = + axutil_stracat (env, content_type, + AXIS2_ESC_DOUBLE_QUOTE_STR); + AXIS2_FREE (env->allocator, content_type); + content_type = temp_content_type; + } + } + } + else if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + axis2_char_t *temp_content_type = NULL; + content_type = + (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + content_type = axutil_stracat(env, content_type, + AXIS2_CONTENT_TYPE_CHARSET); + temp_content_type = + axutil_stracat(env, content_type, char_set_enc); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + } + else + { + axis2_char_t *temp_content_type = NULL; + content_type = + (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP; + content_type = axutil_stracat(env, content_type, + AXIS2_CONTENT_TYPE_CHARSET); + temp_content_type = + axutil_stracat(env, content_type, char_set_enc); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + if (axutil_strcmp(soap_action, "")) + { + temp_content_type = + axutil_stracat(env, content_type, + AXIS2_CONTENT_TYPE_ACTION); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + temp_content_type = + axutil_stracat(env, content_type, soap_action); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + } + temp_content_type = axutil_stracat(env, content_type, + AXIS2_SEMI_COLON_STR); + AXIS2_FREE(env->allocator, content_type); + content_type = temp_content_type; + } + } + else if (is_soap) + { + AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "Attempt to send SOAP" + "message using HTTP PUT failed"); + return AXIS2_FAILURE; + } + else + { + axutil_property_t *content_type_property = NULL; + axutil_hash_t *content_type_hash = NULL; + axis2_char_t *content_type_value = NULL; + + axiom_node_serialize(data_out, env, om_output); + content_type_property = + (axutil_property_t *) + axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE); + + if (content_type_property) + { + content_type_hash = + (axutil_hash_t *) + axutil_property_get_value(content_type_property, env); + + if (content_type_hash) + { + content_type_value = + (char *) axutil_hash_get(content_type_hash, + AXIS2_HTTP_HEADER_CONTENT_TYPE, + AXIS2_HASH_KEY_STRING); + } + } + + if (content_type_value) + { + content_type = content_type_value; + } + else + { + content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + } + + } + + buffer = axiom_xml_writer_get_xml(xml_writer, env); + if (!doing_mtom) + { + buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); + } + else + buffer_size = output_stream_size; + { + char tmp_buf[10]; + sprintf(tmp_buf, "%d", buffer_size); + tmp_strcat = axutil_stracat(env, content_len, tmp_buf); + headers = curl_slist_append(headers, tmp_strcat); + AXIS2_FREE(env->allocator, tmp_strcat); + tmp_strcat = NULL; + + tmp_strcat = axutil_stracat(env, content, content_type); + headers = curl_slist_append(headers, tmp_strcat); + AXIS2_FREE(env->allocator, tmp_strcat); + tmp_strcat = NULL; + } + + if (!doing_mtom) + { + curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE, buffer_size); + curl_easy_setopt(handler, CURLOPT_POSTFIELDS, buffer); + } + else + { + curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE, + output_stream_size); + curl_easy_setopt(handler, CURLOPT_POSTFIELDS, output_stream); + } + + if (send_via_put) + { + curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_PUT); + } + curl_easy_setopt(handler, CURLOPT_URL, str_url); + } + else + { + axis2_char_t *request_param; + axis2_char_t *url_encode; + request_param = + (axis2_char_t *) axis2_http_sender_get_param_string(NULL, env, + msg_ctx); + url_encode = axutil_strcat(env, str_url, AXIS2_Q_MARK_STR, + request_param, NULL); + if (send_via_get) + { + curl_easy_setopt(handler, CURLOPT_HTTPGET, 1); + } + else if (send_via_head) + { + curl_easy_setopt(handler, CURLOPT_NOBODY, 1); + } + else if (send_via_delete) + { + curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, AXIS2_HTTP_DELETE); + } + curl_easy_setopt(handler, CURLOPT_URL, url_encode); + } + + { + axis2_bool_t manage_session; + manage_session = axis2_msg_ctx_get_manage_session(msg_ctx, env); + if (manage_session == AXIS2_TRUE) + { + if (data->cookies == AXIS2_FALSE) + { + /* Ensure cookies enabled to manage session */ + /* Pass empty cookie string to enable cookies */ + curl_easy_setopt(handler, CURLOPT_COOKIEFILE, " "); + data->cookies = AXIS2_TRUE; + } + } + else if (data->cookies == AXIS2_TRUE) + { + /* Pass special string ALL to reset cookies if any have been enabled. */ + /* If cookies have ever been enabled, we reset every time as long as + manage_session is false, as there is no clear curl option to + turn off the cookie engine once enabled. */ + curl_easy_setopt(handler, CURLOPT_COOKIELIST, AXIS2_ALL); + } + } + + curl_easy_setopt(handler, CURLOPT_HTTPHEADER, headers); + curl_easy_setopt(handler, CURLOPT_WRITEFUNCTION, + axis2_libcurl_write_memory_callback); + curl_easy_setopt(handler, CURLOPT_WRITEDATA, data); + + curl_easy_setopt (handler, CURLOPT_HEADERFUNCTION, axis2_libcurl_header_callback); + + curl_easy_setopt (handler, CURLOPT_WRITEHEADER, data); + + /* Free response data from previous request */ + if( data->size ) + { + if (data->memory) + { + AXIS2_FREE(data->env->allocator, data->memory); + } + data->size = 0; + } + + if (curl_easy_perform(handler)) + { + AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "%s", &data->errorbuffer); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + in_stream = axutil_stream_create_libcurl(env, data->memory, data->size); + trans_in_property = axutil_property_create(env); + axutil_property_set_scope(trans_in_property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_free_func(trans_in_property, env, + libcurl_stream_free); + axutil_property_set_value(trans_in_property, env, in_stream); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, + trans_in_property); + + if (axutil_array_list_size(data->alist, env) > 0) + { + status_line_str = axutil_array_list_get(data->alist, env, 0); + if (status_line_str) + { + status_line = axis2_http_status_line_create(env, status_line_str); + } + } + + if (status_line) + { + status_code = axis2_http_status_line_get_status_code(status_line, env); + } + + axis2_msg_ctx_set_status_code (msg_ctx, env, status_code); + AXIS2_FREE(data->env->allocator, content_type); + content_type = axis2_libcurl_get_content_type(data, env); + + if (content_type) + { + if (strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED) + && strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_XOP_XML)) + { + axis2_ctx_t *axis_ctx = + axis2_op_ctx_get_base (axis2_msg_ctx_get_op_ctx (msg_ctx, env), + env); + property = axutil_property_create (env); + axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value (property, + env, axutil_strdup (env, content_type)); + axis2_ctx_set_property (axis_ctx, + env, MTOM_RECIVED_CONTENT_TYPE, property); + } + } + + content_length = axis2_libcurl_get_content_length(data, env); + if (content_length >= 0) + { + response_length = AXIS2_MALLOC (env->allocator, sizeof (int)); + memcpy (response_length, &content_length, sizeof (int)); + property = axutil_property_create (env); + axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value (property, env, response_length); + axis2_msg_ctx_set_property (msg_ctx, env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, property); + } + + curl_slist_free_all (headers); + /* release the read http headers. */ + /* (commenting out the call below is a clever way to force a premature EOF + condition in subsequent messages, as they will be read using the content-length + of the first message.) */ + axis2_libcurl_free_headers(data, env); + AXIS2_FREE(data->env->allocator, content_type); + axis2_http_status_line_free( status_line, env); + + return AXIS2_SUCCESS; +} + +static size_t +axis2_libcurl_write_memory_callback( + void *ptr, + size_t size, + size_t nmemb, + void *data) +{ + size_t realsize = size * nmemb; + axis2_libcurl_t *curl = (axis2_libcurl_t *) data; + axis2_char_t *buffer = + (axis2_char_t *) AXIS2_MALLOC(curl->env->allocator, + curl->size + realsize + 1); + if (buffer) + { + if (curl->size) + { + memcpy(&(buffer[0]), curl->memory, curl->size); + AXIS2_FREE(curl->env->allocator, curl->memory); + } + + memcpy(&(buffer[curl->size]), ptr, realsize); + curl->size += (int)realsize; + /* We are sure that the difference lies within the int range */ + buffer[curl->size] = 0; + curl->memory = buffer; + } + return realsize; +} + +static size_t +axis2_libcurl_header_callback( + void *ptr, + size_t size, + size_t nmemb, + void *data) +{ + axis2_char_t *memory; + size_t realsize = size * nmemb; + axis2_libcurl_t *curl = (axis2_libcurl_t *) data; + memory = (axis2_char_t *)AXIS2_MALLOC(curl->env->allocator, realsize + 1); + if (memory) + { + memcpy(&(memory[0]), ptr, realsize); + memory[realsize] = 0; + axutil_array_list_add(curl->alist, curl->env, memory); + } + return realsize; +} + +axis2_libcurl_t * AXIS2_CALL +axis2_libcurl_create( + const axutil_env_t * env) +{ + axis2_libcurl_t *curl = NULL; + CURLcode code; + + if (!ref) + { + /* curl_global_init is not thread-safe so it would be better + to do this, as well as the test and increment of ref, under + mutex if one is available, or as part of an + axis2_initialize() if a global initialize is created. + Otherwise the client application should perform the the + curl_global_init itself in a thread-safe fashion. + */ + code = curl_global_init(CURL_GLOBAL_ALL); + if (code) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "libcurl curl_global_init failed, error: %d", code); + return NULL; + } + ref++; + } + + curl = + (axis2_libcurl_t *) AXIS2_MALLOC(env->allocator, + sizeof(axis2_libcurl_t)); + if (curl) + { + curl->memory = 0; + curl->size = 0; + curl->alist = axutil_array_list_create(env, 15); + curl->env = env; + curl->handler = curl_easy_init(); + curl->cookies = AXIS2_FALSE; + if ((!curl->alist) || (!curl->handler)) + { + axis2_libcurl_free(curl, env); + curl = 0; + } + } + return curl; +} + +void AXIS2_CALL +axis2_libcurl_free( + axis2_libcurl_t *curl, + const axutil_env_t * env) +{ + if (!curl) + { + return; + } + + if (curl->handler) + { + curl_easy_cleanup (curl->handler); + } + if (curl->alist) + { + axis2_libcurl_free_headers(curl, env); + axutil_array_list_free(curl->alist, env); + curl->alist = NULL; + } + if (curl->memory) + { + AXIS2_FREE(env->allocator, curl->memory); + } + + AXIS2_FREE(env->allocator, curl); +} + +static void +axis2_libcurl_free_headers( + axis2_libcurl_t *curl, + const axutil_env_t * env) +{ + int count = 0; + axutil_array_list_t *header_group = curl->alist; + if (header_group) + { + while ((count = axutil_array_list_size(header_group, env)) > 0) + { + axis2_char_t *header = axutil_array_list_remove(header_group, env, count-1); + AXIS2_FREE(env->allocator, header); + } + } +} + +static axis2_http_header_t * +axis2_libcurl_get_first_header( + axis2_libcurl_t *curl, + const axutil_env_t * env, + const axis2_char_t * str) +{ + axis2_http_header_t *tmp_header = NULL; + axis2_char_t *tmp_header_str = NULL; + axis2_char_t *tmp_name = NULL; + int i = 0; + int count = 0; + axutil_array_list_t *header_group = NULL; + + AXIS2_PARAM_CHECK(env->error, curl, NULL); + AXIS2_PARAM_CHECK(env->error, str, NULL); + + header_group = curl->alist; + if (!header_group) + { + return NULL; + } + + if (0 == axutil_array_list_size(header_group, env)) + { + return NULL; + } + + count = axutil_array_list_size(header_group, env); + + for (i = 0; i < count; i++) + { + tmp_header_str = (axis2_char_t *) axutil_array_list_get(header_group, + env, i); + if(!tmp_header_str) + { + continue; + } + tmp_header = (axis2_http_header_t *) axis2_http_header_create_by_str(env, tmp_header_str); + if(!tmp_header) + { + continue; + } + + tmp_name = axis2_http_header_get_name(tmp_header, env); + if (0 == axutil_strcasecmp(str, tmp_name)) + { + return tmp_header; + } + else + { + axis2_http_header_free( tmp_header, env ); + } + + } + return NULL; +} + +static int +axis2_libcurl_get_content_length( + axis2_libcurl_t *curl, + const axutil_env_t * env) +{ + axis2_http_header_t *tmp_header; + int rtn_value = -1; + + tmp_header = axis2_libcurl_get_first_header + (curl, env, AXIS2_HTTP_HEADER_CONTENT_LENGTH); + if (tmp_header) + { + rtn_value = AXIS2_ATOI(axis2_http_header_get_value(tmp_header, env)); + axis2_http_header_free( tmp_header, env ); + } + return rtn_value; +} + +static axis2_char_t * +axis2_libcurl_get_content_type( + axis2_libcurl_t *curl, + const axutil_env_t * env) +{ + axis2_http_header_t *tmp_header; + axis2_char_t *rtn_value = NULL; + + tmp_header = axis2_libcurl_get_first_header + (curl, env, AXIS2_HTTP_HEADER_CONTENT_TYPE); + if (tmp_header) + { + rtn_value = axutil_strdup (env, axis2_http_header_get_value(tmp_header, env) ); + axis2_http_header_free( tmp_header, env ); + } + else + { + rtn_value = axutil_strdup (env, AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN); + } + + return rtn_value; +} + +/** + * axis2_libcurl_set_auth_options maps authentication AXIS2/C options to + * libcURL options. + * + * CURLOPT_USERPWD - char * user:password for authentication + * CURLOPT_HTTPAUTH - long bitmask which authentication methods to use + */ +static axis2_status_t +axis2_libcurl_set_auth_options( + CURL *handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axutil_property_t *property = NULL; + axis2_char_t *uname = NULL; + axis2_char_t *passwd = NULL; + axis2_char_t *auth_type = NULL; + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_AUTH_UNAME); + if (property) + { + uname = (axis2_char_t *) axutil_property_get_value(property, env); + } + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_AUTH_PASSWD); + if (property) + { + passwd = (axis2_char_t *) axutil_property_get_value(property, env); + } + if (uname && passwd) + { + axis2_char_t buffer[256]; + strncpy(buffer, uname, 256); + strncat(buffer, ":", 256); + strncat(buffer, passwd, 256); + curl_easy_setopt(handler, CURLOPT_USERPWD, buffer); + } + + property = (axutil_property_t *)axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_AUTH_TYPE); + + if (property) + { + auth_type = (axis2_char_t *) axutil_property_get_value(property, env); + } + + if (auth_type && 0 == axutil_strcmp(auth_type, AXIS2_HTTP_AUTH_TYPE_BASIC)) + { + curl_easy_setopt(handler, CURLOPT_HTTPAUTH, CURLAUTH_BASIC); + } + else + { + /* Uses anonymous connection.*/ + } + + return AXIS2_SUCCESS; +} + +/** + * axis2_libcurl_set_proxy_options maps proxy AXIS2/C options to + * libcURL options. + * + * CURLOPT_PROXY - char * proxy hostname + * CURLOPT_PROXYPORT - long proxy listen port + * CURLOPT_PROXYUSERPWD - char * user:password to authenticate to proxy + * + * TODO: + * CURLOPT_PROXYTYPE - long enum type of proxy (HTTP, SOCKS) + * CURLOPT_PROXYAUTH - long bitmask which authentication methods to use for proxy + */ +static axis2_status_t +axis2_libcurl_set_proxy_options( + CURL *handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *proxy_param = NULL; + axutil_hash_t *transport_attrs = NULL; + axutil_property_t *property = NULL; + axis2_char_t *uname = NULL; + axis2_char_t *passwd = NULL; + axis2_char_t *proxy_host = NULL; + axis2_char_t *proxy_port = NULL; + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_UNAME); + if (property) + { + uname = (axis2_char_t *) axutil_property_get_value(property, env); + } + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_PROXY_AUTH_PASSWD); + if (property) + { + passwd = (axis2_char_t *) axutil_property_get_value(property, env); + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if (conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if (conf) + { + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); + } + } + if (trans_desc) + { + proxy_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, AXIS2_HTTP_PROXY_API); + if (!proxy_param) + { + proxy_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, AXIS2_HTTP_PROXY); + } + if (proxy_param) + { + transport_attrs = axutil_param_get_attributes(proxy_param, env); + } + } + + if (transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *attr = NULL; + + if (!uname || !passwd) + { + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_USERNAME, AXIS2_HASH_KEY_STRING); + if (obj) + { + attr = (axiom_attribute_t *) axutil_generic_obj_get_value(obj, env); + } + if (attr) + { + uname = axiom_attribute_get_value(attr, env); + } + + attr = NULL; + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PASSWORD, AXIS2_HASH_KEY_STRING); + if (obj) + { + attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if (attr) + { + passwd = axiom_attribute_get_value(attr, env); + } + } + + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_HOST, AXIS2_HASH_KEY_STRING); + if (obj) + { + attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if (attr) + { + proxy_host = axiom_attribute_get_value(attr, env); + } + if (proxy_host) + { + curl_easy_setopt(handler, CURLOPT_PROXY, proxy_host); + } + + attr = NULL; + obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PORT, AXIS2_HASH_KEY_STRING); + if (obj) + { + attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); + } + if (attr) + { + proxy_port = axiom_attribute_get_value(attr, env); + } + if (proxy_port) + { + curl_easy_setopt(handler, CURLOPT_PROXYPORT, AXIS2_ATOI(proxy_port)); + } + } + if (uname && passwd) + { + axis2_char_t buffer[256]; + strncpy(buffer, uname, 256); + strncat(buffer, ":", 256); + strncat(buffer, passwd, 256); + curl_easy_setopt(handler, CURLOPT_PROXYUSERPWD, buffer); + } + + return AXIS2_SUCCESS; +} + +/** + * axis2_libcurl_set_ssl_options maps SSL AXIS2/C options to + * libcURL options. + * + * CURLOPT_SSL_VERIFYHOST - long enum whether to verify the server identity + * CURLOPT_SSL_VERIFYPEER - long boolean whether to verify the server certificate + */ +static axis2_status_t +axis2_libcurl_set_ssl_options( + CURL *handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axutil_property_t *property = NULL; + axis2_char_t *verify_peer = NULL; + axis2_char_t *verify_host = NULL; + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SSL_VERIFY_PEER); + if (property) + { + verify_peer = (axis2_char_t *)axutil_property_get_value(property, env); + } + if (verify_peer) + { + if (0 == axutil_strcasecmp(verify_peer, AXIS2_VALUE_TRUE)) + { + curl_easy_setopt(handler, CURLOPT_SSL_VERIFYPEER, 1); + } + else + { + curl_easy_setopt(handler, CURLOPT_SSL_VERIFYPEER, 0); + } + } + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SSL_VERIFY_HOST); + if (property) + { + verify_host = (axis2_char_t *)axutil_property_get_value(property, env); + } + if (verify_host) + { + curl_easy_setopt(handler, CURLOPT_SSL_VERIFYHOST, AXIS2_ATOI(verify_host)); + } + + return AXIS2_SUCCESS; +} + +/** + * axis2_libcurl_set_connection_options maps connection AXIS2/C options to + * libcURL options. + * CURLOPT_CONNECTTIMEOUT_MS - long connection timeout in milliseconds + * CURLOPT_TIMEOUT_MS - long transfer timeout in milliseconds + */ +static axis2_status_t +axis2_libcurl_set_connection_options( + CURL *handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axutil_property_t *property = NULL; + long long_property_value = 0; + + /* check if timeout has been set by user using options + * with axis2_options_set_timeout_in_milli_seconds + */ + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_CONNECTION_TIMEOUT); + if (property) + { + axis2_char_t *value = axutil_property_get_value(property, env); + if (value) + { + long_property_value = AXIS2_ATOI(value); + curl_easy_setopt(handler, CURLOPT_CONNECTTIMEOUT_MS, long_property_value); + } + } + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_SO_TIMEOUT); + if (property) + { + axis2_char_t *value = axutil_property_get_value(property, env); + if (value) + { + long_property_value = AXIS2_ATOI(value); + curl_easy_setopt(handler, CURLOPT_TIMEOUT_MS, long_property_value); + } + } + + return AXIS2_SUCCESS; +} + +/** + * axis2_libcurl_set_options maps the AXIS2/C options to libcURL options. + */ +static axis2_status_t +axis2_libcurl_set_options( + CURL *handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + if (axis2_libcurl_set_auth_options(handler, env, msg_ctx) != AXIS2_SUCCESS) + { + return AXIS2_FAILURE; + } + + if (axis2_libcurl_set_proxy_options(handler, env, msg_ctx) != AXIS2_SUCCESS) + { + return AXIS2_FAILURE; + } + + if (axis2_libcurl_set_ssl_options(handler, env, msg_ctx) != AXIS2_SUCCESS) + { + return AXIS2_FAILURE; + } + + if (axis2_libcurl_set_connection_options(handler, env, msg_ctx) != AXIS2_SUCCESS) + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + + +#endif /* AXIS2_LIBCURL_ENABLED */ + diff --git a/src/core/transport/http/sender/libcurl/axis2_libcurl.h b/src/core/transport/http/sender/libcurl/axis2_libcurl.h new file mode 100644 index 0000000..f2971e5 --- /dev/null +++ b/src/core/transport/http/sender/libcurl/axis2_libcurl.h @@ -0,0 +1,53 @@ +/* + * 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_LIBCURL_H +#define AXIS2_LIBCURL_H +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* typedef struct axis2_libcurl axis2_libcurl_t; */ +/* actually defined in axis2_http_sender.h as it is part of axis2/include */ + +AXIS2_EXTERN axis2_libcurl_t *AXIS2_CALL +axis2_libcurl_create( + const axutil_env_t * env); + +AXIS2_EXTERN void AXIS2_CALL +axis2_libcurl_free( + axis2_libcurl_t *data, + const axutil_env_t * env); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_libcurl_send( + axis2_libcurl_t *data, + axiom_output_t * om_output, + 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 /* AXIS2_LIBCURL_H */ diff --git a/src/core/transport/http/sender/libcurl/libcurl_stream.c b/src/core/transport/http/sender/libcurl/libcurl_stream.c new file mode 100644 index 0000000..0c9126d --- /dev/null +++ b/src/core/transport/http/sender/libcurl/libcurl_stream.c @@ -0,0 +1,192 @@ +/* + * 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. + */ +#ifdef AXIS2_LIBCURL_ENABLED + +#include "libcurl_stream.h" +#include + +typedef struct libcurl_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + axis2_char_t *buffer; + int size; + int read_len; +} +libcurl_stream_impl_t; + +#define AXIS2_INTF_TO_IMPL(stream) ((libcurl_stream_impl_t *)(stream)) + +/********************************Function headers******************************/ +axutil_stream_type_t AXIS2_CALL libcurl_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL libcurl_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL libcurl_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +int AXIS2_CALL libcurl_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL libcurl_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +/************************* End of function headers ****************************/ + +/* + * Internal function. Not exposed to outside + */ +AXIS2_EXTERN axutil_stream_t *AXIS2_CALL +axutil_stream_create_libcurl( + const axutil_env_t * env, + axis2_char_t * buffer, + unsigned int size) +{ + libcurl_stream_impl_t *stream_impl = NULL; + + AXIS2_PARAM_CHECK(env->error, buffer, NULL); + + stream_impl = + (libcurl_stream_impl_t *) AXIS2_MALLOC(env->allocator, + sizeof(libcurl_stream_impl_t)); + + if (!stream_impl) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + stream_impl->buffer = buffer; + stream_impl->size = size; + stream_impl->read_len = 0; + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, libcurl_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, libcurl_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, libcurl_stream_skip); + + return &(stream_impl->stream); +} + +void AXIS2_CALL +libcurl_stream_free( + void * stream, + const axutil_env_t * env) +{ + libcurl_stream_impl_t *stream_impl = NULL; + + stream_impl = AXIS2_INTF_TO_IMPL(stream); + AXIS2_FREE(env->allocator, stream_impl); + + return; +} + +int AXIS2_CALL +libcurl_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + libcurl_stream_impl_t *stream_impl = NULL; + int read = 0; + int unread = 0; + + stream_impl = AXIS2_INTF_TO_IMPL(stream); + if (stream_impl->size >= (int)count) + /* We are sure that the difference lies within the int range */ + { + if (buffer && (stream_impl->size > stream_impl->read_len)) + { + unread = (stream_impl->size - stream_impl->read_len); + if (unread > (int)count) + /* We are sure that the difference lies within the int range */ + { + memcpy(buffer, &stream_impl->buffer[stream_impl->read_len], + count); + read = (int)count; + /* We are sure that the difference lies within the int range */ + stream_impl->read_len += read; + } + else + { + memcpy(buffer, &stream_impl->buffer[stream_impl->read_len], + unread); + read = unread; + stream_impl->read_len += read; + } + } + else + read = 0; + } + else + { + if (buffer && (stream_impl->size > stream_impl->read_len)) + { + memcpy(buffer, &stream_impl->buffer[stream_impl->read_len], + stream_impl->size - stream_impl->read_len); + read = stream_impl->size - stream_impl->read_len; + stream_impl->read_len += read; + } + else + read = 0; + } + return read; +} + +int AXIS2_CALL +libcurl_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count) +{ + return (int)count; + /* We are sure that the difference lies within the int range */ +} + +int AXIS2_CALL +libcurl_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + return 0; +} + +int AXIS2_CALL +libcurl_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + return 0; +} + +#endif /* AXIS2_LIBCURL_ENABLED */ + diff --git a/src/core/transport/http/sender/libcurl/libcurl_stream.h b/src/core/transport/http/sender/libcurl/libcurl_stream.h new file mode 100644 index 0000000..8a24fcc --- /dev/null +++ b/src/core/transport/http/sender/libcurl/libcurl_stream.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 LIBCURL_STREAM_H +#define LIBCURL_STREAM_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** brief Constructor for creating apche2 stream + * @return axutil_stream (libcurl) + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + axutil_stream_create_libcurl( + const axutil_env_t * env, + axis2_char_t * buffer, + unsigned int size); + + /** @} */ + + void AXIS2_CALL libcurl_stream_free( + void * stream, + const axutil_env_t * env); + + +#ifdef __cplusplus +} +#endif + +#endif /* LIBCURL_STREAM_H */ diff --git a/src/core/transport/http/sender/ssl/Makefile.am b/src/core/transport/http/sender/ssl/Makefile.am new file mode 100644 index 0000000..3e457e5 --- /dev/null +++ b/src/core/transport/http/sender/ssl/Makefile.am @@ -0,0 +1,2 @@ +EXTRA_DIST= ssl_stream.c ssl_stream.h ssl_utils.c ssl_utils.h + diff --git a/src/core/transport/http/sender/ssl/ssl_stream.c b/src/core/transport/http/sender/ssl/ssl_stream.c new file mode 100644 index 0000000..9360f1a --- /dev/null +++ b/src/core/transport/http/sender/ssl/ssl_stream.c @@ -0,0 +1,239 @@ +/* + * 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. + */ +#ifdef AXIS2_SSL_ENABLED + +#include +#include +#include "ssl_stream.h" +#include "ssl_utils.h" + +/** + * @brief Stream struct impl + * Streaming mechanisms for SSL + */ +typedef struct ssl_stream_impl ssl_stream_impl_t; + +struct ssl_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + SSL *ssl; + SSL_CTX *ctx; + axis2_socket_t socket; +}; + +#define AXIS2_INTF_TO_IMPL(stream) ((ssl_stream_impl_t *)(stream)) + +void AXIS2_CALL axis2_ssl_stream_free( + axutil_stream_t * stream, + const axutil_env_t * env); + +axutil_stream_type_t AXIS2_CALL axis2_ssl_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL axis2_ssl_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL axis2_ssl_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +int AXIS2_CALL axis2_ssl_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL axis2_ssl_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +AXIS2_EXTERN axutil_stream_t *AXIS2_CALL +axutil_stream_create_ssl( + const axutil_env_t * env, + axis2_socket_t socket, + axis2_char_t * server_cert, + axis2_char_t * key_file, + axis2_char_t * ssl_pp) +{ + ssl_stream_impl_t *stream_impl = NULL; + + stream_impl = + (ssl_stream_impl_t *) AXIS2_MALLOC(env->allocator, + sizeof(ssl_stream_impl_t)); + + if (!stream_impl) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset ((void *)stream_impl, 0, sizeof (ssl_stream_impl_t)); + stream_impl->socket = socket; + stream_impl->ctx = NULL; + stream_impl->ssl = NULL; + + stream_impl->ctx = axis2_ssl_utils_initialize_ctx(env, server_cert, + key_file, ssl_pp); + if (!stream_impl->ctx) + { + axis2_ssl_stream_free((axutil_stream_t *) stream_impl, env); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SSL_ENGINE, AXIS2_FAILURE); + return NULL; + } + stream_impl->ssl = axis2_ssl_utils_initialize_ssl(env, stream_impl->ctx, + stream_impl->socket); + if (!stream_impl->ssl) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SSL_ENGINE, AXIS2_FAILURE); + return NULL; + } + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, axis2_ssl_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, + axis2_ssl_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, axis2_ssl_stream_skip); + + return &(stream_impl->stream); +} + +void AXIS2_CALL +axis2_ssl_stream_free( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + ssl_stream_impl_t *stream_impl = NULL; + + stream_impl = AXIS2_INTF_TO_IMPL(stream); + axis2_ssl_utils_cleanup_ssl(env, stream_impl->ctx, stream_impl->ssl); + AXIS2_FREE(env->allocator, stream_impl); + + return; +} + +int AXIS2_CALL +axis2_ssl_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + ssl_stream_impl_t *stream_impl = NULL; + int read = -1; + int len = -1; + + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + SSL_set_mode(stream_impl->ssl, SSL_MODE_AUTO_RETRY); + + read = SSL_read(stream_impl->ssl, buffer, (int)count); + /* We are sure that the difference lies within the int range */ + switch (SSL_get_error(stream_impl->ssl, read)) + { + case SSL_ERROR_NONE: + len = read; + break; + case SSL_ERROR_ZERO_RETURN: + len = -1; + break; + case SSL_ERROR_SYSCALL: + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "SSL Error: Premature close"); + len = -1; + break; + default: + len = -1; + break; + } + return len; +} + +int AXIS2_CALL +axis2_ssl_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buf, + size_t count) +{ + ssl_stream_impl_t *stream_impl = NULL; + int write = -1; + + AXIS2_PARAM_CHECK(env->error, buf, AXIS2_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + write = SSL_write(stream_impl->ssl, buf, (int)count); + /* We are sure that the difference lies within the int range */ + + switch (SSL_get_error(stream_impl->ssl, write)) + { + case SSL_ERROR_NONE: + if ((int)count != write) + /* We are sure that the difference lies within the int range */ + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Incomplete SSL write!"); + break; + default: + return -1; + } + return write; +} + +int AXIS2_CALL +axis2_ssl_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + ssl_stream_impl_t *stream_impl = NULL; + axis2_char_t *tmp_buffer = NULL; + int len = -1; + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + tmp_buffer = AXIS2_MALLOC(env->allocator, count * sizeof(axis2_char_t)); + if (tmp_buffer == NULL) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return -1; + } + len = SSL_read(stream_impl->ssl, tmp_buffer, count); + AXIS2_FREE(env->allocator, tmp_buffer); + return len; + +} + +int AXIS2_CALL +axis2_ssl_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + int ret = -1; + + return ret; +} + +axutil_stream_type_t AXIS2_CALL +axis2_ssl_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + return AXIS2_INTF_TO_IMPL(stream)->stream_type; +} + +#endif + diff --git a/src/core/transport/http/sender/ssl/ssl_stream.h b/src/core/transport/http/sender/ssl/ssl_stream.h new file mode 100644 index 0000000..396da5d --- /dev/null +++ b/src/core/transport/http/sender/ssl/ssl_stream.h @@ -0,0 +1,50 @@ + +/* + * 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_SSL_STREAM_H +#define AXIS2_SSL_STREAM_H + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** \brief Constructor for creating ssl stream + * @return axutil_stream (ssl) + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + axutil_stream_create_ssl( + const axutil_env_t * env, + axis2_socket_t socket, + axis2_char_t * server_cert, + axis2_char_t * key_file, + axis2_char_t * ssl_pp); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SSL_STREAM_H */ diff --git a/src/core/transport/http/sender/ssl/ssl_utils.c b/src/core/transport/http/sender/ssl/ssl_utils.c new file mode 100644 index 0000000..d565555 --- /dev/null +++ b/src/core/transport/http/sender/ssl/ssl_utils.c @@ -0,0 +1,227 @@ +/* + * 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. + */ +#ifdef AXIS2_SSL_ENABLED + +#include "ssl_utils.h" +#include +BIO *bio_err = 0; + +static int +password_cb( + char *buf, + int size, + int rwflag, + void *passwd) +{ + strncpy(buf, (char *) passwd, size); + buf[size - 1] = '\0'; + return (int)(strlen(buf)); + /* We are sure that the difference lies within the int range */ +} + +AXIS2_EXTERN SSL_CTX *AXIS2_CALL +axis2_ssl_utils_initialize_ctx( + const axutil_env_t * env, + axis2_char_t * server_cert, + axis2_char_t * key_file, + axis2_char_t * ssl_pp) +{ + SSL_METHOD *meth = NULL; + SSL_CTX *ctx = NULL; + axis2_char_t *ca_file = server_cert; + + if (!ca_file) + { + AXIS2_LOG_INFO(env->log, "[ssl client] CA certificate not specified"); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SSL_NO_CA_FILE, AXIS2_FAILURE); + return NULL; + } + + if (!bio_err) + { + /* Global system initialization */ + SSL_library_init(); + SSL_load_error_strings(); + + /* An error write context */ + bio_err = BIO_new_fp(stderr, BIO_NOCLOSE); + } + + /* Create our context */ + meth = SSLv23_method(); + ctx = SSL_CTX_new(meth); + + /* Load our keys and certificates + * If we need client certificates it has to be done here + */ + if (key_file) /*can we check if the server needs client auth? */ + { + if (!ssl_pp) + { + AXIS2_LOG_INFO(env->log, + "[ssl client] No passphrase specified for \ +key file %s and server cert %s", key_file, server_cert); + } + + SSL_CTX_set_default_passwd_cb_userdata(ctx, (void *) ssl_pp); + SSL_CTX_set_default_passwd_cb(ctx, password_cb); + + if (!(SSL_CTX_use_certificate_chain_file(ctx, key_file))) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "[ssl client] Loading client certificate failed \ +, key file %s", key_file); + SSL_CTX_free(ctx); + return NULL; + } + + if (!(SSL_CTX_use_PrivateKey_file(ctx, key_file, SSL_FILETYPE_PEM))) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "[ssl client] Loading client key failed, key file \ +%s", key_file); + SSL_CTX_free(ctx); + return NULL; + } + } + else + { + AXIS2_LOG_INFO(env->log, + "[ssl client] Client certificate chain file" + "not specified"); + } + + /* Load the CAs we trust */ + if (!(SSL_CTX_load_verify_locations(ctx, ca_file, 0))) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "[ssl client] Loading CA certificate failed, \ +ca_file is %s", ca_file); + SSL_CTX_free(ctx); + return NULL; + } + + return ctx; +} + +AXIS2_EXTERN SSL *AXIS2_CALL +axis2_ssl_utils_initialize_ssl( + const axutil_env_t * env, + SSL_CTX * ctx, + axis2_socket_t socket) +{ + SSL *ssl = NULL; + BIO *sbio = NULL; + + AXIS2_PARAM_CHECK(env->error, ctx, NULL); + + ssl = SSL_new(ctx); + if (!ssl) + { + AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, + "[ssl]unable to create new ssl context"); + return NULL; + } + + sbio = BIO_new_socket((int)socket, BIO_NOCLOSE); + if (!sbio) + { + AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, + "[ssl]unable to create BIO new socket for socket %d", + (int)socket); + return NULL; + } + + SSL_set_bio(ssl, sbio, sbio); + if (SSL_connect(ssl) <= 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SSL_ENGINE, AXIS2_FAILURE); + return NULL; + } + + if (SSL_get_verify_result(ssl) != X509_V_OK) + { + char sslerror[128]; /** error buffer must be at least 120 bytes long */ + X509 *peer_cert = NULL; + X509_STORE *cert_store = NULL; + X509_NAME *peer_name = NULL; + X509_OBJECT *client_object = NULL; + X509 *client_cert = NULL; + + peer_cert = SSL_get_peer_certificate(ssl); + if (peer_cert && peer_cert->cert_info) + { + peer_name = (peer_cert->cert_info)->subject; + } + + cert_store = SSL_CTX_get_cert_store(ctx); + if (peer_name && cert_store) + { + client_object = X509_OBJECT_retrieve_by_subject(cert_store->objs, + X509_LU_X509, + peer_name); + } + if (client_object) + { + client_cert = (client_object->data).x509; + if (client_cert && + (M_ASN1_BIT_STRING_cmp(client_cert->signature, + peer_cert->signature) == 0)) + { + if (peer_cert) + { + X509_free(peer_cert); + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "[ssl client] SSL certificate verified against peer"); + return ssl; + } + } + if (peer_cert) + { + X509_free(peer_cert); + } + ERR_error_string(SSL_get_verify_result(ssl), sslerror); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "[ssl client] SSL certificate verification failed (%s)", + sslerror); + return NULL; + } + + return ssl; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ssl_utils_cleanup_ssl( + const axutil_env_t * env, + SSL_CTX * ctx, + SSL * ssl) +{ + + if (ssl) + { + SSL_shutdown(ssl); + } + if (ctx) + { + SSL_CTX_free(ctx); + } + return AXIS2_SUCCESS; +} + +#endif + diff --git a/src/core/transport/http/sender/ssl/ssl_utils.h b/src/core/transport/http/sender/ssl/ssl_utils.h new file mode 100644 index 0000000..26dc16b --- /dev/null +++ b/src/core/transport/http/sender/ssl/ssl_utils.h @@ -0,0 +1,56 @@ + +/* + * 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_SSL_UTILS_H +#define AXIS2_SSL_UTILS_H + + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN SSL_CTX *AXIS2_CALL + axis2_ssl_utils_initialize_ctx( + const axutil_env_t * env, + axis2_char_t * server_cert, + axis2_char_t * key_file, + axis2_char_t * ssl_pp); + + AXIS2_EXTERN SSL *AXIS2_CALL + axis2_ssl_utils_initialize_ssl( + const axutil_env_t * env, + SSL_CTX * ctx, + axis2_socket_t socket); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ssl_utils_cleanup_ssl( + const axutil_env_t * env, + SSL_CTX * ctx, + SSL * ssl); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SSL_UTILS_H */ diff --git a/src/core/transport/http/server/CGI/Makefile.am b/src/core/transport/http/server/CGI/Makefile.am new file mode 100644 index 0000000..fafb8bf --- /dev/null +++ b/src/core/transport/http/server/CGI/Makefile.am @@ -0,0 +1,31 @@ +prgbindir=$(bindir) +prgbin_PROGRAMS = axis2.cgi +SUBDIRS = +AM_CFLAGS = -g -pthread +axis2_cgi_SOURCES = axis2_cgi_main.c \ + axis2_cgi_out_transport_info.c \ + axis2_cgi_stream.c + +axis2_cgi_LDADD = $(LDFLAGS) \ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la \ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la \ + $(top_builddir)/src/core/description/libaxis2_description.la \ + $(top_builddir)/src/core/deployment/libaxis2_deployment.la \ + $(top_builddir)/src/core/context/libaxis2_context.la \ + $(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la \ + $(top_builddir)/src/core/transport/http/sender/libaxis2_http_sender.la \ + $(top_builddir)/src/core/transport/http/receiver/libaxis2_http_receiver.la \ + -lpthread + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description\ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/deployment\ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/server/CGI/axis2_cgi_main.c b/src/core/transport/http/server/CGI/axis2_cgi_main.c new file mode 100644 index 0000000..6f9a59d --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_main.c @@ -0,0 +1,280 @@ +/* + * 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. + */ + +#include "axis2_cgi_out_transport_info.h" +#include "axis2_cgi_stream.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +axis2_char_t *axis2_cgi_default_url_prefix = "/cgi-bin/axis2.cgi/"; + +/***************************** Function headers *******************************/ + +void +axis2_cgi_system_exit( + axutil_env_t * env, + int status); + +void +axis2_cgi_set_request_vars( + axis2_cgi_request_t *cgi_request); + +axis2_status_t +axis2_cgi_write_response( + const void *buffer, + unsigned int length); + +/***************************** End of function headers ************************/ + +int +main( + int argc, + char *argv[]) +{ + axutil_allocator_t *allocator = NULL; + axutil_env_t *env = NULL; + const axis2_char_t *repo_path; + axis2_conf_ctx_t *conf_ctx; + axis2_cgi_request_t *cgi_request = NULL; + int content_length = 0; + axis2_char_t *request_url = NULL; + /* axutil_stream_t *request_body_stream = NULL; */ + axutil_stream_t *out_stream = NULL; + axis2_transport_in_desc_t *in_desc = NULL; + axis2_transport_out_desc_t *out_desc = NULL; + /* axis2_msg_ctx_t *msg_ctx = NULL; */ + /* axis2_bool_t processed = AXIS2_FALSE; */ + axis2_http_transport_in_t request; + axis2_http_transport_out_t response; + /*axis2_http_header_t* http_header = NULL; */ + /*axutil_hash_t *headers = NULL; */ + /* axis2_char_t *axis2_cgi_url_prefix = NULL; */ + + if(!(repo_path = AXIS2_GETENV("AXIS2C_HOME"))) + { + fprintf(stderr, "Error: AXIS2C_HOME environment variable not set!"); + axis2_cgi_system_exit(env, -1); + } + + allocator = axutil_allocator_init(NULL); + env = axutil_env_create(allocator); + + if(axutil_file_handler_access(repo_path, AXIS2_R_OK) != AXIS2_SUCCESS) + { + fprintf(stderr, "Error reading repository: %s\nPlease check AXIS2C_HOME var", repo_path); + axis2_cgi_system_exit(env, -1); + } + + /* Set configuration */ + + conf_ctx = axis2_build_conf_ctx(env, repo_path); + if(!conf_ctx) + { + fprintf(stderr, "Error: Configuration not builded propertly\n"); + axis2_cgi_system_exit(env, -1); + } + + axis2_http_transport_utils_transport_out_init(&response, env); + axis2_http_transport_utils_transport_in_init(&request, env); + + /* Get input info */ + + cgi_request = AXIS2_MALLOC(allocator, sizeof(axis2_cgi_request_t)); + axis2_cgi_set_request_vars(cgi_request); + + request_url = (axis2_char_t *)AXIS2_MALLOC(allocator, (7 + /* "http:" */ + strlen(cgi_request->server_name) + ((strlen(cgi_request->server_port)) ? 1 : 0) + /* ":"*/ + strlen(cgi_request->server_port) + strlen(cgi_request->script_name) + strlen( + cgi_request->path_info) + ((strlen(cgi_request->path_info)) ? 1 : 0) + /* "?" */ + strlen(cgi_request->query_string)) * sizeof(axis2_char_t)); + + request_url[0] = '\0'; + + strcat(request_url, "http://"); + strcat(request_url, cgi_request->server_name); + if(strlen(cgi_request->server_port)) + strcat(request_url, ":"); + strcat(request_url, cgi_request->server_port); + strcat(request_url, cgi_request->script_name); + strcat(request_url, cgi_request->path_info); + if(strlen(cgi_request->query_string)) + strcat(request_url, "?"); + strcat(request_url, cgi_request->query_string); + + if(cgi_request->content_length) + content_length = axutil_atoi(cgi_request->content_length); + else + content_length = 0; + + /* Set streams */ + + out_stream = axutil_stream_create_basic(env); + + /* Set message contexts */ + + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + + request.msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + + axis2_msg_ctx_set_server_side(request.msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_transport_out_stream(request.msg_ctx, env, out_stream); + axis2_msg_ctx_set_transport_headers(request.msg_ctx, env, NULL); + + /* Set request parameters */ + + request.soap_action = cgi_request->soap_action; + request.in_stream = axutil_stream_create_cgi(env, content_length); + request.remote_ip = cgi_request->remote_addr; + request.content_length = content_length; + request.content_type = cgi_request->content_type; + request.request_uri = request_url; + request.svr_port = cgi_request->server_port; + request.accept_header = AXIS2_GETENV("HTTP_ACCEPT"); + request.accept_language_header = AXIS2_GETENV("HTTP_ACCEPT_LANGUAGE"); + request.accept_charset_header = AXIS2_GETENV("HTTP_ACCEPT_CHARSET"); + request.request_url_prefix = (AXIS2_GETENV("AXIS2C_URL_PREFIX")) ? AXIS2_GETENV( + "AXIS2C_URL_PREFIX") : axis2_cgi_default_url_prefix; + + if(axutil_strcasecmp(cgi_request->request_method, "POST") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_POST; + } + else if(axutil_strcasecmp(cgi_request->request_method, "GET") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_GET; + } + else if(axutil_strcasecmp(cgi_request->request_method, "HEAD") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_HEAD; + } + else if(axutil_strcasecmp(cgi_request->request_method, "PUT") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_PUT; + } + else if(axutil_strcasecmp(cgi_request->request_method, "DELETE") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_DELETE; + } + + request.out_transport_info = axis2_cgi_out_transport_info_create(env, cgi_request); + + /*Process request */ + fprintf(stderr, "ok\n"); + axis2_http_transport_utils_process_request(env, conf_ctx, &request, &response); + fprintf(stderr, "ok\n"); + /*Send status */ + + fprintf(stdout, "Status: %d %s \r\n", response.http_status_code, response.http_status_code_name); + + if(response.content_type) + { + fprintf(stdout, "Content-type: %s \r\n", response.content_type); + } + else if(strlen(axis2_cgi_out_transport_get_content(request.out_transport_info)) + && axis2_cgi_out_transport_get_content(request.out_transport_info)) + { + fprintf(stdout, "Content-type: %s \r\n", axis2_cgi_out_transport_get_content( + request.out_transport_info)); + } + + fprintf(stdout, "\r\n"); /* End of headers for server */ + + /* Write data body */ + if(!axis2_cgi_write_response(response.response_data, response.response_data_length)) + { + fprintf(stderr, "Error writing output data\n"); + } + + axis2_http_transport_utils_transport_in_uninit(&request, env); + axis2_http_transport_utils_transport_out_uninit(&response, env); + + return 0; +} + +axis2_status_t +axis2_cgi_write_response( + const void *buffer, + unsigned int length) +{ + if(buffer && length) + { + unsigned int completed = 0; + unsigned int written = 0; + + while(completed < length) + { + written = fwrite(buffer, sizeof(char), length - completed, stdout); + if(written < 0) + return AXIS2_FALSE; + completed += written; + } + } + return AXIS2_TRUE; +} + +void +axis2_cgi_set_request_vars( + axis2_cgi_request_t *cgi_request) +{ + cgi_request->server_name = (AXIS2_GETENV("SERVER_NAME")) ? AXIS2_GETENV("SERVER_NAME") : ""; + cgi_request->script_name = (AXIS2_GETENV("SCRIPT_NAME")) ? AXIS2_GETENV("SCRIPT_NAME") : ""; + cgi_request->path_info = (AXIS2_GETENV("PATH_INFO")) ? AXIS2_GETENV("PATH_INFO") : ""; + cgi_request->server_port = (AXIS2_GETENV("SERVER_PORT")) ? AXIS2_GETENV("SERVER_PORT") : ""; + cgi_request->server_protocol = (AXIS2_GETENV("SERVER_PROTOCOL")) ? AXIS2_GETENV( + "SERVER_PROTOCOL") : ""; + cgi_request->content_length = (AXIS2_GETENV("CONTENT_LENGTH")) ? AXIS2_GETENV("CONTENT_LENGTH") + : ""; + cgi_request->content_type = (AXIS2_GETENV("CONTENT_TYPE")) ? AXIS2_GETENV("CONTENT_TYPE") : ""; + cgi_request->request_method = (AXIS2_GETENV("REQUEST_METHOD")) ? AXIS2_GETENV("REQUEST_METHOD") + : ""; + cgi_request->remote_addr = (AXIS2_GETENV("REMOTE_ADDR")) ? AXIS2_GETENV("REMOTE_ADDR") : ""; + cgi_request->soap_action = (AXIS2_GETENV("HTTP_SOAPACTION")) ? AXIS2_GETENV("HTTP_SOAPACTION") + : NULL; + cgi_request->query_string = (AXIS2_GETENV("QUERY_STRING")) ? AXIS2_GETENV("QUERY_STRING") : ""; +} + +void +axis2_cgi_system_exit( + axutil_env_t * env, + int status) +{ + axutil_allocator_t *allocator = NULL; + + if(env) + { + allocator = env->allocator; + axutil_env_free(env); + } + exit(status); +} diff --git a/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c new file mode 100644 index 0000000..59e6820 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.c @@ -0,0 +1,160 @@ +/* + * 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. + */ + +#include "axis2_cgi_out_transport_info.h" +#include +#include + +/** + * @brief CIG Out transport info impl structure + * Axis2 cgi_out_transport_info_impl + */ + +typedef struct axis2_cgi_out_transport_info_s +{ + axis2_http_out_transport_info_t out_transport_info; + axis2_cgi_request_t *request; + axis2_char_t *encoding; +} axis2_cgi_out_transport_info_t; + +#define AXIS2_INTF_TO_IMPL(out_transport_info) \ + ((axis2_cgi_out_transport_info_t *)(out_transport_info)) + +void AXIS2_CALL +axis2_cgi_out_transport_info_free( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + AXIS2_ENV_CHECK(env, void); + + info_impl = AXIS2_INTF_TO_IMPL(info); + + info_impl->request = NULL; /* doesn't belong here so no need to free it here */ + if(info_impl->encoding) + { + AXIS2_FREE(env->allocator, info_impl->encoding); + info_impl->encoding = NULL; + } + + AXIS2_FREE(env->allocator, info_impl); + return; +} + +void AXIS2_CALL +axis2_cgi_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *transport_info_l = NULL; + + AXIS2_ENV_CHECK(env, void); + transport_info_l = (axis2_http_out_transport_info_t *)transport_info; + axis2_http_out_transport_info_free(transport_info_l, env); + return; +} + +axis2_status_t AXIS2_CALL +axis2_cgi_out_transport_info_set_content_type( + axis2_http_out_transport_info_t *info, + const axutil_env_t *env, + const axis2_char_t *content_type) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + + axis2_char_t *temp1 = NULL; + axis2_char_t *temp2 = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + info_impl = AXIS2_INTF_TO_IMPL(info); + if(info_impl->encoding) + { + temp1 = axutil_stracat(env, content_type, ";charset="); + temp2 = axutil_stracat(env, temp1, info_impl->encoding); + info_impl->request->content_type = axutil_strdup(env, temp2); + AXIS2_FREE(env->allocator, temp1); + AXIS2_FREE(env->allocator, temp2); + } + else + { + info_impl->request->content_type = axutil_strdup(env, content_type); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_cgi_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + + info_impl = AXIS2_INTF_TO_IMPL(info); + + if(info_impl->encoding) + { + AXIS2_FREE(env->allocator, info_impl->encoding); + } + info_impl->encoding = axutil_strdup(env, encoding); + + return AXIS2_SUCCESS; +} + +axis2_http_out_transport_info_t *AXIS2_CALL +axis2_cgi_out_transport_info_create( + const axutil_env_t * env, + axis2_cgi_request_t * request) +{ + axis2_cgi_out_transport_info_t *info = NULL; + axis2_http_out_transport_info_t *out_transport_info = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + info = (axis2_cgi_out_transport_info_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_cgi_out_transport_info_t)); + + if(!info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + info->request = request; + info->encoding = NULL; + + out_transport_info = &(info->out_transport_info); + + axis2_http_out_transport_info_set_char_encoding_func(out_transport_info, env, + axis2_cgi_out_transport_info_set_char_encoding); + axis2_http_out_transport_info_set_content_type_func(out_transport_info, env, + axis2_cgi_out_transport_info_set_content_type); + + return out_transport_info; +} + +axis2_char_t * +axis2_cgi_out_transport_get_content( + axis2_http_out_transport_info_t * info) +{ + axis2_cgi_out_transport_info_t *info_impl = NULL; + info_impl = AXIS2_INTF_TO_IMPL(info); + return info_impl->request->content_type; +} + diff --git a/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h new file mode 100644 index 0000000..bc0f526 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_out_transport_info.h @@ -0,0 +1,62 @@ + +/* + * 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_CGI_OUT_TRANSPORT_INFO_H +#define AXIS2_CGI_OUT_TRANSPORT_INFO_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_cgi_out_transport_info.h + * @brief axis2 CGI Out Transport Info + */ + +#include "axis2_cgi_types.h" +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + axis2_http_out_transport_info_t *AXIS2_CALL + + axis2_cgi_out_transport_info_create( + const axutil_env_t * env, + axis2_cgi_request_t * request); + + /** + * 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 + */ + void AXIS2_CALL + axis2_cgi_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env); + + axis2_char_t *axis2_cgi_out_transport_get_content( + axis2_http_out_transport_info_t * out_transport_info); + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SGI_OUT_TRANSPORT_INFO_H */ diff --git a/src/core/transport/http/server/CGI/axis2_cgi_stream.c b/src/core/transport/http/server/CGI/axis2_cgi_stream.c new file mode 100644 index 0000000..68ad19f --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_stream.c @@ -0,0 +1,164 @@ +/* + * 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. + */ + +#include +#include +#include "axis2_cgi_stream.h" + +/** + * @brief Stream struct impl + * Streaming mechanisms for cgi + */ + +typedef struct cgi_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + unsigned int cur_pos; + unsigned int content_length; +} cgi_stream_impl_t; + +#define AXIS2_INTF_TO_IMPL(stream) ((cgi_stream_impl_t *)(stream)) + +axutil_stream_type_t AXIS2_CALL +cgi_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL cgi_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL cgi_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +int AXIS2_CALL cgi_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL cgi_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +axutil_stream_t *AXIS2_CALL +axutil_stream_create_cgi( + const axutil_env_t * env, + unsigned int content_length) +{ + cgi_stream_impl_t *stream_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, content_length, NULL); + + stream_impl = (cgi_stream_impl_t *)AXIS2_MALLOC(env->allocator, sizeof(cgi_stream_impl_t)); + + if(!stream_impl) + { + return NULL; + } + stream_impl->cur_pos = 0; + stream_impl->content_length = content_length; + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, cgi_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, cgi_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, cgi_stream_skip); + + return &(stream_impl->stream); +} +int AXIS2_CALL +cgi_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + /*void *temp_buff = NULL;*/ + /*unsigned int data_to_read = 0;*/ + unsigned int read_bytes = 0; + /*axis2_bool_t ret_ok = AXIS2_TRUE;*/ + + cgi_stream_impl_t *stream_impl = NULL; + /*char *temp = NULL;*/ + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = (cgi_stream_impl_t *)stream; + + if(count < stream_impl->content_length) + { + read_bytes = fread(buffer, sizeof(char), count, stdin); + } + else + { + read_bytes = fread(buffer, sizeof(char), stream_impl->content_length, stdin); + } + + return read_bytes; +} + +int AXIS2_CALL +cgi_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buf, + size_t count) +{ + /* Cannot write on cgi stdin, explicitly an input stream */ + + return -1; +} + +int AXIS2_CALL +cgi_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + cgi_stream_impl_t *stream_impl = NULL; + int skipped = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + if(fseek(stdin, count, SEEK_CUR) == 0) + skipped = count; + return skipped; +} + +int AXIS2_CALL +cgi_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + int ret = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + return ret; +} + +axutil_stream_type_t AXIS2_CALL +cgi_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + return AXIS2_INTF_TO_IMPL(stream)->stream_type; +} diff --git a/src/core/transport/http/server/CGI/axis2_cgi_stream.h b/src/core/transport/http/server/CGI/axis2_cgi_stream.h new file mode 100644 index 0000000..9a6af34 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_stream.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 CGI_STREAM_H +#define CGI_STREAM_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** brief Constructor for creating CGI stream + * @return axutil_stream (CGI) + */ + axutil_stream_t *AXIS2_CALL + axutil_stream_create_cgi( + const axutil_env_t * env, + unsigned int content_length); + +#ifdef __cplusplus +} +#endif + +#endif /* CGI_STREAM_H */ diff --git a/src/core/transport/http/server/CGI/axis2_cgi_types.h b/src/core/transport/http/server/CGI/axis2_cgi_types.h new file mode 100644 index 0000000..af184a1 --- /dev/null +++ b/src/core/transport/http/server/CGI/axis2_cgi_types.h @@ -0,0 +1,34 @@ + +/* + * 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. + */ + +#include + +typedef struct axis2_cgi_request +{ + axis2_char_t *server_name; + axis2_char_t *server_port; + axis2_char_t *script_name; + axis2_char_t *path_info; + axis2_char_t *server_protocol; + axis2_char_t *content_length; + axis2_char_t *content_type; + axis2_char_t *request_method; + axis2_char_t *remote_addr; + axis2_char_t *soap_action; + axis2_char_t *query_string; +} axis2_cgi_request_t; diff --git a/src/core/transport/http/server/IIS/README b/src/core/transport/http/server/IIS/README new file mode 100644 index 0000000..1a47cc4 --- /dev/null +++ b/src/core/transport/http/server/IIS/README @@ -0,0 +1,61 @@ +How to Configure IIS Module for Axis2C +________________________________________ + +Use the Axis2/C VC project or makefile to build the component. + +In this document it is assumed that the mod_axis2_IIS.dll is in the directory +c:\axis2c\lib\mod_axis2_IIS.dll and axis2c_home is c:\axis2c + +Add the following key to the registry. + +HKEY_LOCAL_MACHINE\SOFTWARE\Apache Axis2c\IIS ISAPI Redirector + +Add a string value with the name axis2c_home and a value of c:\axis2c + +Add a string value with the name log_file and a value of c:\axis2c\logs\axis2.log + +Add a string value with the name log_level. The value can be one of trace, error, info, critical, debug, warning + +You can add a string value with the name services_url_prefix. This is optional and defaults to "/services". +As an example, if you have "/web_services" as the prefix, then all the services hosted would have the endpoint prefix of : +http://localhost/axis2/web_services. +Note: don't forget the / at the begining. + +If you wish, you can also change the location as well by adding a string value with the name axis2_location. +This is also optional and defaults to /axis2. If you have /myserser as the value you can access your web +services with a url like http://localhost/myserver/services. +Note: Don't forget the / at the beginning. + +Now you can do all the registry editing using the JScript file axis2_iis_regedit.js +provided with the distribution. When you build axis2/C with the IIS module the file +is copied to the root directory of the binary distribution. Just double click it and +everything will be set to the defaults. The axis2c_home is taken as the current directory, +so make sure you run the file in the Axis2/C repository location (or root of the binary distribution). +If you want to change the values you can manually edit the the .js file or give it as command line arguments +to the script when running the script. To run the jscript from the command line use the command +:\cscript axis2_iis_regedit.js optional arguments. +We recomend the manual editing as it is the easiest way to specify the values + +IIS 5.1 or Below + +Using the IIS management console, add a new virtual directory to your IIS/PWS Web site. +The name of the virtual directory must be axis2. Its physical path should be the directory +where you placed mod_axis2_IIS.dll (in our example it is c:\axis2c\lib). When creating this new +virtual directory, assign execute access to it. + +By Using the IIS management console, add mod_axis2_IIS.dll as a filter in your IIS/PWS web site and restart the IIS admin service. + + +IIS 6 & 7 + +Using the IIS management console, add the mod_axis2_IIS.dll as a Wildcard Script Map. + Executable should be the complete path to the mod_axis2_IIS.dll + You can put any name as the name of the Wildcard Script Map + +Please don't add the mod_axis2_IIS.dll as a filter to IIS as in the IIS 5.1 case. + +Note: If the Axis2/C failed to load, verify that Axis2/C and its dependent DLLs are in the System Path (not the user path). + + + + diff --git a/src/core/transport/http/server/IIS/axis2_iis_constants.h b/src/core/transport/http/server/IIS/axis2_iis_constants.h new file mode 100644 index 0000000..fb6929b --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_constants.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_IIS_CONSTANTS_H +#define AXIS2_IIS_CONSTANTS_H + +#define INTERNET_MAX_PATH_LENGTH 2048 +#define INTERNET_MAX_SCHEME_LENGTH 32 /* longest protocol name length */ +#define INTERNET_MAX_URL_LENGTH (INTERNET_MAX_SCHEME_LENGTH +sizeof("://") +INTERNET_MAX_PATH_LENGTH) + +#define URI_MATCHED 1 +#define URI_UN_MATCHED 2 + +#define EXTENSION_URL "/axis2/mod_axis2_IIS.dll\? " +#define EXTENSION_URL_AXIS2 "/axis2/" +#define EXTENSION_URL_MODIIS "mod_axis2_IIS.dll\? " + + +#define MAX_SERVERNAME 128 +#define MAX_PORT_LEN 8 + +#define MAX_HTTP_VERSION_LEN 16 +#define MAX_HTTP_CONTENT_TYPE_LEN 2048 +#define MAX_CONTENT_ENCODING_LEN 16 +#define MAX_HTTP_METHOD_LEN 8 +#define MAX_TCP_PORT_LEN 8 +#define MAX_CONTENT_LEN 16 + +#define OK 200 +#define HTTP_INTERNAL_SERVER_ERROR 500 +#define HTTP_ACCEPTED 202 + +#define AXIS2_STRICMP _stricmp + +#endif /*AXIS2_IIS_CONSTANTS_H*/ + diff --git a/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c new file mode 100644 index 0000000..fb7693b --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.c @@ -0,0 +1,153 @@ +/* + * 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. + */ + +#include "axis2_iis_out_transport_info.h" +#include +#include +#include + +#include "axis2_iis_constants.h" + +/** + * @brief IIS Out transport info impl structure + * Axis2 iis_out_transport_info_impl + */ + +typedef struct axis2_iis_out_transport_info_s +{ + axis2_http_out_transport_info_t out_transport_info; + axis2_char_t *encoding; + axis2_char_t content_type[MAX_HTTP_CONTENT_TYPE_LEN]; +} axis2_iis_out_transport_info_t; + +#define AXIS2_INTF_TO_IMPL(out_transport_info) \ + ((axis2_iis_out_transport_info_t *)(out_transport_info)) + +void AXIS2_CALL +axis2_iis_out_transport_info_free( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env) +{ + axis2_iis_out_transport_info_t *info = NULL; + AXIS2_ENV_CHECK(env, void); + + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + if(info->encoding) + { + AXIS2_FREE(env->allocator, info->encoding); + info->encoding = NULL; + } + + AXIS2_FREE(env->allocator, info); + return; +} + +void AXIS2_CALL +axis2_iis_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *transport_info_l = NULL; + + AXIS2_ENV_CHECK(env, void); + transport_info_l = (axis2_http_out_transport_info_t *)transport_info; + axis2_http_out_transport_info_free(transport_info_l, env); + return; +} + +axis2_status_t AXIS2_CALL +axis2_iis_out_transport_info_set_content_type( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_iis_out_transport_info_t *info_impl = NULL; + + info_impl = AXIS2_INTF_TO_IMPL(info); + info_impl->content_type[0] = '\0'; + if(info_impl->encoding) + { + sprintf(info_impl->content_type, "%s%s%s", content_type, ";charser:", info_impl->encoding); + } + else + { + strcat(info_impl->content_type, content_type); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_iis_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + axis2_iis_out_transport_info_t *info_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + + info_impl = AXIS2_INTF_TO_IMPL(info); + + if(info_impl->encoding) + { + AXIS2_FREE(env->allocator, info_impl->encoding); + } + info_impl->encoding = axutil_strdup(env, encoding); + + return AXIS2_SUCCESS; +} + +axis2_http_out_transport_info_t *AXIS2_CALL +axis2_iis_out_transport_info_create( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + axis2_iis_out_transport_info_t *info = NULL; + axis2_http_out_transport_info_t *http_out_info = NULL; + AXIS2_ENV_CHECK(env, NULL); + + info = (axis2_iis_out_transport_info_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_iis_out_transport_info_t)); + + if(!info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + info->encoding = NULL; + + http_out_info = &(info->out_transport_info); + + axis2_http_out_transport_info_set_content_type_func(http_out_info, env, + axis2_iis_out_transport_info_set_content_type); + axis2_http_out_transport_info_set_char_encoding_func(http_out_info, env, + axis2_iis_out_transport_info_set_char_encoding); + axis2_http_out_transport_info_set_free_func(http_out_info, env, + axis2_iis_out_transport_info_free); + + return http_out_info; +} + +axis2_char_t * +axis2_iis_out_transport_get_content( + axis2_http_out_transport_info_t * info) +{ + axis2_iis_out_transport_info_t *info_impl = NULL; + info_impl = AXIS2_INTF_TO_IMPL(info); + return info_impl->content_type; +} diff --git a/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.h b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.h new file mode 100644 index 0000000..893ffdf --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_out_transport_info.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_IIS_OUT_TRANSPORT_INFO_H +#define AXIS2_IIS_OUT_TRANSPORT_INFO_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_iis_out_transport_info.h + * @brief axis2 IIS Out Transport Info + */ + +#include +#include +#ifdef __cplusplus +extern "C" +{ +#endif + + axis2_http_out_transport_info_t *AXIS2_CALL + + axis2_iis_out_transport_info_create( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB); + + /** + * 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 + */ + void AXIS2_CALL + axis2_iis_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env); + + axis2_char_t *axis2_iis_out_transport_get_content( + axis2_http_out_transport_info_t * out_transport_info); + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_IIS_OUT_TRANSPORT_INFO_H */ diff --git a/src/core/transport/http/server/IIS/axis2_iis_regedit.js b/src/core/transport/http/server/IIS/axis2_iis_regedit.js new file mode 100644 index 0000000..3889c1e --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_regedit.js @@ -0,0 +1,84 @@ +var WshShell = WScript.CreateObject("WScript.Shell"); + +/* You can change the following values to suite your requirements */ +/* Axis2/C repo location. axis2.xml, modules folder and services folder should be in this dir */ +var axis2c_home = WshShell.CurrentDirectory; +/* Log level. Possible values are trace, error, info, critical, user, debug and warning */ +var log_level = "debug"; +/* Full path to the log file */ +var log_file = axis2c_home + "/logs/axis2.log"; +/* Services URL prefix. This is the folder where services are hosted. Optional */ +var services_url_prefix; +/* Max log file size */ +var max_log_file_size; +/* Axis2 location */ +var axis2_location; + +/* Don't change anything below */ +var axis2c_home_str = "axis2c_home"; +var log_level_str = "log_level"; +var log_file_str = "log_file"; +var services_url_prefix_str = "services_url_prefix"; +var max_log_file_size_str = "max_log_file_size"; +var axis2_location_str = "axis2_location" + +var reg_location = "HKLM\\Software\\Apache Axis2C\\IIS ISAPI Redirector\\" +/* If specified get the values from the command prompt */ +var args = WScript.Arguments; +if (args.length > 0) { + axis2c_home = args.Item(0); + if (axis2c_home) { + log_file = axis2c_home + "/logs/axis2.log"; + } +} +if (args.length > 1) { + log_level = args.Item(1); +} +if (args.length > 2) { + log_file = args.Item(2); +} +if (args.length > 3) { + services_url_prefix = args.Item(3); +} +if (args.length > 4) { + max_log_file_size = args.Item(4); +} +if (args.length > 5) { + axis2_location = args.Item(5); +} +/* Write the axis2c_home entry. This is used by Axis2/C to find the repo location */ +WshShell.RegWrite (reg_location + axis2c_home_str, axis2c_home, "REG_SZ"); +/* Write the log_level registry entry */ +WshShell.RegWrite (reg_location + log_level_str, log_level, "REG_SZ"); +/* Write the log file name */ +WshShell.RegWrite (reg_location + log_file_str, log_file, "REG_SZ"); +/* Write the services url prefix. We write this only if specified */ +try { + var services_url_prefix_key = WshShell.RegRead (reg_location + services_url_prefix_str); + if (services_url_prefix_key) { + WshShell.RegDelete (reg_location + services_url_prefix_str); + } +} catch (e) {} +if (services_url_prefix) { + WshShell.RegWrite (reg_location + services_url_prefix_str, services_url_prefix, "REG_SZ"); +} +/* We write max_log_file_size only if specified */ +try { + var max_log_file_size_key = WshShell.RegRead (reg_location + max_log_file_size_str); + if (max_log_file_size_key) { + WshShell.RegDelete (reg_location + max_log_file_size_str); + } +} catch (e) {} +if (max_log_file_size) { + WshShell.RegWrite (reg_location + max_log_file_size_str, max_log_file_size, "REG_SZ"); +} + +try{ + var axis2_location_key = WshShell.RegRead (reg_location + axis2_location_str); + if (axis2_location_key) { + WshShell.RegDelete (reg_location + axis2_location_str); + } +} catch (e) {} +if (axis2_location) { + WshShell.RegWrite (reg_location + axis2_location_str, axis2_location, "REG_SZ"); +} \ No newline at end of file diff --git a/src/core/transport/http/server/IIS/axis2_iis_stream.c b/src/core/transport/http/server/IIS/axis2_iis_stream.c new file mode 100644 index 0000000..90fc8ba --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_stream.c @@ -0,0 +1,313 @@ +/* + * 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. + */ + +#include +#include +#include "axis2_iis_stream.h" +#include + +/** + * @brief Stream struct impl + * Streaming mechanisms for iis web server + */ + +typedef struct iis_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + LPEXTENSION_CONTROL_BLOCK lpECB; + unsigned int cur_pos; + void *cur_position; +} iis_stream_impl_t; + +#define AXIS2_INTF_TO_IMPL(stream) ((iis_stream_impl_t *)(stream)) + +axutil_stream_type_t AXIS2_CALL +iis_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL iis_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL iis_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +int AXIS2_CALL iis_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL iis_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +axutil_stream_t *AXIS2_CALL +axutil_stream_create_iis( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + iis_stream_impl_t *stream_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, lpECB, NULL); + + stream_impl = (iis_stream_impl_t *)AXIS2_MALLOC(env->allocator, sizeof(iis_stream_impl_t)); + + if(!stream_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + stream_impl->cur_pos = 0; + stream_impl->cur_position = NULL; + stream_impl->lpECB = lpECB; + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, iis_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, iis_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, iis_stream_skip); + + return &(stream_impl->stream); +} + +int AXIS2_CALL +iis_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + void *temp_buff = NULL; + unsigned int data_to_read = 0; + DWORD ret_val = TRUE; + DWORD read_bytes = (DWORD)count; + iis_stream_impl_t *stream_impl = NULL; + char *temp = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = (iis_stream_impl_t *)stream; + + if(stream_impl->cur_pos == 0) + stream_impl->cur_position = stream_impl->lpECB->lpbData; + + /* If this is the case all the bytes are in the lpECB->lpbData buffer*/ + if(stream_impl->lpECB->cbAvailable == stream_impl->lpECB->cbTotalBytes) + { + /* Cannot read more than in the buffer.*/ + if(count + stream_impl->cur_pos <= stream_impl->lpECB->cbAvailable) + data_to_read = (unsigned)count; + else + data_to_read = stream_impl->lpECB->cbTotalBytes - stream_impl->cur_pos; + + memcpy(buffer, stream_impl->cur_position, data_to_read); + temp = (char *)(stream_impl->cur_position); + temp += data_to_read; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += data_to_read; + read_bytes = data_to_read; + } + else if(stream_impl->lpECB->cbAvailable == -1) + { + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, buffer, &read_bytes); + } + else if(stream_impl->lpECB->cbAvailable < stream_impl->lpECB->cbTotalBytes) + { + if(stream_impl->cur_pos > stream_impl->lpECB->cbAvailable) + { + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, buffer, + &read_bytes); + } + else if(stream_impl->cur_pos + count > stream_impl->lpECB->cbAvailable + && stream_impl->cur_pos < stream_impl->lpECB->cbAvailable) + { + int read_length = 0; + if(count + stream_impl->cur_pos <= stream_impl->lpECB->cbAvailable) + read_length = (unsigned)count; + else + read_length = stream_impl->lpECB->cbTotalBytes - stream_impl->cur_pos; + data_to_read = stream_impl->lpECB->cbAvailable - stream_impl->cur_pos; + memcpy(buffer, stream_impl->cur_position, data_to_read); + + read_bytes = stream_impl->cur_pos + read_length - stream_impl->lpECB->cbAvailable; + temp_buff = malloc(read_bytes); + + if(temp_buff == NULL) + return data_to_read; + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, + &read_bytes); + memcpy(((char *)buffer + data_to_read), temp_buff, read_bytes); + read_bytes += data_to_read; + temp = (char *)(stream_impl->cur_position); + temp += read_bytes; + stream_impl->cur_position = temp; + stream_impl->cur_pos += (unsigned)read_bytes; + } + else + { + memcpy(buffer, stream_impl->cur_position, count); + temp = (char *)(stream_impl->cur_position); + temp += count; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += (unsigned)count; + read_bytes = (int)count; + } + } + if(ret_val == TRUE) + return read_bytes; + else + return -1; +} + +int AXIS2_CALL +iis_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buf, + size_t count) +{ + DWORD ret_val = NO_ERROR; + unsigned long bytes_sent = 0; + iis_stream_impl_t *stream_impl = NULL; + axis2_char_t *buffer = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, buf, AXIS2_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + buffer = (axis2_char_t *)buf; + bytes_sent = (unsigned)strlen(buffer); + + if(count <= 0) + { + return (int)count; + } + /* assume that buffer is not null terminated */ + ret_val = stream_impl->lpECB->WriteClient(stream_impl->lpECB->ConnID, buffer, &bytes_sent, + HSE_IO_SYNC); + if(ret_val == TRUE) + return (int)bytes_sent; + else + return -1; +} + +int AXIS2_CALL +iis_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + DWORD ret_val = TRUE; + iis_stream_impl_t *stream_impl = NULL; + void *temp_buff = NULL; + int data_to_read = 0; + DWORD read_bytes = (DWORD)count; + char *temp = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = (iis_stream_impl_t *)stream; + + if(stream_impl->cur_pos == 0) + stream_impl->cur_position = stream_impl->lpECB->lpbData; + + if(stream_impl->lpECB->cbAvailable == stream_impl->lpECB->cbTotalBytes) + { + if(count + stream_impl->cur_pos <= stream_impl->lpECB->cbAvailable) + data_to_read = count; + else + data_to_read = stream_impl->lpECB->cbAvailable - stream_impl->cur_pos; + + temp = (char *)(stream_impl->cur_position); + temp += data_to_read; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += data_to_read; + read_bytes = data_to_read; + } + else if(stream_impl->lpECB->cbAvailable == -1) + { + temp_buff = malloc(read_bytes); + ret_val + = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, &read_bytes); + free(temp_buff); + } + else if(stream_impl->lpECB->cbAvailable < stream_impl->lpECB->cbTotalBytes) + { + if(stream_impl->cur_pos > stream_impl->lpECB->cbAvailable) + { + temp_buff = malloc(read_bytes); + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, + &read_bytes); + free(temp_buff); + } + else if(stream_impl->cur_pos + count > stream_impl->lpECB->cbAvailable + && stream_impl->cur_pos < stream_impl->lpECB->cbAvailable) + { + data_to_read = stream_impl->lpECB->cbAvailable - stream_impl->cur_pos; + read_bytes = stream_impl->cur_pos + count - stream_impl->lpECB->cbAvailable; + temp_buff = malloc(read_bytes); + + if(temp_buff == NULL) + return data_to_read; + + ret_val = stream_impl->lpECB->ReadClient(stream_impl->lpECB->ConnID, temp_buff, + &read_bytes); + read_bytes += data_to_read; + free(temp_buff); + } + else + { + temp = (char *)(stream_impl->cur_position); + temp += count; + stream_impl->cur_position = temp; + temp = NULL; + stream_impl->cur_pos += count; + read_bytes = count; + } + } + if(ret_val == FALSE) + { + return -1; + } + return read_bytes; +} + +int AXIS2_CALL +iis_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + int ret = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + return ret; +} + +axutil_stream_type_t AXIS2_CALL +iis_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + return AXIS2_INTF_TO_IMPL(stream)->stream_type; +} diff --git a/src/core/transport/http/server/IIS/axis2_iis_stream.h b/src/core/transport/http/server/IIS/axis2_iis_stream.h new file mode 100644 index 0000000..091edb0 --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_stream.h @@ -0,0 +1,45 @@ + +/* + * 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 IIS_STREAM_H +#define IIS_STREAM_H + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** brief Constructor for creating IIS stream + * @return axutil_stream (IIS) + */ + axutil_stream_t *AXIS2_CALL + axutil_stream_create_iis( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB); + +#ifdef __cplusplus +} +#endif + +#endif /* IIS_STREAM_H */ diff --git a/src/core/transport/http/server/IIS/axis2_iis_worker.c b/src/core/transport/http/server/IIS/axis2_iis_worker.c new file mode 100644 index 0000000..51a6cc8 --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_worker.c @@ -0,0 +1,607 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "axis2_iis_out_transport_info.h" +#include "axis2_iis_stream.h" +#include "axis2_iis_worker.h" + +/* Files from iis */ +#include +#include + +#include "axis2_iis_constants.h" + +#define READ_SIZE 2048 + +axis2_status_t AXIS2_CALL +axis2_worker_get_original_url( + char url[], + char ret_url[]); + +axis2_char_t * AXIS2_CALL +axis2_iis_worker_get_bytes( + const axutil_env_t * env, + axutil_stream_t * stream); + +axis2_status_t AXIS2_CALL +start_response( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB, + int status, + const char *reason, + axutil_array_list_t *headers); + +axis2_status_t +write_response( + LPEXTENSION_CONTROL_BLOCK lpECB, + const void *b, + unsigned int l); + +axutil_hash_t * +axis2_iis_worker_read_http_headers( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB); + +AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + +static struct reasons +{ + axis2_char_t * status_code; + int status_len; +} reasons[] = { { "200 OK", 6 }, { "202 Accepted", 12 }, { "500 Internal Server Error", 25 } }; + +struct axis2_iis_worker +{ + axis2_conf_ctx_t * conf_ctx; +}; + +char * +status_reason( + int status); + +axis2_iis_worker_t * AXIS2_CALL +axis2_iis_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path) +{ + axis2_iis_worker_t * iis_worker = NULL; + + iis_worker = (axis2_iis_worker_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_iis_worker_t)); + if(!iis_worker) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + iis_worker->conf_ctx = axis2_build_conf_ctx(env, repo_path); + if(!iis_worker->conf_ctx) + { + axis2_iis_worker_free((axis2_iis_worker_t *)iis_worker, env); + return NULL; + } + return iis_worker; +} + +void AXIS2_CALL +axis2_iis_worker_free( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env) +{ + if(iis_worker->conf_ctx) + { + axis2_conf_ctx_free(iis_worker->conf_ctx, env); + iis_worker->conf_ctx = NULL; + } + AXIS2_FREE(env->allocator, iis_worker); + return; +} + +int AXIS2_CALL +axis2_iis_worker_process_request( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + axis2_conf_ctx_t * conf_ctx = NULL; + axutil_stream_t * out_stream = NULL; + axis2_transport_out_desc_t * out_desc = NULL; + axis2_transport_in_desc_t * in_desc = NULL; + axis2_char_t soap_action[INTERNET_MAX_URL_LENGTH]; + axis2_char_t original_url[INTERNET_MAX_URL_LENGTH]; + axis2_char_t req_url[INTERNET_MAX_URL_LENGTH]; + DWORD cbSize = 0; + CHAR server_name[MAX_SERVERNAME]; + axis2_char_t port[MAX_TCP_PORT_LEN]; + axis2_char_t redirect_url[INTERNET_MAX_PATH_LENGTH]; + axis2_char_t accept_language[INTERNET_MAX_PATH_LENGTH]; + axutil_hash_t *headers = NULL; + axis2_char_t peer_ip[50]; + axis2_char_t accept_header[INTERNET_MAX_URL_LENGTH]; + axis2_char_t accept_charset[INTERNET_MAX_URL_LENGTH]; + /*axutil_property_t *peer_property = NULL;*/ + + axis2_http_header_t *content_type_header = NULL; + axis2_http_header_t *content_length_header = NULL; + + /* New Code variables */ + axis2_http_transport_in_t request; + axis2_http_transport_out_t response; + + /* initialize tranport in structure */ + axis2_http_transport_utils_transport_in_init(&request, env); + + /* initialize tranport out structure */ + axis2_http_transport_utils_transport_out_init(&response, env); + + soap_action[0] = '\0'; + + /*Check the parameters*/ + if(!lpECB) + { + AXIS2_ERROR_SET_ERROR_NUMBER(env->error, AXIS2_ERROR_INVALID_NULL_PARAM); + return AXIS2_FAILURE; + } + conf_ctx = iis_worker->conf_ctx; + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "SERVER_NAME", server_name, &cbSize) == FALSE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot get server name from IIS."); + return AXIS2_FAILURE; + } + cbSize = MAX_TCP_PORT_LEN; + if(lpECB->GetServerVariable(lpECB->ConnID, "SERVER_PORT", port, &cbSize) == FALSE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot get server port from IIS."); + return AXIS2_FAILURE; + } + request.svr_port = port; + + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_URL", redirect_url, &cbSize) == FALSE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot get server port from IIS."); + return AXIS2_FAILURE; + } + + /* We have a mapped URL only when the server version is 5 or less than that. */ + if(server_version <= 5) + { + axis2_worker_get_original_url(redirect_url, original_url); + /* create the url using the above variables */ + sprintf(req_url, "%s%s%s%s%s", "http://", server_name, ":", port, original_url); + } + else + { + sprintf(req_url, "%s%s%s%s%s", "http://", server_name, ":", port, redirect_url); + } + /* Set the request url */ + request.request_uri = req_url; + + out_stream = axutil_stream_create_basic(env); + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(iis_worker->conf_ctx, env), + env, AXIS2_TRANSPORT_ENUM_HTTP); + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(iis_worker->conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_HTTP); + + /* Create the in message context */ + request.msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + axis2_msg_ctx_set_server_side(request.msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_transport_out_stream(request.msg_ctx, env, out_stream); + + /* Get the SOAPAction Header */ + cbSize = INTERNET_MAX_URL_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_SOAPAction", soap_action, &cbSize)) + { + request.soap_action = soap_action; + } + + /* Create the in stream */ + request.in_stream = axutil_stream_create_iis(env, lpECB); + if(!request.in_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in creating input stream."); + return AXIS2_FAILURE; + } + + /* Get the Remote Adrress */ + if(lpECB->GetServerVariable(lpECB->ConnID, "REMOTE_ADDR", peer_ip, &cbSize)) + { + request.remote_ip = peer_ip; + } + + /* Set the http headers into the message context */ + headers = axis2_iis_worker_read_http_headers(env, lpECB); + if(axis2_msg_ctx_set_transport_headers(request.msg_ctx, env, headers) == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "IIS: Error occured in setting transport headers."); + } + /* Set the content length */ + request.content_length = lpECB->cbTotalBytes; + /* Set the HTTP method */ + if(axutil_strcasecmp(lpECB->lpszMethod, "POST") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_POST; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "GET") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_GET; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "HEAD") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_HEAD; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "PUT") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_PUT; + } + else if(axutil_strcasecmp(lpECB->lpszMethod, "DELETE") == 0) + { + request.request_method = AXIS2_HTTP_METHOD_DELETE; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "IIS: Unsupported HTTP Method."); + return AXIS2_FAILURE; + } + /* Set the URL prefix. axis2_request_url_prefix is a global variable set at the init time */ + request.request_url_prefix = axis2_request_url_prefix; + /* Create the transport out info */ + request.out_transport_info = axis2_iis_out_transport_info_create(env, lpECB); + /* Set the content type */ + request.content_type = lpECB->lpszContentType; + + /* Get accept headaer */ + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_Accept", accept_header, &cbSize)) + { + request.accept_header = accept_header; + } + + /* Get the accept langauge */ + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_Accept-Language", accept_language, &cbSize)) + { + request.accept_language_header = accept_language; + } + + cbSize = INTERNET_MAX_PATH_LENGTH; + if(lpECB->GetServerVariable(lpECB->ConnID, "HTTP_Accept-Charset", accept_charset, &cbSize)) + { + request.accept_charset_header = accept_charset; + } + + /* Now we have set everything. We can call process method to process the request */ + if(axis2_http_transport_utils_process_request(env, conf_ctx, &request, &response) + == AXIS2_FAILURE) + { + return AXIS2_FAILURE; + } + + /* Write the response */ + if(response.response_data && response.response_data_length > 0) + { + axis2_char_t content_length_str[16] = { 0 }; + axis2_bool_t is_out_headers_created = AXIS2_FALSE; + if(!response.output_headers) + { + response.output_headers = axutil_array_list_create(env, 2); + is_out_headers_created = AXIS2_TRUE; + } + sprintf(content_length_str, "%d", response.response_data_length); + if(!response.content_type) + { + content_type_header = axis2_http_header_create(env, "Content-Type", + axis2_iis_out_transport_get_content(request.out_transport_info)); + } + else + { + content_type_header = axis2_http_header_create(env, "Content-Type", + response.content_type); + } + content_length_header = axis2_http_header_create(env, "Content-Length", content_length_str); + axutil_array_list_add(response.output_headers, env, content_length_header); + axutil_array_list_add(response.output_headers, env, content_type_header); + /* Write the headers */ + start_response(env, lpECB, response.http_status_code, response.http_status_code_name, + response.output_headers); + /* Write the response body */ + if(write_response(lpECB, response.response_data, response.response_data_length) + == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "IIS: Writing data to IIS"); + return AXIS2_FAILURE; + } + if(is_out_headers_created) + { + if(content_length_header) + { + axis2_http_header_free(content_length_header, env); + } + if(content_type_header) + { + axis2_http_header_free(content_type_header, env); + } + axutil_array_list_free(response.output_headers, env); + } + } + else + { + /* If we don't have a body we should write the HTTP headers */ + start_response(env, lpECB, response.http_status_code, response.http_status_code_name, + response.output_headers); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Response is NULL"); + } + + /* Do some cleaning */ + axis2_http_transport_utils_transport_in_uninit(&request, env); + axis2_http_transport_utils_transport_out_uninit(&response, env); + return AXIS2_SUCCESS; +} + +axis2_status_t +write_response( + LPEXTENSION_CONTROL_BLOCK lpECB, + const void *b, + unsigned int l) +{ + if(lpECB && b) + { + if(l) + { + unsigned int written = 0; + char *buf = (char *)b; + /* If couldn't write the data at onece try again until all the data is written.*/ + while(written < l) + { + DWORD try_to_write = l - written; + if(!lpECB-> WriteClient(lpECB->ConnID, buf + written, &try_to_write, 0)) + { + return AXIS2_FAILURE; + } + written += try_to_write; + } + } + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +start_response( + const axutil_env_t *env, + LPEXTENSION_CONTROL_BLOCK lpECB, + int status, + const char *reason, + axutil_array_list_t *headers) +{ + static char crlf[3] = { (char)13, (char)10, '\0' }; + unsigned int num_of_headers = 0; + + if(status < 100 || status > 1000) + { + return AXIS2_FAILURE; + } + if(lpECB) + { + size_t len_of_status; + char *status_str; + char *headers_str; + + /* + * Create the status line + */ + if(reason) + { + status_str = (char *)_alloca((6 + strlen(reason)) * sizeof(char)); + sprintf(status_str, "%d %s", status, reason); + len_of_status = strlen(status_str); + } + else + { + switch(status) + { + case 200: + status_str = reasons[0].status_code; + len_of_status = reasons[0].status_len; + break; + case 202: + status_str = reasons[1].status_code; + len_of_status = reasons[1].status_len; + break; + case 500: + status_str = reasons[2].status_code; + len_of_status = reasons[2].status_len; + break; + default: + status_str = reasons[0].status_code; + len_of_status = reasons[0].status_len; + break; + } + } + /* + * Create response headers string + */ + if(headers && (num_of_headers = axutil_array_list_size(headers, env)) > 0) + { + size_t i, len_of_headers; + axis2_http_header_t *header = NULL; + for(i = 0, len_of_headers = 0; i < num_of_headers; i++) + { + header = axutil_array_list_get(headers, env, (int)i); + len_of_headers += strlen(axis2_http_header_get_name(header, env)); + len_of_headers += strlen(axis2_http_header_get_value(header, env)); + len_of_headers += 4; /* extra for colon, space and crlf */ + } + len_of_headers += 3; /* crlf and terminating null char */ + headers_str = (char *)_alloca(len_of_headers * sizeof(char)); + headers_str[0] = '\0'; + for(i = 0; i < num_of_headers; i++) + { + header = axutil_array_list_get(headers, env, (int)i); + strcat(headers_str, axis2_http_header_get_name(header, env)); + strcat(headers_str, ": "); + strcat(headers_str, axis2_http_header_get_value(header, env)); + strcat(headers_str, "\r\n"); + } + strcat(headers_str, "\r\n"); + } + else + { + headers_str = crlf; + } + if(!lpECB-> ServerSupportFunction(lpECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER, status_str, + (LPDWORD) & len_of_status, (LPDWORD)headers_str)) + { + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} + +axis2_status_t AXIS2_CALL +axis2_worker_get_original_url( + char url[], + char ret_url[]) +{ + extern axis2_char_t *axis2_location; + strcpy(ret_url, axis2_location); + strcat(ret_url, &url[25]); + return URI_MATCHED; +} + +axis2_char_t * AXIS2_CALL +axis2_iis_worker_get_bytes( + const axutil_env_t * env, + axutil_stream_t * stream) +{ + axutil_stream_t * tmp_stream = NULL; + int return_size = -1; + axis2_char_t * buffer = NULL; + axis2_bool_t loop_state = AXIS2_TRUE; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, stream, NULL); + + tmp_stream = axutil_stream_create_basic(env); + while(loop_state) + { + int read = 0; + int write = 0; + char buf[READ_SIZE]; + + read = axutil_stream_read(stream, env, buf, READ_SIZE); + if(read < 0) + { + break; + } + write = axutil_stream_write(tmp_stream, env, buf, read); + if(read < (READ_SIZE - 1)) + { + break; + } + } + return_size = axutil_stream_get_len(tmp_stream, env); + if(return_size > 0) + { + buffer = (char *)AXIS2_MALLOC(env->allocator, sizeof(char) * (return_size + 2)); + return_size = axutil_stream_read(tmp_stream, env, buffer, return_size + 1); + buffer[return_size + 1] = '\0'; + } + axutil_stream_free(tmp_stream, env); + return buffer; +} + +/** Read all HTTP headers. + */ +axutil_hash_t * +axis2_iis_worker_read_http_headers( + const axutil_env_t * env, + LPEXTENSION_CONTROL_BLOCK lpECB) +{ + const char szHTTP_[] = "HTTP_"; + char szBuffer[4096]; + DWORD dwBufferSize = sizeof szBuffer; + axutil_hash_t *headers = NULL; + axis2_http_header_t* http_header = NULL; + + BOOL bGet = lpECB->GetServerVariable(lpECB->ConnID, "ALL_HTTP", szBuffer, &dwBufferSize); + if(bGet) + { + /* Find lines, split key/data pair and write them as output */ + LPTSTR pOpts = NULL; + LPTSTR pEnd = NULL; + LPTSTR pChar = NULL; + char szTmpBuf[512]; + char szTmpName[256]; + + headers = axutil_hash_make(env); + szTmpBuf[0] = 0; + for(pChar = szBuffer; '\0' != *pChar;) + { + if(*pChar == '\r' || *pChar == '\n') + { + pChar++; + continue; + } + pOpts = strchr(pChar, ':');/* findseparator */ + if(pOpts && *pOpts) + { + pEnd = pOpts; + while(*pEnd && *pEnd != '\r' && *pEnd != '\n') + { + pEnd++; + } + *pOpts = '\0'; /* split the strings */ + *pEnd = '\0'; + if(0 == strncmp(pChar, szHTTP_, strlen(szHTTP_))) + { + pChar += strlen(szHTTP_); + } + strcpy(szTmpName, pChar); + axutil_string_replace(szTmpName, '_', '-'); + http_header = axis2_http_header_create(env, szTmpName, pOpts + 1); + axutil_hash_set(headers, axutil_strdup(env, szTmpName), AXIS2_HASH_KEY_STRING, + http_header); + pChar = pEnd + 1; + } + } + } + else + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "axis2_iis_worker_read_http_headers: no http headers"); + } + return headers; +} + diff --git a/src/core/transport/http/server/IIS/axis2_iis_worker.h b/src/core/transport/http/server/IIS/axis2_iis_worker.h new file mode 100644 index 0000000..f9b6292 --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_iis_worker.h @@ -0,0 +1,62 @@ + +/* + * 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_APACHE2_WORKER_H +#define AXIS2_APACHE2_WORKER_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ + +#endif /* + */ + +typedef struct axis2_iis_worker axis2_iis_worker_t; + +int server_version; + +int AXIS2_CALL + axis2_iis_worker_process_request( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env, + void *r); + + +void AXIS2_CALL + axis2_iis_worker_free( + axis2_iis_worker_t * iis_worker, + const axutil_env_t * env); + + +axis2_iis_worker_t * AXIS2_CALL + axis2_iis_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path); + + +#ifdef __cplusplus +} +#endif /* + */ + +#endif /* AXIS2_IIS_WORKER_H */ diff --git a/src/core/transport/http/server/IIS/axis2_isapi_plugin.c b/src/core/transport/http/server/IIS/axis2_isapi_plugin.c new file mode 100644 index 0000000..eccfd1c --- /dev/null +++ b/src/core/transport/http/server/IIS/axis2_isapi_plugin.c @@ -0,0 +1,476 @@ + +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +#include "axis2_iis_constants.h" +#include "axis2_iis_worker.h" + +/* Axis headers */ +#include +#include +#include +#include +#include + +#ifndef _WIN32_WINNT +#define _WIN32_WINNT 0x0500 +#endif + +#define AXIS2_IIS_LOG_FILE_TAG "log_file" +#define AXIS2_IIS_LOG_LEVEL_TAG "log_level" +#define AXIS2_IIS_REPO_PATH_TAG "axis2c_home" +#define AXIS2_IIS_EXTENSION_URI_TAG "extension_uri" +#define AXIS2_IIS_REDIRECT_WORD_TAG "redirect_uri" +#define AXIS2_IIS_AXIS2_LOCATION "axis2_location" +#define AXIS2_IIS_SERVICE_URL_PREFIX "services_url_prefix" + +#define AXIS2_IIS_LOG_TRACE_VERB "trace" +#define AXIS2_IIS_LOG_ERROR_VERB "error" +#define AXIS2_IIS_LOG_INFO_VERB "info" +#define AXIS2_IIS_LOG_USER_VERB "user" +#define AXIS2_IIS_LOG_CRITICAL_VERB "critical" +#define AXIS2_IIS_LOG_WARN_VERB "warning" +#define AXIS2_IIS_LOG_DEBUG_VERB "debug" + +#define MAX_FILE_PATH 256 +#define REGISTRY_LOCATION "Software\\Apache Axis2c\\IIS ISAPI Redirector" + +static int is_inited = FALSE; +static axis2_iis_worker_t *axis2_worker = NULL; +static const axutil_env_t *axutil_env = NULL; + +/* Configuration parameters */ +axis2_char_t *axis2_location = "/axis2"; +static axis2_char_t *axis2_service_url_prefix= "/services"; +static axis2_char_t repo_path[MAX_FILE_PATH]; +static axis2_char_t log_file[MAX_FILE_PATH]; +static axutil_log_levels_t log_level = AXIS2_LOG_LEVEL_CRITICAL; + +/* Path variables */ +static char szOriginalPath[_MAX_PATH + 1]; +static char szPath[_MAX_PATH + 1]; + +axis2_char_t general_error[] = "\r\n" + " An IIS server error occurred. \r\n" + "

An IIS server error occurred

\r\n" + "
\r\n" + "An error occurred in IIS while processing this request."; + +axis2_char_t initializing_error[] = "\r\n" + " An IIS server error occurred. \r\n" + "

An IIS server error occurred

\r\n" + "
\r\n" + "An error occurred while initilizing Axis2/C."; + + +/* + * This is a utility functipn for reading configuration data from the registery. + */ +static axis2_status_t AXIS2_CALL +read_registery_init_data(); + +/* + * Utility function for reading + */ +static axis2_status_t AXIS2_CALL get_registry_config_parameter( + HKEY hkey, + const char *tag, + char *b, + DWORD sz); + +/* + * Parse the given string and return the corresponding log_level + */ +axutil_log_levels_t AXIS2_CALL axis2_iis_parse_log_level(char level[]); + +/* + * Initialize axis. This function is called in the begining of the module loading. + * It initializes the axis by reading values from the configuration and creating the + * required structures for the axis2c +*/ +axis2_status_t AXIS2_CALL init_axis2(); + +/* + * This is the function to be called after the processing + * is over for non Axis2 requets + */ +VOID +WINAPI +ExecUrlCompletion ( + EXTENSION_CONTROL_BLOCK * pecb, + PVOID pContext, + DWORD cbIO, + DWORD dwError + ); + +/* + * If somethign went wrong in the IIS server when + * we are proccessing we send this + */ +BOOL +send_error( + EXTENSION_CONTROL_BLOCK * pecb, + CHAR error[]); + +axis2_status_t AXIS2_CALL init_axis2(); + +BOOL +WINAPI +GetExtensionVersion(HSE_VERSION_INFO * pVer) +{ + pVer->dwExtensionVersion = MAKELONG( HSE_VERSION_MINOR, + HSE_VERSION_MAJOR); + strncpy( pVer->lpszExtensionDesc, + "WildCardMap Sample ISAPI Extension", HSE_MAX_EXT_DLL_NAME_LEN ); + + pVer->lpszExtensionDesc[HSE_MAX_EXT_DLL_NAME_LEN-1] = '\0'; + server_version = 5; + return TRUE; +} + +DWORD +WINAPI +HttpExtensionProc(EXTENSION_CONTROL_BLOCK * pecb) + +{ + HSE_EXEC_URL_INFO ExecUrlInfo; + DWORD cbData = INTERNET_MAX_URL_LENGTH; + char url[INTERNET_MAX_URL_LENGTH]; + axis2_bool_t is_for_us = AXIS2_TRUE; + + /* Get the URL */ + if ( pecb->GetServerVariable( pecb->ConnID, + "URL", + url, + &cbData ) == FALSE ) + { + return HSE_STATUS_ERROR; + } + + if (!is_inited) + { + DWORD dwBufferSize = 0; + axis2_char_t server_software[256]; + axis2_char_t *version = NULL; + + ZeroMemory(szOriginalPath, sizeof szOriginalPath); + dwBufferSize = sizeof szOriginalPath; + +#if _WIN32_WINNT >= 0x0502 + GetDllDirectory( dwBufferSize, szOriginalPath ); +#else + GetCurrentDirectory( dwBufferSize, szOriginalPath ); +#endif + ZeroMemory(szPath, sizeof szPath); + dwBufferSize = sizeof szPath; + /* Get the current physical paht */ + if (pecb->GetServerVariable(pecb->ConnID, "APPL_PHYSICAL_PATH", szPath, &dwBufferSize) == FALSE) + { + send_error(pecb, initializing_error); + return HSE_STATUS_ERROR; + } + /* Retrieve the server version */ + dwBufferSize = 32; + if (pecb->GetServerVariable(pecb->ConnID, "SERVER_SOFTWARE", server_software, &dwBufferSize) == FALSE) + { + send_error(pecb, initializing_error); + return HSE_STATUS_ERROR; + } + version = axutil_strchr(server_software, '/'); + if (version) + { + server_version = atoi(version + 1); + } +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szPath ); +#else + SetCurrentDirectory( szPath ); +#endif + /* If we haven't initialized axis2/c before initialization failed */ + if (AXIS2_FAILURE == init_axis2()) + { + send_error(pecb, initializing_error); + return HSE_STATUS_ERROR; + } +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szOriginalPath ); +#else + SetCurrentDirectory( szOriginalPath ); +#endif + } + + /* Check weather we have a request for Axis2/C */ + if (server_version >= 6 && strlen(url) >= strlen(axis2_location)) + { + int i = 0; + is_for_us = AXIS2_TRUE; + while (axis2_location[i] != '\0') + { + if (axis2_location[i] != (url)[i]) { + is_for_us = AXIS2_FALSE; + break; + } + i++; + } + if (url[i] != '/' && url[i] != '\0') + { + is_for_us = AXIS2_FALSE; + } + } + + if (is_for_us) + { + /* Windows cannot find the correct dlls unless the path is set*/ +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szPath ); +#else + SetCurrentDirectory( szPath ); +#endif + pecb->dwHttpStatusCode = HTTP_INTERNAL_SERVER_ERROR; + /* We are sure that worker is not NULL since it is NULL init_axis2 would have failed */ + axis2_iis_worker_process_request(axis2_worker, axutil_env, pecb); + + /* Windows cannot find the correct dlls unless the dir is set + but we want to reset to previous dir after the load */ +#if _WIN32_WINNT >= 0x0502 + SetDllDirectory( szOriginalPath ); +#else + SetCurrentDirectory( szOriginalPath ); +#endif + return HSE_STATUS_SUCCESS; + } + else if (server_version >= 6) + { + /* For IIS 5.1 or earlier this code is never executed. Since the URL is + redirected to Axis2/C by the Filter */ + + /* If not for Axis2/C let the request go to who ever wants it */ + ExecUrlInfo.pszUrl = NULL; /* Use original request URL */ + ExecUrlInfo.pszMethod = NULL; /* Use original request method */ + ExecUrlInfo.pszChildHeaders = NULL; /* Use original request headers */ + ExecUrlInfo.pUserInfo = NULL; /* Use original request user info */ + ExecUrlInfo.pEntity = NULL; /* Use original request entity */ + + /* Provent recursion */ + ExecUrlInfo.dwExecUrlFlags = HSE_EXEC_URL_IGNORE_CURRENT_INTERCEPTOR; + + /* Associate the completion routine and the current URL with this request. */ + if ( pecb->ServerSupportFunction( pecb->ConnID, + HSE_REQ_IO_COMPLETION, + ExecUrlCompletion, + NULL, + NULL) == FALSE ) + { + return HSE_STATUS_ERROR; + } + + /* Ok, now that everything is set up, let's call the child request */ + if ( pecb->ServerSupportFunction( pecb->ConnID, + HSE_REQ_EXEC_URL, + &ExecUrlInfo, + NULL, + NULL ) == FALSE ) + { + return HSE_STATUS_ERROR; + } + /* Return pending and let the completion clean up */ + return HSE_STATUS_PENDING; + } + return HSE_STATUS_ERROR; +} + +VOID +WINAPI +ExecUrlCompletion ( + EXTENSION_CONTROL_BLOCK * pecb, + PVOID pContext, + DWORD cbIO, + DWORD dwError + ) +{ + /* We are done so notify */ + pecb->ServerSupportFunction( + pecb->ConnID, + HSE_REQ_DONE_WITH_SESSION, + NULL, + NULL, + NULL); +} + + +BOOL +send_error( + EXTENSION_CONTROL_BLOCK * pecb, + axis2_char_t error[]) +{ + DWORD cbData; + pecb->dwHttpStatusCode = 500; + /* Send headers and response */ + pecb->ServerSupportFunction( pecb->ConnID, + HSE_REQ_SEND_RESPONSE_HEADER, + "500 Server Error", + NULL, + (LPDWORD)"Content-Type: text/html\r\n\r\n" ); + + cbData = axutil_strlen( error ); + return pecb->WriteClient( pecb->ConnID, + error, + &cbData, + HSE_IO_SYNC ); +} + +axis2_status_t AXIS2_CALL read_registery_init_data() +{ + long rc = 0; + axis2_status_t ok = TRUE; + char tmpbuf[INTERNET_MAX_URL_LENGTH]; + HKEY hkey; + AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + + rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGISTRY_LOCATION, (DWORD) 0, KEY_READ, &hkey); + if (ERROR_SUCCESS != rc) + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_REPO_PATH_TAG, tmpbuf, sizeof(repo_path))) + { + strcpy(repo_path, tmpbuf); + } + else + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_LOG_FILE_TAG, tmpbuf, sizeof(log_file))) + { + strcpy(log_file, tmpbuf); + } + else + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_LOG_LEVEL_TAG, tmpbuf, sizeof(tmpbuf))) + { + log_level = axis2_iis_parse_log_level(tmpbuf); + } + else + { + return AXIS2_FAILURE; + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_SERVICE_URL_PREFIX, tmpbuf, sizeof(tmpbuf))) + { + axis2_request_url_prefix = _strdup(tmpbuf); + } + if (get_registry_config_parameter(hkey, AXIS2_IIS_AXIS2_LOCATION, tmpbuf, sizeof(tmpbuf))) + { + axis2_location = _strdup(tmpbuf); + } + RegCloseKey(hkey); + return ok; +} + +axutil_log_levels_t AXIS2_CALL +axis2_iis_parse_log_level(char level[]) +{ + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_TRACE_VERB)) + { + return AXIS2_LOG_LEVEL_TRACE; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_DEBUG_VERB)) + { + return AXIS2_LOG_LEVEL_DEBUG; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_INFO_VERB)) + { + return AXIS2_LOG_LEVEL_INFO; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_USER_VERB)) + { + return AXIS2_LOG_LEVEL_USER; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_WARN_VERB)) + { + return AXIS2_LOG_LEVEL_WARNING; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_ERROR_VERB)) + { + return AXIS2_LOG_LEVEL_ERROR; + } + if (0 == AXIS2_STRICMP(level, AXIS2_IIS_LOG_CRITICAL_VERB)) + { + return AXIS2_LOG_LEVEL_CRITICAL; + } + return AXIS2_LOG_LEVEL_DEBUG; +} + +axis2_status_t AXIS2_CALL +get_registry_config_parameter(HKEY hkey, const char *tag, char *b, DWORD sz) +{ + DWORD type = 0; + LONG lrc; + + lrc = RegQueryValueEx(hkey, tag, (LPDWORD) 0, &type, (LPBYTE) b, &sz); + if ((ERROR_SUCCESS != lrc) || (type != REG_SZ)) + { + return FALSE; + } + b[sz] = '\0'; + return TRUE; +} + +/** + * This method initializes the axis2 engine. All the required variables are set to + * their initial values in this method. +*/ +axis2_status_t AXIS2_CALL init_axis2() +{ + /* + * These are the varibles required to initialize axis. + */ + axis2_status_t status = FALSE; + /* We need to init xml readers before we go into threaded env */ + if (!is_inited) + { + axiom_xml_reader_init(); + status = read_registery_init_data(); + if (status == AXIS2_FAILURE) + { + return AXIS2_FAILURE; + } + axutil_error_init(); + /* Initialize the environement */ + axutil_env = axutil_env_create_all(log_file, log_level); + if (!axutil_env) + { + return AXIS2_FAILURE; + } + axis2_worker = axis2_iis_worker_create(axutil_env, repo_path); + if (!axis2_worker) + { + return AXIS2_FAILURE; + } + is_inited = AXIS2_TRUE; + return AXIS2_SUCCESS; + } + return AXIS2_FAILURE; +} diff --git a/src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c b/src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c new file mode 100644 index 0000000..49cd6d9 --- /dev/null +++ b/src/core/transport/http/server/IIS/iis_iaspi_plugin_51/axis2_isapi_51.c @@ -0,0 +1,153 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "..\\axis2_iis_constants.h" + +#define REGISTRY_LOC "Software\\Apache Axis2c\\IIS ISAPI Redirector" +#define AXIS2_IIS_AXIS2_LOC "axis2_location" +static char *axis2_loc = "/axis2"; + +static axis2_char_t redirect_word[INTERNET_MAX_URL_LENGTH] = "/axis2/mod_axis2_IIS.dll\?"; +/* + * Search a given uri to find weather it matches a uri for the axis2 + * The uri format for axis2 is of the form + * scheme://server:port/axis2/other_parts + * This function search a give uri for the /axis2/. If a match + * is found it will replace the /axis2 part of the url with /axis2/mod_iis.dll? + */ +axis2_bool_t AXIS2_CALL +get_extension_url( + char url[], + char ret_url[]); + +/* + * This function is called by the IIS server at the server + * initialization. So this is the ideal plcae for initializing + * axis2c. + */ +BOOL WINAPI +GetFilterVersion( + PHTTP_FILTER_VERSION pVer) +{ + DWORD type = 0, size = 0; + LONG lrc = 0; + char tmpbuf[INTERNET_MAX_URL_LENGTH]; + HKEY hkey; + ULONG http_filter_revision = HTTP_FILTER_REVISION; + pVer->dwFilterVersion = pVer->dwServerFilterVersion; + if(pVer->dwFilterVersion > http_filter_revision) + { + pVer->dwFilterVersion = http_filter_revision; + } + + /* + Receive notifictions when + 1. Server preprocessed the headers. + 2. Log + 3. All the request coming in secure and none secure ports. + */ + pVer->dwFlags = (SF_NOTIFY_ORDER_HIGH | SF_NOTIFY_PREPROC_HEADERS | SF_NOTIFY_SECURE_PORT + | SF_NOTIFY_NONSECURE_PORT | SF_NOTIFY_AUTH_COMPLETE); + + /* Give a short discription about the module.*/ + strcpy(pVer->lpszFilterDesc, "axis2c filter"); + /* Get the axis2 location from the registry configuration */ + lrc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGISTRY_LOC, (DWORD)0, KEY_READ, &hkey); + if(ERROR_SUCCESS != lrc) + { + return FALSE; + } + size = INTERNET_MAX_URL_LENGTH; + lrc = RegQueryValueEx(hkey, AXIS2_IIS_AXIS2_LOC, (LPDWORD)0, &type, (LPBYTE)tmpbuf, &size); + if((ERROR_SUCCESS == lrc) && (type == REG_SZ)) + { + tmpbuf[size] = '\0'; + axis2_loc = _strdup(tmpbuf); + } + RegCloseKey(hkey); + return TRUE; +} + +/* + When a notification happens this function is called by the IIS. + */ +DWORD WINAPI +HttpFilterProc( + PHTTP_FILTER_CONTEXT pfc, + DWORD notificationType, + LPVOID pvNotification) +{ + DWORD bufferLength = INTERNET_MAX_URL_LENGTH; + char url[INTERNET_MAX_URL_LENGTH]; + char modified_url[INTERNET_MAX_URL_LENGTH]; + + if(notificationType == SF_NOTIFY_PREPROC_HEADERS) + { + pfc->GetServerVariable(pfc, "HTTP_URL", url, &bufferLength); + if(get_extension_url(url, modified_url)) + { + ((PHTTP_FILTER_PREPROC_HEADERS)pvNotification)->SetHeader(pfc, "url", modified_url); + return SF_STATUS_REQ_HANDLED_NOTIFICATION; + } + } + return SF_STATUS_REQ_NEXT_NOTIFICATION; +} + +axis2_bool_t AXIS2_CALL +get_extension_url( + char url[], + char ret_url[]) +{ + axis2_bool_t is_for_us = AXIS2_FALSE; + int i = 0; + /* Should contain "/axis2/"*/ + ret_url[0] = '\0'; + if(strlen(url) >= strlen(axis2_loc)) + { + is_for_us = AXIS2_TRUE; + while(axis2_loc[i] != '\0') + { + if(axis2_loc[i] != (url)[i]) + { + is_for_us = AXIS2_FALSE; + break; + } + i++; + } + if(url[i] != '/' && url[i] != '\0') + { + is_for_us = AXIS2_FALSE; + } + } + if(is_for_us) + { + strcpy(ret_url, redirect_word); + strcat(ret_url, &url[i]); + } + return is_for_us; +} diff --git a/src/core/transport/http/server/IIS/mod_axis2.def b/src/core/transport/http/server/IIS/mod_axis2.def new file mode 100644 index 0000000..22205e7 --- /dev/null +++ b/src/core/transport/http/server/IIS/mod_axis2.def @@ -0,0 +1,7 @@ +LIBRARY "mod_axis2_IIS" + +EXPORTS + GetExtensionVersion + HttpExtensionProc + GetFilterVersion + HttpFilterProc \ No newline at end of file diff --git a/src/core/transport/http/server/Makefile.am b/src/core/transport/http/server/Makefile.am new file mode 100644 index 0000000..07cf1e9 --- /dev/null +++ b/src/core/transport/http/server/Makefile.am @@ -0,0 +1,2 @@ +SUBDIRS=@APACHE2BUILD@ simple_axis2_server ${CGI_DIR} +EXTRA_DIST=IIS CGI diff --git a/src/core/transport/http/server/apache2/Makefile.am b/src/core/transport/http/server/apache2/Makefile.am new file mode 100644 index 0000000..d5f6bd8 --- /dev/null +++ b/src/core/transport/http/server/apache2/Makefile.am @@ -0,0 +1,40 @@ +lib_LTLIBRARIES = libmod_axis2.la +libmod_axis2_la_SOURCES = mod_axis2.c\ + apache2_stream.c\ + apache2_out_transport_info.c\ + apache2_worker.c + +AM_CFLAGS = -DLINUX=2 -D_REENTRANT -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -D_SVID_SOURCE -D_GNU_SOURCE + +libmod_axis2_la_LIBADD = $(LDFLAGS) \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la\ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la\ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la\ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la\ + -lpthread + +libmod_axis2_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/http \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/axiom/include\ + -I$(top_builddir)/util/include\ + @APACHE2INC@ \ + @APRINC@ + +EXTRA_DIST=axis2_apache2_worker.h apache2_stream.h axis2_apache2_out_transport_info.h + + + + + + + + diff --git a/src/core/transport/http/server/apache2/apache2_out_transport_info.c b/src/core/transport/http/server/apache2/apache2_out_transport_info.c new file mode 100644 index 0000000..9deaa56 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_out_transport_info.c @@ -0,0 +1,191 @@ +/* + * 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. + */ + +#include "axis2_apache2_out_transport_info.h" +#include +#include +#include +#include + +typedef struct axis2_apache2_out_transport_info +{ + axis2_http_out_transport_info_t out_transport_info; + request_rec *request; + axis2_char_t *encoding; +} axis2_apache2_out_transport_info_t; + +#define AXIS2_INTF_TO_IMPL(out_transport_info) \ + ((axis2_apache2_out_transport_info_t *)(out_transport_info)) + +void AXIS2_CALL +axis2_apache2_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env) +{ + axis2_http_out_transport_info_t *transport_info_l = NULL; + + AXIS2_ENV_CHECK(env, void); + transport_info_l = (axis2_http_out_transport_info_t *)transport_info; + axis2_http_out_transport_info_free(transport_info_l, env); + return; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_free( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env) +{ + axis2_apache2_out_transport_info_t *info = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + info->request = NULL; /* request doesn't belong to info */ + if(info->encoding) + { + AXIS2_FREE(env->allocator, info->encoding); + info->encoding = NULL; + } + + AXIS2_FREE(env->allocator, info); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_content_type( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_apache2_out_transport_info_t *info = NULL; + + axis2_char_t *tmp1 = NULL; + axis2_char_t *tmp2 = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + if(info->encoding) + { + + tmp1 = axutil_stracat(env, content_type, ";charset="); + tmp2 = axutil_stracat(env, tmp1, info->encoding); + info->request->content_type = apr_pstrdup(info->request->pool, tmp2); + AXIS2_FREE(env->allocator, tmp1); + AXIS2_FREE(env->allocator, tmp2); + } + else + { + info->request->content_type = apr_pstrdup(info->request->pool, content_type); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_char_encoding( + axis2_http_out_transport_info_t * info, + const axutil_env_t * env, + const axis2_char_t * encoding) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, encoding, AXIS2_FAILURE); + + if(info->encoding) + { + AXIS2_FREE(env->allocator, info->encoding); + } + info->encoding = axutil_strdup(env, encoding); + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_cookie_header( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * cookie_header) +{ + axis2_apache2_out_transport_info_t *info = NULL; + + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, cookie_header, AXIS2_FAILURE); + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + apr_table_set(info->request->headers_out, AXIS2_HTTP_HEADER_SET_COOKIE, cookie_header); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_apache_out_transport_info_set_session( + axis2_http_out_transport_info_t * out_transport_info, + const axutil_env_t * env, + const axis2_char_t * session_id, + const axis2_char_t * session_value) +{ + axis2_apache2_out_transport_info_t *info = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, session_id, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, session_value, AXIS2_FAILURE); + info = AXIS2_INTF_TO_IMPL(out_transport_info); + + status = env->set_session_fn(info->request, session_id, session_value); + + return status; +} + +axis2_http_out_transport_info_t *AXIS2_CALL +axis2_apache2_out_transport_info_create( + const axutil_env_t * env, + request_rec * request) +{ + axis2_apache2_out_transport_info_t *info = NULL; + axis2_http_out_transport_info_t *out_transport_info = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + info = (axis2_apache2_out_transport_info_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_apache2_out_transport_info_t)); + + if(!info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + info->request = request; + info->encoding = NULL; + + out_transport_info = &(info->out_transport_info); + out_transport_info->encoding = NULL; + out_transport_info->response = NULL; + + axis2_http_out_transport_info_set_char_encoding_func(out_transport_info, env, + axis2_apache_out_transport_info_set_char_encoding); + axis2_http_out_transport_info_set_content_type_func(out_transport_info, env, + axis2_apache_out_transport_info_set_content_type); + axis2_http_out_transport_info_set_cookie_header_func(out_transport_info, env, + axis2_apache_out_transport_info_set_cookie_header); + axis2_http_out_transport_info_set_session_func(out_transport_info, env, + axis2_apache_out_transport_info_set_session); + + return out_transport_info; +} + + diff --git a/src/core/transport/http/server/apache2/apache2_stream.c b/src/core/transport/http/server/apache2/apache2_stream.c new file mode 100644 index 0000000..5e189a7 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_stream.c @@ -0,0 +1,292 @@ +/* + * 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. + */ + +#include +#include +#include "apache2_stream.h" +#include + +typedef struct apache2_stream_impl +{ + axutil_stream_t stream; + axutil_stream_type_t stream_type; + request_rec *request; +} apache2_stream_impl_t; + +#define AXIS2_INTF_TO_IMPL(stream) ((apache2_stream_impl_t *)(stream)) + +axutil_stream_type_t AXIS2_CALL +apache2_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env); + +int AXIS2_CALL apache2_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buffer, + size_t count); + +int AXIS2_CALL apache2_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count); + +static int AXIS2_CALL +apache2_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count); + +int AXIS2_CALL apache2_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env); + +static apr_size_t +apache2_ap_get_client_block( + request_rec *r, + char* buffer, + apr_size_t bufsiz); + +AXIS2_EXTERN axutil_stream_t *AXIS2_CALL +axutil_stream_create_apache2( + const axutil_env_t * env, + request_rec * request) +{ + apache2_stream_impl_t *stream_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, request, NULL); + + stream_impl = (apache2_stream_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(apache2_stream_impl_t)); + + if(!stream_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset(&(stream_impl->stream), 0, sizeof(axutil_stream_t)); + + stream_impl->request = request; + stream_impl->stream_type = AXIS2_STREAM_MANAGED; + + axutil_stream_set_read(&(stream_impl->stream), env, apache2_stream_read); + axutil_stream_set_write(&(stream_impl->stream), env, apache2_stream_write); + axutil_stream_set_skip(&(stream_impl->stream), env, apache2_stream_skip); + + return &(stream_impl->stream); +} + +int AXIS2_CALL +apache2_stream_read( + axutil_stream_t * stream, + const axutil_env_t * env, + void *buffer, + size_t count) +{ + apache2_stream_impl_t *stream_impl = NULL; + size_t read = 0; + size_t len = 0; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + while(count - len > 0) + { + read = apache2_ap_get_client_block(stream_impl->request, (char *) buffer + len, + count - len); + if(read > 0) + { + len += read; + } + else + { + break; + } + } + + return (int)len; + /* We are sure that the difference lies within the int range */ +} + +int AXIS2_CALL +apache2_stream_write( + axutil_stream_t * stream, + const axutil_env_t * env, + const void *buf, + size_t count) +{ + apache2_stream_impl_t *stream_impl = NULL; + axis2_char_t *buffer = NULL; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, buf, AXIS2_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + buffer = (axis2_char_t *)buf; + if(count <= 0) + { + return (int)count; + /* We are sure that the difference lies within the int range */ + } + /* assume that buffer is not null terminated */ + return ap_rwrite(buffer, (int)count, stream_impl->request); + /* We are sure that the difference lies within the int range */ +} + +static int AXIS2_CALL +apache2_stream_skip( + axutil_stream_t * stream, + const axutil_env_t * env, + int count) +{ + apache2_stream_impl_t *stream_impl = NULL; + axis2_char_t *tmp_buffer = NULL; + apr_size_t len = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + stream_impl = AXIS2_INTF_TO_IMPL(stream); + + tmp_buffer = AXIS2_MALLOC(env->allocator, count * sizeof(axis2_char_t)); + if(tmp_buffer == NULL) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return -1; + } + len = apache2_ap_get_client_block(stream_impl->request, tmp_buffer, count); + AXIS2_FREE(env->allocator, tmp_buffer); + return (int)len; + +} + +int AXIS2_CALL +apache2_stream_get_char( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + int ret = -1; + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + return ret; +} + +axutil_stream_type_t AXIS2_CALL +apache2_stream_get_type( + axutil_stream_t * stream, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + return AXIS2_INTF_TO_IMPL(stream)->stream_type; +} + +/* + * This is a re-write of get_client_block found in http_filters.c in httpd + * which does not work when dealing with compressed payloads (or any other input + * filters that could potentially return 0 bytes of filtered data and not be at + * the end of the stream). + * get_client_block is called in a loop to get the request message body. + * This is quite simple if the client includes a content-length + * (the normal case), but gets messy if the body is chunked. Note that + * r->remaining is used to maintain state across calls and that + * r->read_length is the total number of bytes given to the caller + * across all invocations. It is messy because we have to be careful not + * to read past the data provided by the client, since these reads block. + * Returns 0 on End-of-body, -1 on error or premature chunk end. + * + */ +static apr_size_t +apache2_ap_get_client_block( + request_rec *r, + char *buffer, + apr_size_t bufsiz) +{ + apr_status_t rv; + apr_bucket_brigade *bb; + int loop = 1; + apr_size_t origBufSize = bufsiz; + + if (r->remaining < 0 || (!r->read_chunked && r->remaining == 0)) { + return 0; + } + + bb = apr_brigade_create(r->pool, r->connection->bucket_alloc); + if (bb == NULL) { + r->connection->keepalive = AP_CONN_CLOSE; + return -1; + } + + /* we need to loop until the input filters (if any) give us data */ + while (loop) { + rv = ap_get_brigade(r->input_filters, bb, AP_MODE_READBYTES, + APR_BLOCK_READ, bufsiz); + + /* We lose the failure code here. This is why ap_get_client_block should + * not be used. + */ + if (rv != APR_SUCCESS) { + /* if we actually fail here, we want to just return and + * stop trying to read data from the client. + */ + r->connection->keepalive = AP_CONN_CLOSE; + apr_brigade_destroy(bb); + return -1; + } + + /* If this fails, it means that a filter is written incorrectly and that + * it needs to learn how to properly handle APR_BLOCK_READ requests by + * returning data when requested. + */ + AP_DEBUG_ASSERT(!APR_BRIGADE_EMPTY(bb)); + + /* Check to see if EOS in the brigade. + * + * If so, we have to leave a nugget for the *next* ap_get_client_block + * call to return 0. + */ + if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(bb))) { + if (r->read_chunked) { + r->remaining = -1; + } else { + r->remaining = 0; + } + } + + rv = apr_brigade_flatten(bb, buffer, &bufsiz); + if (rv != APR_SUCCESS) { + apr_brigade_destroy(bb); + return -1; + } + + /* XXX yank me? */ + r->read_length += bufsiz; + + /* it is possible that the entire bucket brigade is exhausted, but no data + * has been produced by the input filter (mod_deflate, for example).... + * in this scenario, we really need to keep looping + */ + if (bufsiz != 0 || r->remaining <= 0) { + loop = 0; + apr_brigade_destroy(bb); + } else { + if (bufsiz == 0) { + bufsiz = origBufSize; + } + } + + } + + return (long)bufsiz; +} diff --git a/src/core/transport/http/server/apache2/apache2_stream.h b/src/core/transport/http/server/apache2/apache2_stream.h new file mode 100644 index 0000000..abbea45 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_stream.h @@ -0,0 +1,46 @@ + +/* + * 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 APACHE2_STREAM_H +#define APACHE2_STREAM_H + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** \brief Constructor for creating apche2 stream + * @return axutil_stream (apache2) + */ + AXIS2_EXTERN axutil_stream_t *AXIS2_CALL + axutil_stream_create_apache2( + const axutil_env_t * env, + request_rec * req); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* APACHE2_STREAM_H */ diff --git a/src/core/transport/http/server/apache2/apache2_worker.c b/src/core/transport/http/server/apache2/apache2_worker.c new file mode 100644 index 0000000..12b05b2 --- /dev/null +++ b/src/core/transport/http/server/apache2/apache2_worker.c @@ -0,0 +1,1687 @@ +/* + * 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. + */ + +#include "axis2_apache2_worker.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "axis2_apache2_out_transport_info.h" +#include +#include +#include +#include +#include +#include +#include +#include + +#define READ_SIZE 2048 + +static axis2_status_t +apache2_worker_send_mtom_message( + request_rec *request, + const axutil_env_t * env, + axutil_array_list_t *mime_parts, + axis2_char_t *mtom_sending_callback_name); + +static axis2_status_t +apache2_worker_send_attachment_using_file( + const axutil_env_t * env, + request_rec *request, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size); + +static axis2_status_t +apache2_worker_send_attachment_using_callback( + const axutil_env_t * env, + request_rec *request, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param); + +static axutil_hash_t* +axis2_apache_worker_get_headers( + const axutil_env_t *env, + request_rec *request); + + +struct axis2_apache2_worker +{ + axis2_conf_ctx_t *conf_ctx; +}; + +AXIS2_EXTERN axis2_apache2_worker_t *AXIS2_CALL +axis2_apache2_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path) +{ + axis2_apache2_worker_t *apache2_worker = NULL; + axutil_hash_t* svc_map = NULL; + axis2_conf_t* conf = NULL; + axutil_hash_index_t *hi = NULL; + void* svc = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created"); + apache2_worker = (axis2_apache2_worker_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_apache2_worker_t)); + + if(!apache2_worker) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + apache2_worker->conf_ctx = axis2_build_conf_ctx(env, repo_path); + + if(!apache2_worker->conf_ctx) + { + axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env); + return NULL; + } + + /* + * we have to load all the services. This is because, before the fork (in linux) + * we should have a full code segment. Otherwise, we can't share function pointers of services + * between processed. In fork, the code segment will be duplicated across processes + */ + conf = axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env); + if(!conf) + { + axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env); + return NULL; + } + + svc_map = axis2_conf_get_all_svcs(conf, env); + if(!svc_map) + { + axis2_apache2_worker_free((axis2_apache2_worker_t *)apache2_worker, env); + return NULL; + } + + for(hi = axutil_hash_first(svc_map, env); hi; hi = axutil_hash_next(env, hi)) + { + void *impl_class = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axutil_hash_t *ops_hash = NULL; + + axutil_hash_this(hi, NULL, NULL, &svc); + if(!svc) + continue; + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + continue; + ops_hash = axis2_svc_get_all_ops(svc, env); + if(ops_hash) + { + axutil_hash_index_t *op_hi = NULL; + void *op = NULL; + op_hi = axutil_hash_first(ops_hash, env); + if(op_hi) + { + axutil_hash_this(op_hi, NULL, NULL, &op); + if(op) + { + msg_recv = axis2_op_get_msg_recv(op, env); + if(msg_recv) + { + axis2_msg_recv_set_conf_ctx(msg_recv, env, apache2_worker->conf_ctx); + axis2_msg_recv_load_and_init_svc(msg_recv, env, svc); + } + } + } + + } + } + + AXIS2_LOG_INFO(env->log, "[Axis2] Axis2 worker created"); + + return apache2_worker; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_apache2_worker_free( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(apache2_worker->conf_ctx) + { + axis2_conf_ctx_free(apache2_worker->conf_ctx, env); + apache2_worker->conf_ctx = NULL; + } + + AXIS2_FREE(env->allocator, apache2_worker); + + return; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_apache2_worker_process_request( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env, + request_rec * request) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_msg_ctx_t *msg_ctx = NULL; + axutil_stream_t *request_body = NULL; + axutil_stream_t *out_stream = NULL; + axis2_transport_out_desc_t *out_desc = NULL; + axis2_transport_in_desc_t *in_desc = NULL; + axis2_char_t *http_version = NULL; + axutil_string_t *soap_action = NULL; + axis2_char_t *soap_action_header_txt = NULL; + axis2_bool_t processed = AXIS2_FALSE; + int content_length = -1; + axis2_char_t *url_external_form = NULL; + axis2_char_t *body_string = NULL; + unsigned int body_string_len = 0; + int send_status = DECLINED; + axis2_char_t *content_type = NULL; + axis2_http_out_transport_info_t *apache2_out_transport_info = NULL; + axis2_char_t *ctx_uuid = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_char_t *peer_ip = NULL; + axutil_property_t *peer_property = NULL; + axutil_url_t *request_url = NULL; + axis2_char_t *accept_header_value = NULL; + axis2_char_t *accept_charset_header_value = NULL; + axis2_char_t *accept_language_header_value = NULL; + axis2_char_t *content_language_header_value = NULL; + axis2_bool_t do_mtom = AXIS2_FALSE; + axutil_array_list_t *mime_parts = NULL; + axutil_param_t *callback_name_param = NULL; + axis2_char_t *mtom_sending_callback_name = NULL; + axis2_char_t *cookie = NULL; + axis2_char_t *header_value = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *headers = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, request, AXIS2_CRITICAL_FAILURE); + + conf_ctx = apache2_worker->conf_ctx; + + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); + return AXIS2_CRITICAL_FAILURE; + } + content_length = (int)request->remaining; + /* We are sure that the difference lies within the int range */ + http_version = request->protocol; + + request_url = axutil_url_create(env, "http", request->hostname, request->parsed_uri.port, + request->unparsed_uri); + if(request_url) + { + url_external_form = axutil_url_to_external_form(request_url, env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, url_external_form); + axutil_url_free(request_url, env); + request_url = NULL; + } + else + { + send_status = OK; + request->status = HTTP_BAD_REQUEST; + return send_status; + } + + content_type = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(!content_type) + { + content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN; + } + request->content_type = content_type; + + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env), + env, AXIS2_TRANSPORT_ENUM_HTTP); + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(apache2_worker->conf_ctx, env), + env, AXIS2_TRANSPORT_ENUM_HTTP); + { + axis2_transport_receiver_t *receiver = NULL; + receiver = axis2_transport_in_desc_get_recv(in_desc, env); + if(receiver) + axis2_transport_receiver_set_server_ip(receiver, env, request->connection->local_ip); + } + + msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + cookie = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_COOKIE); + if(cookie) + { + char *session_str = NULL; + axis2_char_t *session_id = NULL; + + session_id = axis2_http_transport_utils_get_session_id_from_cookie(env, cookie); + if(session_id) + session_str = env->get_session_fn((void *) request, session_id); + if(session_str) + axis2_http_transport_utils_set_session(env, msg_ctx, session_str); + } + + if(request->read_chunked == AXIS2_TRUE && 0 == content_length) + { + content_length = -1; + request->chunked = 1; + } + if(!http_version) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE); + return AXIS2_CRITICAL_FAILURE; + } + out_stream = axutil_stream_create_basic(env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Client HTTP version %s", http_version); + + peer_ip = request->connection->remote_ip; + + if(peer_ip) + { + peer_property = axutil_property_create(env); + axutil_property_set_value(peer_property, env, axutil_strdup(env, peer_ip)); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_SVR_PEER_IP_ADDR, peer_property); + } + + axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream); + + ctx_uuid = axutil_uuid_gen(env); + if(ctx_uuid) + { + axutil_string_t *uuid_str = axutil_string_create_assume_ownership(env, &ctx_uuid); + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, uuid_str); + axutil_string_free(uuid_str, env); + } + + apache2_out_transport_info = axis2_apache2_out_transport_info_create(env, request); + axis2_msg_ctx_set_out_transport_info(msg_ctx, env, &(apache2_out_transport_info->out_transport)); + + accept_header_value = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_ACCEPT); + if(accept_header_value) + { + axutil_array_list_t *accept_header_field_list = NULL; + axutil_array_list_t *accept_record_list = NULL; + accept_header_field_list = axutil_tokenize(env, accept_header_value, ','); + if(accept_header_field_list && axutil_array_list_size(accept_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_header_field_list, env, 0); + } + while(token); + } + if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0) + { + axis2_msg_ctx_set_http_accept_record_list(msg_ctx, env, accept_record_list); + } + } + + accept_charset_header_value = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_ACCEPT_CHARSET); + if(accept_charset_header_value) + { + axutil_array_list_t *accept_charset_header_field_list = NULL; + axutil_array_list_t *accept_charset_record_list = NULL; + accept_charset_header_field_list = axutil_tokenize(env, accept_charset_header_value, ','); + if(accept_charset_header_field_list && axutil_array_list_size( + accept_charset_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_charset_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_charset_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_charset_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_charset_header_field_list, + env, 0); + } + while(token); + } + if(accept_charset_record_list && axutil_array_list_size(accept_charset_record_list, env) + > 0) + { + axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env, + accept_charset_record_list); + } + } + + accept_language_header_value = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_ACCEPT_LANGUAGE); + if(accept_language_header_value) + { + axutil_array_list_t *accept_language_header_field_list = NULL; + axutil_array_list_t *accept_language_record_list = NULL; + accept_language_header_field_list = axutil_tokenize(env, accept_language_header_value, ','); + if(accept_language_header_field_list && axutil_array_list_size( + accept_language_header_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_language_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_language_header_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_language_record_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_language_header_field_list, + env, 0); + } + while(token); + } + if(accept_language_record_list && axutil_array_list_size(accept_language_record_list, env) + > 0) + { + axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env, + accept_language_record_list); + } + } + + soap_action_header_txt = (axis2_char_t *)apr_table_get(request->headers_in, + AXIS2_HTTP_HEADER_SOAP_ACTION); + + if(soap_action_header_txt) + { + soap_action = axutil_string_create(env, soap_action_header_txt); + } + + headers = axis2_apache_worker_get_headers(env, request); + axis2_msg_ctx_set_transport_headers(msg_ctx, env, headers); + + request_body = axutil_stream_create_apache2(env, request); + if(!request_body) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in" + " creating input stream."); + return AXIS2_CRITICAL_FAILURE; + } + if(M_GET == request->method_number || M_DELETE == request->method_number) + { + if(M_DELETE == request->method_number) + { + processed = axis2_http_transport_utils_process_http_delete_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx, + axis2_http_transport_utils_get_request_params(env, + (axis2_char_t *)url_external_form)); + } + else if(request->header_only) + { + processed = axis2_http_transport_utils_process_http_head_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx, + axis2_http_transport_utils_get_request_params(env, + (axis2_char_t *)url_external_form)); + } + else + { + processed = axis2_http_transport_utils_process_http_get_request(env, msg_ctx, + request_body, out_stream, content_type, soap_action, url_external_form, conf_ctx, + axis2_http_transport_utils_get_request_params(env, + (axis2_char_t *)url_external_form)); + } + if(AXIS2_FALSE == processed) + { + axis2_char_t *wsdl = NULL; + axis2_bool_t is_services_path = AXIS2_FALSE; + if(M_DELETE != request->method_number) + { + axis2_char_t *temp = NULL; + temp = strstr(url_external_form, AXIS2_REQUEST_URL_PREFIX); + if(temp) + { + temp += strlen(AXIS2_REQUEST_URL_PREFIX); + if(*temp == '/') + { + temp++; + } + if(!*temp || *temp == '?' || *temp == '#') + { + is_services_path = AXIS2_TRUE; + } + } + } + wsdl = strstr(url_external_form, AXIS2_REQUEST_WSDL); + if(is_services_path) + { + body_string = axis2_http_transport_utils_get_services_html(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else if(M_DELETE != request->method_number && wsdl) + { + body_string = axis2_http_transport_utils_get_services_static_wsdl(env, conf_ctx, + (axis2_char_t *)url_external_form); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + + } + else if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + if(method_list && size) + { + axis2_char_t *method_list_str = NULL; + axis2_char_t *temp; + int i = 0; + method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29); + temp = method_list_str; + request->allowed_methods->method_mask = 0; + for(i = 0; i < size; i++) + { + if(i) + { + sprintf(temp, ", "); + temp += 2; + } + sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, + i)); + temp += strlen(temp); + /* Conditions below is to assist down-stream modules */ + if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT; + } + else if(!strcasecmp(AXIS2_HTTP_POST, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_POST; + } + else if(!strcasecmp(AXIS2_HTTP_GET, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_HEAD, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + /* Apache Can't differentiate between HEAD and GET */ + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_DELETE, + (axis2_char_t *)axutil_array_list_get(method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_DELETE; + } + } + *temp = '\0'; + apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_ALLOW, + method_list_str); + AXIS2_FREE(env->allocator, method_list_str); + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + request->status = HTTP_METHOD_NOT_ALLOWED; + } + else + { + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + request->status = HTTP_NOT_FOUND; + } + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_BAD_REQUEST; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_REQUEST_TIME_OUT; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_CONFLICT; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_gone(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_GONE; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_PRECONDITION_FAILED; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + } + else if(axis2_msg_ctx_get_status_code(msg_ctx, env) + == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) + { + body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_SERVICE_UNAVAILABLE; + } + else + { + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_INTERNAL_SERVER_ERROR; + } + + if(body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + } + } + else if(M_POST == request->method_number || M_PUT == request->method_number) + { + /*axis2_status_t status = AXIS2_FAILURE;*/ + if(M_POST == request->method_number) + { + status = axis2_http_transport_utils_process_http_post_request(env, msg_ctx, + request_body, out_stream, content_type, content_length, soap_action, + (axis2_char_t *)url_external_form); + } + else + { + status = axis2_http_transport_utils_process_http_put_request(env, msg_ctx, + request_body, out_stream, content_type, content_length, soap_action, + (axis2_char_t *)url_external_form); + } + if(AXIS2_FAILURE == status && (M_PUT == request->method_number + || axis2_msg_ctx_get_doing_rest(msg_ctx, env))) + { + if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + if(method_list && size) + { + axis2_char_t *method_list_str = NULL; + axis2_char_t *temp; + int i = 0; + method_list_str = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 29); + temp = method_list_str; + request->allowed_methods->method_mask = 0; + for(i = 0; i < size; i++) + { + if(i) + { + sprintf(temp, ", "); + temp += 2; + } + sprintf(temp, "%s", (axis2_char_t *)axutil_array_list_get(method_list, env, + i)); + temp += strlen(temp); + /* Conditions below is to assist down-stream modules */ + if(!strcasecmp(AXIS2_HTTP_PUT, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_PUT; + } + else if(!strcasecmp(AXIS2_HTTP_POST, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_POST; + } + else if(!strcasecmp(AXIS2_HTTP_GET, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_HEAD, (axis2_char_t *)axutil_array_list_get( + method_list, env, i))) + { + /* Apache Can't differentiate between HEAD and GET */ + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_GET; + } + else if(!strcasecmp(AXIS2_HTTP_DELETE, + (axis2_char_t *)axutil_array_list_get(method_list, env, i))) + { + request->allowed_methods->method_mask |= AP_METHOD_BIT << M_DELETE; + } + } + *temp = '\0'; + apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_ALLOW, + method_list_str); + AXIS2_FREE(env->allocator, method_list_str); + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + request->status = HTTP_METHOD_NOT_ALLOWED; + } + else + { + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + request->status = HTTP_NOT_FOUND; + } + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else + { + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + request->status = HTTP_INTERNAL_SERVER_ERROR; + } + + if(body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + } + else if(status == AXIS2_FAILURE) + { + axis2_msg_ctx_t *fault_ctx = NULL; + axis2_char_t *fault_code = NULL; + axis2_engine_t *engine = axis2_engine_create(env, conf_ctx); + if(!engine) + { + /* Critical error, cannot proceed, Apache will send default + document for 500 + */ + return AXIS2_CRITICAL_FAILURE; + } + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP11_FAULT_CODE_SENDER; + } + else + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER; + } + fault_ctx = axis2_engine_create_fault_msg_ctx(engine, env, msg_ctx, + fault_code, + axutil_error_get_message + (env->error)); + axis2_engine_send_fault(engine, env, fault_ctx); + if (out_stream) + { + body_string = axutil_stream_get_buffer(out_stream, env); + body_string_len = axutil_stream_get_len(out_stream, env); + } + + /* In case of a SOAP Fault, we have to set the status to 500, + but still return OK because the module has handled the error + */ + send_status = OK; + request->status = HTTP_INTERNAL_SERVER_ERROR; + } + } + else + { + body_string = + axis2_http_transport_utils_get_not_implemented(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_IMPLEMENTED; + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + + if (op_ctx) + { + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + if (out_msg_ctx) + { + content_language_header_value = axis2_msg_ctx_get_content_language(out_msg_ctx, env); + } + } + + if (send_status == DECLINED) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (M_POST != request->method_number || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + if ((accept_header_value || accept_charset_header_value || + accept_language_header_value) && do_rest) + { + axis2_char_t *content_type_header_value = NULL; + axis2_char_t *temp = NULL; + axis2_char_t *language_header_value = NULL; + + content_type_header_value = (axis2_char_t *) request->content_type; + language_header_value = content_language_header_value; + if (content_type_header_value) + { + temp = axutil_strdup(env, content_type_header_value); + } + if (temp) + { + axis2_char_t *content_type = NULL; + axis2_char_t *char_set = NULL; + axis2_char_t *temp2 = NULL; + + temp2 = strchr(temp, ';'); + if (temp2) + { + *temp2 = '\0'; + temp2++; + char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING); + } + if (char_set) + { + char_set = axutil_strltrim(env, char_set, " \t="); + } + if (char_set) + { + temp2 = strchr(char_set, ';'); + } + if (temp2) + { + *temp2 = '\0'; + } + content_type = axutil_strtrim(env, temp, NULL); + + if (temp) + { + AXIS2_FREE(env->allocator, temp); + temp = NULL; + } + if (content_type && accept_header_value && + !axutil_strcasestr(accept_header_value, content_type)) + { + temp2 = strchr(content_type, '/'); + if (temp2) + { + *temp2 = '\0'; + temp = AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * ((int)strlen(content_type) + 3)); + if (!temp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FALSE; + } + sprintf(temp, "%s/*", content_type); + if (!axutil_strcasestr(accept_header_value, temp) && + !strstr(accept_header_value, AXIS2_HTTP_HEADER_ACCEPT_ALL)) + { + body_string = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_ACCEPTABLE; + } + AXIS2_FREE(env->allocator, temp); + } + } + if (content_type) + { + AXIS2_FREE(env->allocator, content_type); + } + if (char_set && accept_charset_header_value && + !axutil_strcasestr(accept_charset_header_value, char_set)) + { + body_string = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_ACCEPTABLE; + } + if (char_set) + { + AXIS2_FREE(env->allocator, char_set); + } + } + if (language_header_value) + { + if (accept_language_header_value && + !axutil_strcasestr(accept_language_header_value, language_header_value)) + { + body_string = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (body_string) + { + body_string_len = axutil_strlen(body_string); + } + send_status = OK; + request->status = HTTP_NOT_ACCEPTABLE; + } + } + } + } + + header_value = axis2_http_transport_utils_get_session(env, msg_ctx); + if(header_value) + { + axis2_http_out_transport_info_t *out_info = NULL; + out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info(msg_ctx, env); + AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_info, env, header_value); + } + if (send_status == DECLINED) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (M_POST != request->method_number || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + if (op_ctx && axis2_op_ctx_get_response_written(op_ctx, env)) + { + if (do_rest) + { + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + if (in_msg_ctx) + { + /* TODO: Add necessary handling */ + } + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + } + while (size) + { + axis2_http_header_t *output_header = NULL; + size--; + output_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, env, size); + apr_table_set(request->err_headers_out, + axis2_http_header_get_name(output_header, env), + axis2_http_header_get_value(output_header, env)); + } + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + request->status = HTTP_CONTINUE; + break; + case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL: + request->status = HTTP_ACCEPTED; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + request->status = HTTP_MULTIPLE_CHOICES; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + request->status = HTTP_MOVED_PERMANENTLY; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + request->status = HTTP_SEE_OTHER; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + request->status = HTTP_TEMPORARY_REDIRECT; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + request->status = HTTP_BAD_REQUEST; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + request->status = HTTP_REQUEST_TIME_OUT; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + request->status = HTTP_CONFLICT; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + request->status = HTTP_GONE; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + request->status = HTTP_PRECONDITION_FAILED; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + request->status = HTTP_SERVICE_UNAVAILABLE; + break; + default: + request->status = HTTP_OK; + break; + } + send_status = DONE; + } + } + } + if (send_status == DECLINED) + { + send_status = OK; + if (out_stream) + { + body_string = axutil_stream_get_buffer(out_stream, env); + body_string_len = axutil_stream_get_len(out_stream, env); + } + } + } + else if (op_ctx) + { + if (do_rest) + { + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + if (in_msg_ctx) + { + /* TODO: Add necessary handling */ + } + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + } + while (size) + { + axis2_http_header_t *output_header = NULL; + size--; + output_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, env, size); + apr_table_set(request->err_headers_out, + axis2_http_header_get_name(output_header, env), + axis2_http_header_get_value(output_header, env)); + } + if (axis2_msg_ctx_get_no_content(out_msg_ctx, env)) + { + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL: + request->status = HTTP_RESET_CONTENT; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + default: + request->status = HTTP_NO_CONTENT; + break; + } + } + else + { + request->status = HTTP_NO_CONTENT; + } + send_status = DONE; + } + else if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + request->status = HTTP_CONTINUE; + break; + case AXIS2_HTTP_RESPONSE_OK_CODE_VAL: + request->status = HTTP_OK; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + request->status = HTTP_MULTIPLE_CHOICES; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + request->status = HTTP_MOVED_PERMANENTLY; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + request->status = HTTP_SEE_OTHER; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + request->status = HTTP_TEMPORARY_REDIRECT; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + request->status = HTTP_BAD_REQUEST; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + request->status = HTTP_REQUEST_TIME_OUT; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + request->status = HTTP_CONFLICT; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + request->status = HTTP_GONE; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + request->status = HTTP_PRECONDITION_FAILED; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + request->status = HTTP_SERVICE_UNAVAILABLE; + break; + default: + request->status = HTTP_ACCEPTED; + break; + } + send_status = DONE; + } + } + } + if (send_status == DECLINED) + { + if (msg_ctx) + { + int size = 0; + int status_code; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + } + while (size) + { + axis2_http_header_t *output_header = NULL; + size--; + output_header = (axis2_http_header_t *) + axutil_array_list_get(output_header_list, env, size); + apr_table_set(request->err_headers_out, + axis2_http_header_get_name(output_header, env), + axis2_http_header_get_value(output_header, env)); + } + + status_code = axis2_msg_ctx_get_status_code(msg_ctx, env); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + request->status = HTTP_CONTINUE; + break; + case AXIS2_HTTP_RESPONSE_OK_CODE_VAL: + request->status = HTTP_OK; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + request->status = HTTP_MULTIPLE_CHOICES; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + request->status = HTTP_MOVED_PERMANENTLY; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + request->status = HTTP_SEE_OTHER; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + request->status = HTTP_NOT_MODIFIED; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + request->status = HTTP_TEMPORARY_REDIRECT; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + request->status = HTTP_BAD_REQUEST; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + request->status = HTTP_REQUEST_TIME_OUT; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + request->status = HTTP_CONFLICT; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + request->status = HTTP_GONE; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + request->status = HTTP_PRECONDITION_FAILED; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + request->status = HTTP_REQUEST_ENTITY_TOO_LARGE; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + request->status = HTTP_SERVICE_UNAVAILABLE; + break; + case AXIS2_HTTP_RESPONSE_FORBIDDEN_CODE_VAL: + request->status = HTTP_FORBIDDEN; + break; + case AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL: + request->status = HTTP_UNAUTHORIZED; + break; + default: + request->status = HTTP_ACCEPTED; + break; + } + + out_stream = axis2_msg_ctx_get_transport_out_stream(msg_ctx, env); + if (out_stream) + { + body_string = axutil_stream_get_buffer(out_stream, env); + body_string_len = axutil_stream_get_len(out_stream, env); + } + send_status = DONE; + } + else + { + request->status = HTTP_ACCEPTED; + send_status = DONE; + } + } + } + else + { + send_status = DONE; + request->status = HTTP_ACCEPTED; + } + } + + if (content_language_header_value) + { + apr_table_set(request->err_headers_out, AXIS2_HTTP_HEADER_CONTENT_LANGUAGE, + content_language_header_value); + } + + if (op_ctx) + { + axis2_msg_ctx_t *out_msg_ctx = NULL, + *in_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + axis2_char_t *msg_id = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + in_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN]; + + /* In mtom case we send the attachment differently */ + + /* status = AXIS2_FAILURE means fault scenario. We are not + * doing MTOM for fault cases. */ + + if(status != AXIS2_FAILURE) + { + do_mtom = axis2_msg_ctx_get_doing_mtom(out_msg_ctx, env); + if(do_mtom) + { + mime_parts = axis2_msg_ctx_get_mime_parts(out_msg_ctx, env); + if(!mime_parts) + { + return AXIS2_FAILURE; + } + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env , + AXIS2_MTOM_SENDING_CALLBACK); + if(callback_name_param) + { + mtom_sending_callback_name = + (axis2_char_t *) axutil_param_get_value (callback_name_param, env); + } + } + } + + if (out_msg_ctx) + { + axis2_msg_ctx_free(out_msg_ctx, env); + out_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT] = NULL; + } + + if (in_msg_ctx) + { + msg_id = + axutil_strdup(env, axis2_msg_ctx_get_msg_id(in_msg_ctx, env)); + conf_ctx = axis2_msg_ctx_get_conf_ctx(in_msg_ctx, env); + axis2_msg_ctx_reset_out_transport_info(in_msg_ctx, env); + axis2_msg_ctx_free(in_msg_ctx, env); + in_msg_ctx = NULL; + msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = NULL; + } + + if (!axis2_op_ctx_is_in_use(op_ctx, env)) + { + axis2_op_ctx_destroy_mutex(op_ctx, env); + if (conf_ctx && msg_id) + { + axis2_conf_ctx_register_op_ctx(conf_ctx, env, msg_id, NULL); + AXIS2_FREE(env->allocator, msg_id); + } + axis2_op_ctx_free(op_ctx, env); + } + + } /* Done freeing message contexts */ + + /* We send the message in parts when doing MTOM */ + + if(do_mtom) + { + axis2_status_t mtom_status = AXIS2_FAILURE; + + if(!mtom_sending_callback_name) + { + /* If the callback name is not there, then we will check whether there + * is any mime_parts which has type callback. If we found then no point + * of continuing we should return a failure */ + + if(!mtom_sending_callback_name) + { + if(axis2_http_transport_utils_is_callback_required( + env, mime_parts)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sender callback not specified"); + return AXIS2_FAILURE; + } + } + } + + mtom_status = apache2_worker_send_mtom_message(request, env, mime_parts, + mtom_sending_callback_name); + if(mtom_status == AXIS2_SUCCESS) + { + send_status = DONE; + } + else + { + send_status = DECLINED; + } + + axis2_http_transport_utils_destroy_mime_parts(mime_parts, env); + mime_parts = NULL; + } + + else if (body_string) + { + ap_rwrite(body_string, body_string_len, request); + body_string = NULL; + } + + if (request_body) + { + axutil_stream_free(request_body, env); + request_body = NULL; + } + + axutil_string_free(soap_action, env); + + msg_ctx = NULL; + return send_status; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_apache2_worker_get_bytes( + const axutil_env_t * env, + axutil_stream_t * stream) +{ + + axutil_stream_t *tmp_stream = NULL; + int return_size = -1; + axis2_char_t *buffer = NULL; + axis2_bool_t loop_status = AXIS2_TRUE; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, stream, NULL); + + tmp_stream = axutil_stream_create_basic(env); + while(loop_status) + { + int read = 0; + int write = 0; + + char buf[READ_SIZE]; + read = axutil_stream_read(stream, env, buf, READ_SIZE); + if(read < 0) + { + break; + } + write = axutil_stream_write(tmp_stream, env, buf, read); + if(read < (READ_SIZE - 1)) + { + break; + } + } + return_size = axutil_stream_get_len(tmp_stream, env); + + if(return_size > 0) + { + buffer = (char *)AXIS2_MALLOC(env->allocator, sizeof(char) * (return_size + 2)); + return_size = axutil_stream_read(tmp_stream, env, buffer, return_size + 1); + buffer[return_size + 1] = '\0'; + } + axutil_stream_free(tmp_stream, env); + return buffer; +} + +static axis2_status_t +apache2_worker_send_mtom_message( + request_rec *request, + const axutil_env_t * env, + axutil_array_list_t *mime_parts, + axis2_char_t *mtom_sending_callback_name) +{ + int i = 0; + axiom_mime_part_t *mime_part = NULL; + axis2_status_t status = AXIS2_SUCCESS; + /*int written = 0;*/ + int len = 0; + + if(mime_parts) + { + for(i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + if((mime_part->type) == AXIOM_MIME_PART_BUFFER) + { + len = 0; + len = ap_rwrite(mime_part->part, (int)mime_part->part_size, request); + ap_rflush(request); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + } + else if((mime_part->type) == AXIOM_MIME_PART_FILE) + { + FILE *f = NULL; + axis2_byte_t *output_buffer = NULL; + int output_buffer_size = 0; + + f = fopen(mime_part->file_name, "rb"); + if(!f) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error opening file %s for reading", + mime_part->file_name); + return AXIS2_FAILURE; + } + if(mime_part->part_size > AXIS2_MTOM_OUTPUT_BUFFER_SIZE) + { + output_buffer_size = AXIS2_MTOM_OUTPUT_BUFFER_SIZE; + } + else + { + output_buffer_size = (int)mime_part->part_size; + } + + output_buffer = AXIS2_MALLOC(env->allocator, (output_buffer_size + 1) + * sizeof(axis2_char_t)); + + status = apache2_worker_send_attachment_using_file(env, request, f, output_buffer, + output_buffer_size); + if(status == AXIS2_FAILURE) + { + return status; + } + } + else if((mime_part->type) == AXIOM_MIME_PART_CALLBACK) + { + void *handler = NULL; + axiom_mtom_sending_callback_t *callback = NULL; + + handler = axis2_http_transport_utils_initiate_callback(env, + mtom_sending_callback_name, mime_part->user_param, &callback); + + if(handler) + { + status = apache2_worker_send_attachment_using_callback(env, request, callback, + handler, mime_part->user_param); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "MTOM Sending Callback loading failed"); + status = AXIS2_FAILURE; + } + if(callback) + { + axutil_param_t *param = NULL; + + param = callback->param; + + AXIOM_MTOM_SENDING_CALLBACK_FREE(callback, env); + callback = NULL; + + if(param) + { + axutil_param_free(param, env); + param = NULL; + } + + } + + if(status == AXIS2_FAILURE) + { + return status; + } + } + else + { + return AXIS2_FAILURE; + } + if(status == AXIS2_FAILURE) + { + break; + } + } + return status; + } + else + { + return AXIS2_FAILURE; + } +} + +static axis2_status_t +apache2_worker_send_attachment_using_file( + const axutil_env_t * env, + request_rec *request, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size) +{ + + int count = 0; + int len = 0; + /*int written = 0;*/ + axis2_status_t status = AXIS2_SUCCESS; + + do + { + count = (int)fread(buffer, 1, buffer_size + 1, fp); + if(ferror(fp)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in reading file containg the attachment"); + if(buffer) + { + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + } + fclose(fp); + return AXIS2_FAILURE; + } + + if(count > 0) + { + len = 0; + len = ap_rwrite(buffer, count, request); + ap_rflush(request); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + } + else + { + if(buffer) + { + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + } + fclose(fp); + return AXIS2_FAILURE; + } + memset(buffer, 0, buffer_size); + if(status == AXIS2_FAILURE) + { + if(buffer) + { + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + } + fclose(fp); + return AXIS2_FAILURE; + } + } + while(!feof(fp)); + + fclose(fp); + AXIS2_FREE(env->allocator, buffer); + buffer = NULL; + return AXIS2_SUCCESS; +} + +static axis2_status_t +apache2_worker_send_attachment_using_callback( + const axutil_env_t * env, + request_rec *request, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param) +{ + int count = 0; + int len = 0; + axis2_status_t status = AXIS2_SUCCESS; + axis2_char_t *buffer = NULL; + + /* Keep on loading the data in a loop until + * all the data is sent */ + + while((count = AXIOM_MTOM_SENDING_CALLBACK_LOAD_DATA(callback, env, handler, &buffer)) > 0) + { + len = 0; + len = ap_rwrite(buffer, count, request); + ap_rflush(request); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + } + + if(status == AXIS2_FAILURE) + { + AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler); + return status; + } + + status = AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler); + return status; +} + + +static axutil_hash_t* +axis2_apache_worker_get_headers( + const axutil_env_t *env, + request_rec *request) +{ + int i = 0; + axutil_hash_t *header_map = NULL; + const apr_array_header_t *tarr; + const apr_table_entry_t *telts; + axis2_http_header_t * tmp_http_header = NULL; + + + header_map = axutil_hash_make(env); + tarr = apr_table_elts(request->headers_in); + telts = (const apr_table_entry_t*)tarr->elts; + + for (i = 0; i < tarr->nelts; i++) + { + axis2_char_t* tmp_key = (axis2_char_t*) telts[i].key; + axis2_char_t* tmp_value = (axis2_char_t*) telts[i].val; + tmp_http_header = axis2_http_header_create(env, tmp_key, tmp_value); + axutil_hash_set(header_map, tmp_key, AXIS2_HASH_KEY_STRING, tmp_http_header); + } + + return header_map; + + +} diff --git a/src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.h b/src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.h new file mode 100644 index 0000000..9ab9250 --- /dev/null +++ b/src/core/transport/http/server/apache2/axis2_apache2_out_transport_info.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_APACHE2_OUT_TRANSPORT_INFO_H +#define AXIS2_APACHE2_OUT_TRANSPORT_INFO_H + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_apache2_out_transport_info.h + * @brief axis2 Apache2 Out Transport Info + */ + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN axis2_http_out_transport_info_t *AXIS2_CALL + + axis2_apache2_out_transport_info_create( + const axutil_env_t * env, + request_rec * r); + + /** + * 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 + */ + AXIS2_EXTERN void AXIS2_CALL + + axis2_apache2_out_transport_info_free_void_arg( + void *transport_info, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_APACHE2_OUT_TRANSPORT_INFO_H */ diff --git a/src/core/transport/http/server/apache2/axis2_apache2_worker.h b/src/core/transport/http/server/apache2/axis2_apache2_worker.h new file mode 100644 index 0000000..eea4033 --- /dev/null +++ b/src/core/transport/http/server/apache2/axis2_apache2_worker.h @@ -0,0 +1,78 @@ + +/* + * 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_APACHE2_WORKER_H +#define AXIS2_APACHE2_WORKER_H + +/** + * @brief Apache2 Worker ops struct + * Encapsulator struct for ops of axis2_apache2_worker + */ + +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +/** + * @file axis2_apache2_worker.h + * @brief axis2 Apache2 Worker + */ + +#include +#include +#include +#include +#include "apache2_stream.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_apache2_worker axis2_apache2_worker_t; + + AXIS2_EXTERN int AXIS2_CALL + axis2_apache2_worker_process_request( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env, + request_rec * r); + + AXIS2_EXTERN void AXIS2_CALL + axis2_apache2_worker_free( + axis2_apache2_worker_t * apache2_worker, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_apache2_worker_t *AXIS2_CALL + + axis2_apache2_worker_create( + const axutil_env_t * env, + axis2_char_t * repo_path); + +#define AXIS2_APACHE2_WORKER_PROCESS_REQUEST(apache2_worker, env, request) \ + axis2_apache2_worker_process_request(\ + apache2_worker, env, request) +#define AXIS2_APACHE2_WORKER_FREE(apache2_worker, env) \ + axis2_apache2_worker_free(apache2_worker, env) + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_APACHE2_WORKER_H */ diff --git a/src/core/transport/http/server/apache2/mod_axis2.c b/src/core/transport/http/server/apache2/mod_axis2.c new file mode 100644 index 0000000..a9431eb --- /dev/null +++ b/src/core/transport/http/server/apache2/mod_axis2.c @@ -0,0 +1,844 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include "axis2_apache2_worker.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Configuration structure populated by apache2.conf */ +typedef struct axis2_config_rec +{ + char *axutil_log_file; + char *axis2_repo_path; + axutil_log_levels_t log_level; + int max_log_file_size; + int axis2_global_pool_size; +} axis2_config_rec_t; + +axis2_apache2_worker_t *axis2_worker = NULL; +axutil_env_t *axutil_env = NULL; +apr_rmm_t* rmm = NULL; +apr_global_mutex_t *global_mutex = NULL; + +/******************************Function Headers********************************/ +static void * +axis2_create_svr( + apr_pool_t * p, + server_rec * s); + +static const char * +axis2_set_repo_path( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_log_file( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_max_log_file_size( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_global_pool_size( + cmd_parms * cmd, + void * dummy, + const char *arg); + +static const char * +axis2_set_log_level( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static const char * +axis2_set_svc_url_prefix( + cmd_parms * cmd, + void *dummy, + const char *arg); + +static int +axis2_handler( + request_rec * req); + +/* Shutdown Axis2 */ +apr_status_t +axis2_shutdown( + void *tmp); + +void *AXIS2_CALL axis2_module_malloc( + axutil_allocator_t * allocator, + size_t size); + +void *AXIS2_CALL axis2_module_realloc( + axutil_allocator_t * allocator, + void *ptr, + size_t size); + +void AXIS2_CALL axis2_module_free( + axutil_allocator_t * allocator, + void *ptr); + +static void +axis2_module_init( + apr_pool_t * p, + server_rec * svr_rec); + +static void +axis2_register_hooks( + apr_pool_t * p); + +char * +axis2_get_session( + void *req, + const char *id); + +axis2_status_t +axis2_set_session( + void *req, + const char *id, + const char *session); + +/***************************End of Function Headers****************************/ + +static const command_rec axis2_cmds[] = { AP_INIT_TAKE1("Axis2RepoPath", axis2_set_repo_path, NULL, + RSRC_CONF, "Axis2/C repository path"), AP_INIT_TAKE1("Axis2LogFile", axis2_set_log_file, NULL, + RSRC_CONF, "Axis2/C log file name"), AP_INIT_TAKE1("Axis2LogLevel", axis2_set_log_level, NULL, + RSRC_CONF, "Axis2/C log level"), AP_INIT_TAKE1("Axis2MaxLogFileSize", + axis2_set_max_log_file_size, NULL, RSRC_CONF, "Axis2/C maximum log file size"), + AP_INIT_TAKE1("Axis2GlobalPoolSize", axis2_set_global_pool_size, NULL, RSRC_CONF, + "Axis2/C global pool size"), AP_INIT_TAKE1("Axis2ServiceURLPrefix", + axis2_set_svc_url_prefix, NULL, RSRC_CONF, "Axis2/C service URL prifix"), + { NULL } }; + +/* Dispatch list for API hooks */ +module AP_MODULE_DECLARE_DATA axis2_module = { STANDARD20_MODULE_STUFF, NULL, /* create per-dir config structures */ + NULL, /* merge per-dir config structures */ + axis2_create_svr, /* create per-server config structures */ + NULL, /* merge per-server config structures */ + axis2_cmds, /* table of config file commands */ + axis2_register_hooks /* register hooks */ + }; + +static void * +axis2_create_svr( + apr_pool_t * p, + server_rec * s) +{ + axis2_config_rec_t *conf = apr_palloc(p, sizeof(*conf)); + conf->axutil_log_file = NULL; + conf->axis2_repo_path = NULL; + conf->log_level = AXIS2_LOG_LEVEL_DEBUG; + conf->axis2_global_pool_size = 0; + conf->max_log_file_size = 1; + return conf; +} + +static const char * +axis2_set_repo_path( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->axis2_repo_path = apr_pstrdup(cmd->pool, arg); + return NULL; +} + +static const char * +axis2_set_log_file( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->axutil_log_file = apr_pstrdup(cmd->pool, arg); + return NULL; +} + +static const char * +axis2_set_max_log_file_size( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->max_log_file_size = 1024 * 1024 * atoi(arg); + return NULL; +} + +static const char * +axis2_set_global_pool_size( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + conf->axis2_global_pool_size = 1024 * 1024 * atoi(arg); + return NULL; +} + +static const char * +axis2_set_log_level( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + char *str; + axutil_log_levels_t level = AXIS2_LOG_LEVEL_DEBUG; + axis2_config_rec_t *conf = NULL; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if(err != NULL) + { + return err; + } + + conf = (axis2_config_rec_t *)ap_get_module_config(cmd->server->module_config, &axis2_module); + + str = ap_getword_conf(cmd->pool, &arg); + if(str) + { + if(!strcasecmp(str, "crit")) + { + level = AXIS2_LOG_LEVEL_CRITICAL; + } + else if(!strcasecmp(str, "error")) + { + level = AXIS2_LOG_LEVEL_ERROR; + } + else if(!strcasecmp(str, "warn")) + { + level = AXIS2_LOG_LEVEL_WARNING; + } + else if(!strcasecmp(str, "info")) + { + level = AXIS2_LOG_LEVEL_INFO; + } + else if(!strcasecmp(str, "debug")) + { + level = AXIS2_LOG_LEVEL_DEBUG; + } + else if(!strcasecmp(str, "user")) + { + level = AXIS2_LOG_LEVEL_USER; + } + else if(!strcasecmp(str, "trace")) + { + level = AXIS2_LOG_LEVEL_TRACE; + } + } + conf->log_level = level; + return NULL; +} + +static const char * +axis2_set_svc_url_prefix( + cmd_parms * cmd, + void *dummy, + const char *arg) +{ + AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + + axis2_request_url_prefix = AXIS2_REQUEST_URL_PREFIX; + if(!err) + { + axis2_char_t *prefix = apr_pstrdup(cmd->pool, arg); + if(prefix) + axis2_request_url_prefix = prefix; + } + + return NULL; +} + +/* The sample content handler */ +static int +axis2_handler( + request_rec * req) +{ + int rv = 0; + axutil_env_t *thread_env = NULL; + axutil_allocator_t *allocator = NULL; + axutil_error_t *error = NULL; + + apr_allocator_t *local_allocator = NULL; + apr_pool_t *local_pool = NULL; + + if(strcmp(req->handler, "axis2_module")) + { + return DECLINED; + } + + /* Set up the read policy from the client. */ + if((rv = ap_setup_client_block(req, REQUEST_CHUNKED_DECHUNK)) != OK) + { + return rv; + } + ap_should_client_block(req); + + apr_allocator_create(&local_allocator); + apr_pool_create_ex(&local_pool, NULL, NULL, local_allocator); + + /*thread_env = axutil_init_thread_env(axutil_env);*/ + + /*axutil_env->allocator->current_pool = (void *) req->pool; + rv = AXIS2_APACHE2_WORKER_PROCESS_REQUEST(axis2_worker, axutil_env, req);*/ + + /* create new allocator for this request */ + /*allocator = (axutil_allocator_t *) apr_palloc(req->pool, + sizeof(axutil_allocator_t));*/ + + allocator = (axutil_allocator_t *)apr_palloc(local_pool, sizeof(axutil_allocator_t)); + + if(!allocator) + { + return HTTP_INTERNAL_SERVER_ERROR; + } + allocator->malloc_fn = axis2_module_malloc; + allocator->realloc = axis2_module_realloc; + allocator->free_fn = axis2_module_free; + allocator->global_pool_ref = 0; + allocator->local_pool = (void *)local_pool; + allocator->current_pool = (void *)local_pool; + allocator->global_pool = axutil_env->allocator->global_pool; + + error = axutil_error_create(allocator); + thread_env = axutil_env_create_with_error_log_thread_pool(allocator, error, axutil_env->log, + axutil_env-> thread_pool); + thread_env->allocator = allocator; + thread_env->set_session_fn = axis2_set_session; + thread_env->get_session_fn = axis2_get_session; + + rv = AXIS2_APACHE2_WORKER_PROCESS_REQUEST(axis2_worker, thread_env, req); + if(AXIS2_CRITICAL_FAILURE == rv) + { + return HTTP_INTERNAL_SERVER_ERROR; + } + + apr_pool_destroy(local_pool); + apr_allocator_destroy(local_allocator); + + return rv; +} + +void *AXIS2_CALL +axis2_module_malloc( + axutil_allocator_t * allocator, + size_t size) +{ +#if APR_HAS_SHARED_MEMORY + if (rmm == allocator->current_pool) + { + + void* ptr = NULL; + apr_rmm_off_t offset; + apr_global_mutex_lock(global_mutex); + offset = apr_rmm_malloc(rmm, size); + if (offset) + ptr = apr_rmm_addr_get(rmm, offset); + apr_global_mutex_unlock(global_mutex); + return ptr; + } +#endif + return apr_palloc((apr_pool_t *)(allocator->current_pool), size); +} + +void *AXIS2_CALL +axis2_module_realloc( + axutil_allocator_t * allocator, + void *ptr, + size_t size) +{ +#if APR_HAS_SHARED_MEMORY + if (rmm == allocator->current_pool) + { + void* ptr = NULL; + apr_rmm_off_t offset; + apr_global_mutex_lock(global_mutex); + offset = apr_rmm_realloc(rmm, ptr, size); + if (offset) + ptr = apr_rmm_addr_get(rmm, offset); + apr_global_mutex_unlock(global_mutex); + return ptr; + } +#endif + /* can't be easily implemented */ + return NULL; +} + +void AXIS2_CALL +axis2_module_free( + axutil_allocator_t * allocator, + void *ptr) +{ +#if APR_HAS_SHARED_MEMORY + if (rmm == allocator->current_pool) + { + apr_rmm_off_t offset; + apr_global_mutex_lock(global_mutex); + offset = apr_rmm_offset_get(rmm, ptr); + apr_rmm_free(rmm, offset); + apr_global_mutex_unlock(global_mutex); + } +#endif +} + +static int +axis2_post_config( + apr_pool_t *pconf, + apr_pool_t *plog, + apr_pool_t *ptemp, + server_rec *svr_rec) +{ + apr_status_t status = APR_SUCCESS; + axutil_allocator_t *allocator = NULL; + axutil_error_t *error = NULL; + axutil_log_t *axutil_logger = NULL; + axutil_thread_pool_t *thread_pool = NULL; + void *data = NULL; + const char *userdata_key = "axis2_init"; + axis2_config_rec_t *conf = (axis2_config_rec_t *)ap_get_module_config(svr_rec->module_config, + &axis2_module); + + /* axis2_post_config() will be called twice. Don't bother + * going through all of the initialization on the first call + * because it will just be thrown away.*/ + + ap_add_version_component(pconf, AXIS2_HTTP_HEADER_SERVER_AXIS2C); + + apr_pool_userdata_get(&data, userdata_key, svr_rec->process->pool); + if(!data) + { + apr_pool_userdata_set((const void *)1, userdata_key, apr_pool_cleanup_null, + svr_rec->process->pool); + return OK; + } + +#if APR_HAS_SHARED_MEMORY + if (conf->axis2_global_pool_size > 0) + { + apr_shm_t *shm; + apr_rmm_off_t offset; + + status = apr_shm_create(&shm, conf->axis2_global_pool_size, NULL, pconf); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error creating shared memory pool"); + exit(APEXIT_INIT); + } + + status = apr_rmm_init(&rmm, NULL, apr_shm_baseaddr_get(shm), conf->axis2_global_pool_size, + pconf); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error creating relocatable memory pool"); + exit(APEXIT_INIT); + } + + status = apr_global_mutex_create(&global_mutex, NULL, + APR_LOCK_DEFAULT, pconf); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error creating global mutex"); + exit(APEXIT_INIT); + } + + /*status = unixd_set_global_mutex_perms(global_mutex); + if (status != APR_SUCCESS) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Permision cannot be set to global mutex"); + exit(APEXIT_INIT); + } + */ + + offset = apr_rmm_malloc(rmm, sizeof(axutil_allocator_t)); + if (!offset) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error in creating allocator in global pool"); + exit(APEXIT_INIT); + } + allocator = apr_rmm_addr_get(rmm, offset); + allocator->malloc_fn = axis2_module_malloc; + allocator->realloc = axis2_module_realloc; + allocator->free_fn = axis2_module_free; + allocator->global_pool_ref = 0; + allocator->local_pool = (void *) rmm; + allocator->current_pool = (void *) rmm; + allocator->global_pool = (void *) rmm; + + /* We need to init xml readers before we go into threaded env + */ + axiom_xml_reader_init(); + axutil_error_init(); + + error = axutil_error_create(allocator); + if (!error) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 error structure"); + exit(APEXIT_CHILDFATAL); + } + + axutil_logger = axutil_log_create(allocator, NULL, conf->axutil_log_file); + if (!axutil_logger) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 log structure"); + exit(APEXIT_CHILDFATAL); + } + thread_pool = axutil_thread_pool_init(allocator); + if (!thread_pool) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error initializing mod_axis2 thread pool"); + exit(APEXIT_CHILDFATAL); + } + axutil_env = axutil_env_create_with_error_log_thread_pool(allocator, error, + axutil_logger, + thread_pool); + if (!axutil_env) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 environment"); + exit(APEXIT_CHILDFATAL); + } + if (axutil_logger) + { + axutil_logger->level = conf->log_level; + axutil_logger->size = conf->max_log_file_size; + AXIS2_LOG_INFO(axutil_env->log, "Apache Axis2/C version in use : %s", + axis2_version_string()); + AXIS2_LOG_INFO(axutil_env->log, + "Starting log with log level %d and max log file size %d", + conf->log_level, conf->max_log_file_size); + } + axutil_env->set_session_fn = axis2_set_session; + axutil_env->get_session_fn = axis2_get_session; + + axis2_worker = axis2_apache2_worker_create(axutil_env, + conf->axis2_repo_path); + if (!axis2_worker) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 apache2 worker"); + exit(APEXIT_CHILDFATAL); + } + } + +#endif + + return OK; +} + +static void +axis2_module_init( + apr_pool_t * p, + server_rec * svr_rec) +{ + apr_pool_t *pool; + apr_status_t status; + axutil_allocator_t *allocator = NULL; + axutil_error_t *error = NULL; + axutil_log_t *axutil_logger = NULL; + axutil_thread_pool_t *thread_pool = NULL; + axis2_config_rec_t *conf = (axis2_config_rec_t*)ap_get_module_config(svr_rec->module_config, + &axis2_module); + + if(conf->axis2_global_pool_size > 0) + { + /* + If we are using shared memory, no need to init the child, as the + worker has been created in post config. + */ + return; + } + + /* We need to init xml readers before we go into threaded env + */ + axiom_xml_reader_init(); + + /* create an allocator that uses APR memory pools and lasts the + * lifetime of the httpd server child process + */ + status = apr_pool_create(&pool, p); + if(status) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, status, svr_rec, + "[Axis2] Error allocating mod_axis2 memory pool"); + exit(APEXIT_CHILDFATAL); + } + allocator = (axutil_allocator_t*)apr_palloc(pool, sizeof(axutil_allocator_t)); + if(!allocator) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_ENOMEM, svr_rec, + "[Axis2] Error allocating mod_axis2 allocator"); + exit(APEXIT_CHILDFATAL); + } + allocator->malloc_fn = axis2_module_malloc; + allocator->realloc = axis2_module_realloc; + allocator->free_fn = axis2_module_free; + allocator->global_pool_ref = 0; + allocator->local_pool = (void*)pool; + allocator->current_pool = (void*)pool; + allocator->global_pool = (void*)pool; + + if(!allocator) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error initializing mod_axis2 allocator"); + exit(APEXIT_CHILDFATAL); + } + + axutil_error_init(); + + error = axutil_error_create(allocator); + if(!error) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 error structure"); + exit(APEXIT_CHILDFATAL); + } + axutil_logger = axutil_log_create(allocator, NULL, conf->axutil_log_file); + if(!axutil_logger) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 log structure"); + exit(APEXIT_CHILDFATAL); + } + thread_pool = axutil_thread_pool_init(allocator); + if(!thread_pool) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error initializing mod_axis2 thread pool"); + exit(APEXIT_CHILDFATAL); + } + axutil_env = axutil_env_create_with_error_log_thread_pool(allocator, error, axutil_logger, + thread_pool); + if(!axutil_env) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 environment"); + exit(APEXIT_CHILDFATAL); + } + if(axutil_logger) + { + + axutil_logger->level = conf->log_level; + AXIS2_LOG_INFO(axutil_env->log, "Apache Axis2/C version in use : %s", + axis2_version_string()); + AXIS2_LOG_INFO(axutil_env->log, "Starting log with log level %d", conf->log_level); + } + axutil_env->set_session_fn = axis2_set_session; + axutil_env->get_session_fn = axis2_get_session; + axis2_worker = axis2_apache2_worker_create(axutil_env, conf->axis2_repo_path); + if(!axis2_worker) + { + ap_log_error(APLOG_MARK, APLOG_EMERG, APR_EGENERAL, svr_rec, + "[Axis2] Error creating mod_axis2 apache2 worker"); + exit(APEXIT_CHILDFATAL); + } + + /*ap_dbd_prepare(svr_rec, "SELECT value FROM session WHERE id = %s", "retrieve_session"); + ap_dbd_prepare(svr_rec, "INSERT INTO session VALUES(?,?)", "insert_session");*/ + + + /* If we are initialized we register a clean up as well */ + /* apr_pool_cleanup_register(p, NULL, axis2_shutdown, apr_pool_cleanup_null);*/ +} + +static void +axis2_register_hooks( + apr_pool_t * p) +{ + ap_hook_post_config(axis2_post_config, NULL, NULL, APR_HOOK_MIDDLE); + ap_hook_handler(axis2_handler, NULL, NULL, APR_HOOK_MIDDLE); + ap_hook_child_init(axis2_module_init, NULL, NULL, APR_HOOK_MIDDLE); +} + +apr_status_t +axis2_shutdown( + void *tmp) +{ + if(axis2_worker) + { + axis2_apache2_worker_free(axis2_worker, axutil_env); + } + return APR_SUCCESS; +} + +char * +axis2_get_session( + void *req, + const char *id) +{ + request_rec *request = NULL; + apr_status_t rv; + const char *dbd_session = NULL; + apr_dbd_prepared_t *statement; + apr_dbd_results_t *res = NULL; + apr_dbd_row_t *row = NULL; + ap_dbd_t *dbd = NULL; + ap_dbd_t *(*authn_dbd_acquire_fn)(request_rec*) = NULL; + request = (request_rec *) req; + + authn_dbd_acquire_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire); + dbd = authn_dbd_acquire_fn(request); + if (!dbd) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Failed to acquire database connection to look up " + "id '%s'", id); + return NULL; + } + + statement = apr_hash_get(dbd->prepared, "retrieve_session", APR_HASH_KEY_STRING); + if (!statement) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "A prepared statement could not be found for " + "the key '%s'", "retrieve_session"); + return NULL; + } + if (apr_dbd_pvselect(dbd->driver, request->pool, dbd->handle, &res, statement, + 0, id, NULL) != 0) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Query execution error looking up '%s' " + "in database", id); + return NULL; + } + for (rv = apr_dbd_get_row(dbd->driver, request->pool, res, &row, -1); rv != -1; + rv = apr_dbd_get_row(dbd->driver, request->pool, res, &row, -1)) + { + if (rv != 0) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, request, + "Error retrieving results while looking up '%s' " + "in database", id); + return NULL; + } + if (!dbd_session) + { + dbd_session = apr_dbd_get_entry(dbd->driver, row, 0); + } + /* we can't break out here or row won't get cleaned up */ + } + + if (!dbd_session) + { + return NULL; + } + + return (char *) dbd_session; +} + +axis2_status_t +axis2_set_session( + void *req, + const char *id, + const char *session) +{ + request_rec *request = NULL; + apr_dbd_prepared_t *statement; + int affected_rows = -1; + ap_dbd_t *dbd = NULL; + ap_dbd_t *(*authn_dbd_acquire_fn)(request_rec*) = NULL; + request = (request_rec *) req; + + authn_dbd_acquire_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire); + dbd = authn_dbd_acquire_fn(request); + if (!dbd) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Failed to acquire database connection to insert session for " + "id '%s'", id); + return AXIS2_FAILURE; + } + + statement = apr_hash_get(dbd->prepared, "insert_session", APR_HASH_KEY_STRING); + if (!statement) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "A prepared statement could not be found for " + "the key '%s'", "insert_session"); + return AXIS2_FAILURE; + } + if (apr_dbd_pvquery(dbd->driver, request->pool, dbd->handle, &affected_rows, statement, id, + session, NULL) != 0) + { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, + "Query execution error inserting session for '%s' " + "in database", id); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + + diff --git a/src/core/transport/http/server/simple_axis2_server/Makefile.am b/src/core/transport/http/server/simple_axis2_server/Makefile.am new file mode 100644 index 0000000..604851d --- /dev/null +++ b/src/core/transport/http/server/simple_axis2_server/Makefile.am @@ -0,0 +1,30 @@ +prgbindir=$(bindir) +prgbin_PROGRAMS = axis2_http_server +SUBDIRS = +AM_CFLAGS = -g -pthread +axis2_http_server_SOURCES = http_server_main.c + +axis2_http_server_LDADD = $(LDFLAGS) \ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la \ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la \ + $(top_builddir)/src/core/description/libaxis2_description.la \ + $(top_builddir)/src/core/deployment/libaxis2_deployment.la \ + $(top_builddir)/src/core/context/libaxis2_context.la \ + $(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la \ + $(top_builddir)/src/core/transport/http/sender/libaxis2_http_sender.la \ + $(top_builddir)/src/core/transport/http/receiver/libaxis2_http_receiver.la \ + $(top_builddir)/neethi/src/libneethi.la \ + -lpthread + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description\ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/deployment\ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/server/simple_axis2_server/http_server_main.c b/src/core/transport/http/server/simple_axis2_server/http_server_main.c new file mode 100644 index 0000000..cfbcda4 --- /dev/null +++ b/src/core/transport/http/server/simple_axis2_server/http_server_main.c @@ -0,0 +1,310 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +axutil_env_t *system_env = NULL; +axis2_transport_receiver_t *server = NULL; +AXIS2_IMPORT extern int axis2_http_socket_read_timeout; +AXIS2_IMPORT extern axis2_char_t *axis2_request_url_prefix; + +#define DEFAULT_REPO_PATH "../" + +/***************************** Function headers *******************************/ +axutil_env_t * +init_syetem_env( + axutil_allocator_t * allocator, + const axis2_char_t * log_file); + +void +system_exit( + axutil_env_t * env, + int status); + +void +usage( + axis2_char_t * prog_name); + +void +sig_handler( + int signal); + +/***************************** End of function headers ************************/ +axutil_env_t * +init_syetem_env( + axutil_allocator_t * allocator, + const axis2_char_t * log_file) +{ + axutil_error_t *error = axutil_error_create(allocator); + axutil_log_t *log = axutil_log_create(allocator, NULL, log_file); + /* if (!log) */ + + /* log = axutil_log_create_default (allocator); */ + axutil_thread_pool_t *thread_pool = axutil_thread_pool_init(allocator); + /* We need to init the parser in main thread before spawning child + * threads + */ + axiom_xml_reader_init(); + return axutil_env_create_with_error_log_thread_pool(allocator, error, log, thread_pool); +} + +void +system_exit( + axutil_env_t * env, + int status) +{ + axutil_allocator_t *allocator = NULL; + if(server) + { + axis2_transport_receiver_free(server, system_env); + } + if(env) + { + allocator = env->allocator; + axutil_env_free(env); + } + /*axutil_allocator_free(allocator); */ + axiom_xml_reader_cleanup(); + exit(status); +} + +int +main( + int argc, + char *argv[]) +{ + axutil_allocator_t *allocator = NULL; + axutil_env_t *env = NULL; + extern char *optarg; + extern int optopt; + int c; + unsigned int len; + int log_file_size = AXUTIL_LOG_FILE_SIZE; + unsigned int file_flag = 0; + axutil_log_levels_t log_level = AXIS2_LOG_LEVEL_DEBUG; + const axis2_char_t *log_file = "axis2.log"; + const axis2_char_t *repo_path = DEFAULT_REPO_PATH; + int port = 9090; + axis2_status_t status; + + /* Set the service URL prefix to be used. This could default to services if not + set with AXIS2_REQUEST_URL_PREFIX macro at compile time */ + axis2_request_url_prefix = AXIS2_REQUEST_URL_PREFIX; + + while((c = AXIS2_GETOPT(argc, argv, ":p:r:ht:l:s:f:")) != -1) + { + + switch(c) + { + case 'p': + port = AXIS2_ATOI(optarg); + break; + case 'r': + repo_path = optarg; + break; + case 't': + axis2_http_socket_read_timeout = AXIS2_ATOI(optarg) * 1000; + break; + case 'l': + log_level = AXIS2_ATOI(optarg); + if(log_level < AXIS2_LOG_LEVEL_CRITICAL) + log_level = AXIS2_LOG_LEVEL_CRITICAL; + if(log_level > AXIS2_LOG_LEVEL_TRACE) + log_level = AXIS2_LOG_LEVEL_TRACE; + break; + case 's': + log_file_size = 1024 * 1024 * AXIS2_ATOI(optarg); + break; + case 'f': + log_file = optarg; + break; + case 'h': + usage(argv[0]); + return 0; + case ':': + fprintf(stderr, "\nOption -%c requires an operand\n", optopt); + usage(argv[0]); + return -1; + case '?': + if(isprint(optopt)) + fprintf(stderr, "\nUnknown option `-%c'.\n", optopt); + usage(argv[0]); + return -1; + } + } + + allocator = axutil_allocator_init(NULL); + + if(!allocator) + { + system_exit(NULL, -1); + } + + env = init_syetem_env(allocator, log_file); + env->log->level = log_level; + env->log->size = log_file_size; + + axutil_error_init(); + system_env = env; + + signal(SIGINT, sig_handler); +#ifndef WIN32 + signal(SIGPIPE, sig_handler); +#endif + + AXIS2_LOG_INFO(env->log, "Starting Axis2 HTTP server...."); + AXIS2_LOG_INFO(env->log, "Apache Axis2/C version in use : %s", axis2_version_string()); + AXIS2_LOG_INFO(env->log, "Server port : %d", port); + AXIS2_LOG_INFO(env->log, "Repo location : %s", repo_path); + AXIS2_LOG_INFO(env->log, "Read Timeout : %d ms", axis2_http_socket_read_timeout); + + status = axutil_file_handler_access(repo_path, AXIS2_R_OK); + if(status == AXIS2_SUCCESS) + { + len = (unsigned int)strlen(repo_path); + /* We are sure that the difference lies within the unsigned int range */ + if((len >= 9) && !strcmp((repo_path + (len - 9)), "axis2.xml")) + { + file_flag = 1; + } + } + else + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "provided repo path %s does " + "not exist or no permissions to read, set " + "repo_path to DEFAULT_REPO_PATH", repo_path); + repo_path = DEFAULT_REPO_PATH; + } + + if(!file_flag) + server = axis2_http_server_create(env, repo_path, port); + else + server = axis2_http_server_create_with_file(env, repo_path, port); + + if(!server) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server creation failed: Error code:" " %d :: %s", + env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); + system_exit(env, -1); + + } + printf("Started Simple Axis2 HTTP Server ...\n"); + if(axis2_transport_receiver_start(server, env) == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server start failed: Error code:" " %d :: %s", + env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); + system_exit(env, -1); + } + return 0; +} + +void +usage( + axis2_char_t * prog_name) +{ + fprintf(stdout, "\n Usage : %s", prog_name); + fprintf(stdout, " [-p PORT]"); + fprintf(stdout, " [-t TIMEOUT]"); + fprintf(stdout, " [-r REPO_PATH]"); + fprintf(stdout, " [-l LOG_LEVEL]"); + fprintf(stdout, " [-f LOG_FILE]\n"); + fprintf(stdout, " [-s LOG_FILE_SIZE]\n"); + fprintf(stdout, " Options :\n"); + fprintf(stdout, "\t-p PORT \t port number to use, default port is 9090\n"); + fprintf(stdout, "\t-r REPO_PATH \t repository path, default is ../\n"); + fprintf(stdout, "\t-t TIMEOUT\t socket read timeout, default is 30 seconds\n"); + fprintf(stdout, "\t-l LOG_LEVEL\t log level, available log levels:" + "\n\t\t\t 0 - critical 1 - errors 2 - warnings" + "\n\t\t\t 3 - information 4 - debug 5- user 6- trace" + "\n\t\t\t Default log level is 4(debug).\n"); +#ifndef WIN32 + fprintf(stdout, "\t-f LOG_FILE\t log file, default is $AXIS2C_HOME/logs/axis2.log" + "\n\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#else + fprintf(stdout, + "\t-f LOG_FILE\t log file, default is %%AXIS2C_HOME%%\\logs\\axis2.log" + "\n\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#endif + fprintf(stdout, + "\t-s LOG_FILE_SIZE\t Maximum log file size in mega bytes, default maximum size is 1MB.\n"); + fprintf(stdout, " Help :\n\t-h \t display this help screen.\n\n"); +} + +/** + * Signal handler + */ +void +sig_handler( + int signal) +{ + + if(!system_env) + { + AXIS2_LOG_ERROR( + system_env->log, + AXIS2_LOG_SI, + "Received signal %d, unable to proceed system_env is NULL ,\ + system exit with -1", + signal); + _exit(-1); + } + + switch(signal) + { + case SIGINT: + { + /* Use of SIGINT in Windows is valid, since we have a console application + * Thus, eventhough this may a single threaded application, it does work. + */ + AXIS2_LOG_INFO(system_env->log, "Received signal SIGINT. Server " + "shutting down"); + if(server) + { + axis2_http_server_stop(server, system_env); + } + + AXIS2_LOG_INFO(system_env->log, "Shutdown complete ..."); + system_exit(system_env, 0); + } +#ifndef WIN32 + case SIGPIPE: + { + AXIS2_LOG_INFO(system_env->log, "Received signal SIGPIPE. Client " + "request serve aborted"); + return; + } +#endif + case SIGSEGV: + { + fprintf(stderr, "Received deadly signal SIGSEGV. Terminating\n"); + _exit(-1); + } + } +} diff --git a/src/core/transport/http/util/Makefile.am b/src/core/transport/http/util/Makefile.am new file mode 100644 index 0000000..eff6c0e --- /dev/null +++ b/src/core/transport/http/util/Makefile.am @@ -0,0 +1,14 @@ +NSUBDIRS = +noinst_LTLIBRARIES = libaxis2_http_util.la + +libaxis2_http_util_la_SOURCES = http_transport_utils.c + +libaxis2_http_util_la_LIBADD=$(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/parser/${WRAPPER_DIR}/libaxis2_parser.la\ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la + + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/http/util/http_transport_utils.c b/src/core/transport/http/util/http_transport_utils.c new file mode 100644 index 0000000..97d1510 --- /dev/null +++ b/src/core/transport/http/util/http_transport_utils.c @@ -0,0 +1,3885 @@ +/* + * 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. + */ + +#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 +#include + +#define AXIOM_MIME_BOUNDARY_BYTE 45 + +/** Size of the buffer to be used when reading a file */ +#ifndef AXIS2_FILE_READ_SIZE +#define AXIS2_FILE_READ_SIZE 2048 +#endif + +/** Content length value to be used in case of chunked content */ +#ifndef AXIS2_CHUNKED_CONTENT_LENGTH +#define AXIS2_CHUNKED_CONTENT_LENGTH 100000000 +#endif + +const axis2_char_t *AXIS2_TRANS_UTIL_DEFAULT_CHAR_ENCODING = + AXIS2_HTTP_HEADER_DEFAULT_CHAR_ENCODING; + +/***************************** Function headers *******************************/ + +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); + +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_is_optimized( + const axutil_env_t * env, + axiom_element_t * om_element); + +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 axis2_status_t AXIS2_CALL +axis2_http_transport_utils_strdecode( + const axutil_env_t * env, + axis2_char_t * dest, + axis2_char_t * src); + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_transport_utils_hexit( + axis2_char_t c); + +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_string_t *AXIS2_CALL +axis2_http_transport_utils_get_charset_enc( + const axutil_env_t * env, + const axis2_char_t * content_type); + +int AXIS2_CALL +axis2_http_transport_utils_on_data_request( + char *buffer, + int size, + void *ctx); + +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 axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_value_from_content_type( + const axutil_env_t * env, + const axis2_char_t * content_type, + const axis2_char_t * key); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_dispatch_and_verify( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_http_transport_utils_handle_media_type_url_encoded( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_hash_t * param_map, + axis2_char_t * method); + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_session_map_free_void_arg( + void *sm_void, + const axutil_env_t *env); + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_file( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size); + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_callback( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param); + +static axis2_char_t * +axis2_http_transport_utils_copy_key( + const axutil_env_t *env, + axis2_char_t *); + +static axis2_char_t * +axis2_http_transport_utils_copy_value( + const axutil_env_t *env, + axis2_char_t *pair); + +static void +axis2_http_transport_utils_parse_session_str( + const axutil_env_t *env, + axis2_char_t *str, + axutil_hash_t *ht); +/***************************** End of function headers ************************/ + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_transport_out_init( + axis2_http_transport_out_t *response, + const axutil_env_t *env) +{ + response->http_status_code_name = NULL; + response->http_status_code = 0; + response->msg_ctx = NULL; + response->response_data = NULL; + response->content_type = NULL; + response->response_data_length = 0; + response->content_language = NULL; + response->output_headers = NULL; + return AXIS2_SUCCESS; +} + +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) +{ + if(response->msg_ctx) + { + axis2_msg_ctx_free(response->msg_ctx, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_transport_in_init( + axis2_http_transport_in_t *request, + const axutil_env_t *env) +{ + request->content_type = NULL; + request->content_length = 0; + request->msg_ctx = NULL; + request->soap_action = NULL; + request->request_uri = NULL; + request->in_stream = NULL; + request->remote_ip = NULL; + request->svr_port = NULL; + request->transfer_encoding = NULL; + request->accept_header = NULL; + request->accept_language_header = NULL; + request->accept_charset_header = NULL; + request->request_method = 0; + request->out_transport_info = NULL; + request->request_url_prefix = NULL; + return AXIS2_SUCCESS; +} + +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) +{ + if(request->msg_ctx) + { + axis2_msg_ctx_reset_out_transport_info(request->msg_ctx, env); + axis2_msg_ctx_free(request->msg_ctx, env); + } + return AXIS2_SUCCESS; +} + +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) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_builder_t *soap_builder = NULL; + axiom_stax_builder_t *om_builder = NULL; + axis2_bool_t is_soap11 = AXIS2_FALSE; + axiom_xml_reader_t *xml_reader = NULL; + axutil_string_t *char_set_str = NULL; + + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_callback_info_t *callback_ctx = NULL; + axis2_callback_info_t *mime_cb_ctx = NULL; + axutil_hash_t *headers = NULL; + axis2_engine_t *engine = NULL; + axiom_soap_body_t *soap_body = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *binary_data_map = NULL; + axis2_char_t *soap_body_str = NULL; + axutil_stream_t *stream = NULL; + axis2_bool_t do_rest = AXIS2_FALSE; + axis2_bool_t run_as_get = AXIS2_FALSE; + axis2_char_t *soap_action = NULL; + unsigned int soap_action_len = 0; + axutil_property_t *http_error_property = NULL; + axiom_mime_parser_t *mime_parser = NULL; + axis2_bool_t is_svc_callback = AXIS2_FALSE; + axutil_property_t *is_client_property = NULL; + axis2_bool_t is_application_client_side = AXIS2_FALSE; + axis2_char_t *mime_boundary = NULL; + axis2_bool_t check_for_fault = AXIS2_FALSE; + axis2_bool_t has_fault = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FAILURE); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + /* Note: the memory created above is freed in xml reader free function + as this is passed on to the reader */ + callback_ctx->in_stream = in_stream; + callback_ctx->env = env; + callback_ctx->content_length = content_length; + callback_ctx->unread_len = content_length; + callback_ctx->chunked_stream = NULL; + + soap_action = (axis2_char_t *)axutil_string_get_buffer(soap_action_header, env); + soap_action_len = axutil_string_get_length(soap_action_header, env); + + if(soap_action && (soap_action_len > 0)) + { + /* remove leading and trailing " s */ + if(AXIS2_DOUBLE_QUOTE == soap_action[0]) + { + memmove(soap_action, soap_action + sizeof(char), soap_action_len - 1 + sizeof(char)); + } + if(AXIS2_DOUBLE_QUOTE == soap_action[soap_action_len - 2]) + { + soap_action[soap_action_len - 2] = AXIS2_ESC_NULL; + } + } + else + { + /** soap action is null, check whether soap action is in content_type header */ + soap_action = axis2_http_transport_utils_get_value_from_content_type(env, content_type, + AXIS2_ACTION); + } + + headers = axis2_msg_ctx_get_transport_headers(msg_ctx, env); + if(headers) + { + axis2_http_header_t *encoding_header = NULL; + encoding_header = (axis2_http_header_t *)axutil_hash_get(headers, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, AXIS2_HASH_KEY_STRING); + + if(encoding_header) + { + axis2_char_t *encoding_value = NULL; + encoding_value = axis2_http_header_get_value(encoding_header, env); + if(encoding_value && 0 == axutil_strcasecmp(encoding_value, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + callback_ctx->chunked_stream = axutil_http_chunked_stream_create(env, in_stream); + + if(!callback_ctx->chunked_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occurred in" + " creating in chunked stream."); + return AXIS2_FAILURE; + } + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "HTTP" + " stream chunked"); + } + } + } + else + { + /* Encoding header is not available */ + /* check content encoding from msg ctx property */ + axis2_char_t *value = axis2_msg_ctx_get_transfer_encoding(msg_ctx, env); + + if(value && axutil_strstr(value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + /* In case Transfer encoding is set to message context, some streams strip chunking meta + data, so chunked streams should not be created */ + + callback_ctx->content_length = -1; + callback_ctx->unread_len = -1; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[chunked ] setting length to -1"); + } + } + + /* when the message contains does not contain pure XML we can't send it + * directly to the parser, First we need to separate the SOAP part from + * the attachment */ + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)) + { + /* get mime boundary */ + mime_boundary = axis2_http_transport_utils_get_value_from_content_type(env, + content_type, AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + /*axiom_mime_parser_t *mime_parser = NULL;*/ + int soap_body_len = 0; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axutil_param_t *callback_name_param = NULL; + axutil_param_t *enable_service_callback_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + axis2_char_t *value_callback = NULL; + axis2_char_t *value_enable_service_callback = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + /* This is the size of the buffer we keep inside mime_parser + * when parsing. */ + + enable_service_callback_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_ENABLE_MTOM_SERVICE_CALLBACK); + if(enable_service_callback_param) + { + value_enable_service_callback = (axis2_char_t *)axutil_param_get_value( + enable_service_callback_param, env); + if(value_enable_service_callback) + { + if(!axutil_strcmp(value_enable_service_callback, AXIS2_VALUE_TRUE)) + { + is_svc_callback = AXIS2_TRUE; + } + } + } + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + if(buffer_size_param) + { + value_size = (axis2_char_t *)axutil_param_get_value(buffer_size_param, env); + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + /* We create an array of buffers in order to conatin SOAP data inside + * mime_parser. This is the number of sucj buffers */ + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + if(max_buffers_param) + { + value_num = (axis2_char_t *)axutil_param_get_value(max_buffers_param, env); + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + /* If this paramter is there mime_parser will cached the attachment + * using to the directory for large attachments. */ + + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_MTOM_CACHING_CALLBACK); + if(callback_name_param) + { + value_callback = (axis2_char_t *)axutil_param_get_value(callback_name_param, env); + if(value_callback) + { + axiom_mime_parser_set_caching_callback_name(mime_parser, env, value_callback); + } + } + + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + + if(attachment_dir_param) + { + value_dir = (axis2_char_t *)axutil_param_get_value(attachment_dir_param, env); + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + axiom_mime_parser_set_mime_boundary(mime_parser, env, mime_boundary); + + if(axiom_mime_parser_parse_for_soap(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, mime_boundary) + == AXIS2_FAILURE) + { + return AXIS2_FAILURE; + } + + if(!is_svc_callback) + { + binary_data_map = axiom_mime_parser_parse_for_attachments(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, + mime_boundary, NULL); + if(!binary_data_map) + { + return AXIS2_FAILURE; + } + } + soap_body_len = (int)axiom_mime_parser_get_soap_body_len(mime_parser, env); + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + + if(!is_svc_callback) + { + if(callback_ctx->chunked_stream) + { + axutil_http_chunked_stream_free(callback_ctx->chunked_stream, env); + callback_ctx->chunked_stream = NULL; + } + } + else + { + mime_cb_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + if(mime_cb_ctx) + { + mime_cb_ctx->in_stream = callback_ctx->in_stream; + mime_cb_ctx->env = callback_ctx->env; + mime_cb_ctx->content_length = callback_ctx->content_length; + mime_cb_ctx->unread_len = callback_ctx->unread_len; + mime_cb_ctx->chunked_stream = callback_ctx->chunked_stream; + } + } + + stream = axutil_stream_create_basic(env); + if(stream) + { + axutil_stream_write(stream, env, soap_body_str, soap_body_len); + callback_ctx->in_stream = stream; + callback_ctx->chunked_stream = NULL; + callback_ctx->content_length = soap_body_len; + callback_ctx->unread_len = soap_body_len; + } + /*axiom_mime_parser_free(mime_parser, env); + mime_parser = NULL;*/ + + /*AXIS2_FREE(env->allocator, mime_boundary);*/ + } + /*AXIS2_FREE(env->allocator, mime_boundary);*/ + } + + if(soap_action_header) + { + axis2_msg_ctx_set_soap_action(msg_ctx, env, soap_action_header); + + } + else if(soap_action) + { + axutil_string_t *soap_action_str = NULL; + soap_action_str = axutil_string_create(env, soap_action); + axis2_msg_ctx_set_soap_action(msg_ctx, env, soap_action_str); + axutil_string_free(soap_action_str, env); + } + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + char_set_str = axis2_http_transport_utils_get_charset_enc(env, content_type); + xml_reader = axiom_xml_reader_create_for_io(env, axis2_http_transport_utils_on_data_request, + NULL, (void *)callback_ctx, axutil_string_get_buffer(char_set_str, env)); + + if(!xml_reader) + { + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_charset_encoding(msg_ctx, env, char_set_str); + + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return AXIS2_FAILURE; + } + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + is_soap11 = AXIS2_FALSE; + soap_builder = axiom_soap_builder_create(env, om_builder, + AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + if(!soap_envelope) + { + axiom_stax_builder_free(om_builder, env); + om_builder = NULL; + xml_reader = NULL; + axiom_soap_builder_free(soap_builder, env); + soap_builder = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + is_soap11 = AXIS2_TRUE; + if(soap_action_header) + { + soap_builder = axiom_soap_builder_create(env, om_builder, + AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + if(!soap_envelope) + { + axiom_soap_builder_free(soap_builder, env); + om_builder = NULL; + xml_reader = NULL; + soap_builder = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + } + else + { + /* REST support */ + do_rest = AXIS2_TRUE; + } + } + + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_X_WWW_FORM_URLENCODED)) + { + /* REST support */ + do_rest = AXIS2_TRUE; + run_as_get = AXIS2_TRUE; + } + else + { + http_error_property = axutil_property_create(env); + axutil_property_set_value(http_error_property, env, AXIS2_HTTP_UNSUPPORTED_MEDIA_TYPE); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_TRANSPORT_ERROR, http_error_property); + } + + if(soap_builder) + { + if(mime_parser) + { + axiom_soap_builder_set_mime_parser(soap_builder, env, mime_parser); + if(mime_cb_ctx) + { + axiom_soap_builder_set_callback_ctx(soap_builder, env, mime_cb_ctx); + axiom_soap_builder_set_callback_function(soap_builder, env, + axis2_http_transport_utils_on_data_request); + } + else if(is_svc_callback) + { + return AXIS2_FAILURE; + } + } + } + + if(do_rest) + { + /* REST support */ + axutil_param_t *rest_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ENABLE_REST); + if(rest_param && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, axutil_param_get_value(rest_param, + env))) + { + axiom_soap_body_t *def_body = NULL; + axiom_document_t *om_doc = NULL; + axiom_node_t *root_node = NULL; + if(!run_as_get) + { + soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + def_body = axiom_soap_envelope_get_body(soap_envelope, env); + om_doc = axiom_stax_builder_get_document(om_builder, env); + root_node = axiom_document_build_all(om_doc, env); + axiom_soap_body_add_child(def_body, env, root_node); + } + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_POST); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + } + else + { + return AXIS2_FAILURE; + } + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FAILURE; + } + } + + if(run_as_get) + { + axis2_char_t *buffer = NULL; + axis2_char_t *new_url = NULL; + buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (content_length + 1)); + if(!buffer) + { + return AXIS2_FAILURE; + } + axis2_http_transport_utils_on_data_request(buffer, content_length, (void *)callback_ctx); + + new_url = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * ((int)(strlen(request_uri) + + strlen(buffer)) + 2)); + if(!new_url) + { + return AXIS2_FAILURE; + } + sprintf(new_url, "%s?%s", request_uri, buffer); + AXIS2_FREE(env->allocator, buffer); + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + axis2_http_transport_utils_get_request_params(env, new_url), AXIS2_HTTP_POST); + } + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + engine = axis2_engine_create(env, conf_ctx); + + if(!soap_envelope) + return AXIS2_FAILURE; + + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(!soap_body) + return AXIS2_FAILURE; + + if(!is_svc_callback) + { + is_client_property = axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE); + if(is_client_property) + { + axis2_char_t *prop_value = NULL; + prop_value = axutil_property_get_value(is_client_property, env); + if(prop_value && !axutil_strcmp(prop_value , AXIS2_VALUE_TRUE)) + { + is_application_client_side = AXIS2_TRUE; + } + } + if(mime_boundary || is_application_client_side) + { + check_for_fault = AXIS2_TRUE; + } + if(check_for_fault) + { + has_fault = axiom_soap_body_has_fault(soap_body, env); + } + if(has_fault) + { + status = axis2_engine_receive_fault(engine, env, msg_ctx); + } + else + { + status = axis2_engine_receive(engine, env, msg_ctx); + } + } + else + { + status = axis2_engine_receive(engine, env, msg_ctx); + } + + if(!axis2_msg_ctx_get_soap_envelope(msg_ctx, env) && AXIS2_FALSE == is_soap11) + { + axiom_soap_envelope_t *def_envelope = axiom_soap_envelope_create_default_soap_envelope(env, + AXIOM_SOAP12); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, def_envelope); + } + + if(engine) + { + axis2_engine_free(engine, env); + } + + if(soap_body_str) + { + AXIS2_FREE(env->allocator, soap_body_str); + } + + if(stream) + { + axutil_stream_free(stream, env); + } + + if(char_set_str) + { + axutil_string_free(char_set_str, env); + } + if(!soap_builder && om_builder) + { + axiom_stax_builder_free_self(om_builder, env); + om_builder = NULL; + } + if(!axutil_string_get_buffer(soap_action_header, env) && soap_action) + { + AXIS2_FREE(env->allocator, soap_action); + soap_action = NULL; + } + return status; +} + +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) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_builder_t *soap_builder = NULL; + axiom_stax_builder_t *om_builder = NULL; + axis2_bool_t is_soap11 = AXIS2_FALSE; + axiom_xml_reader_t *xml_reader = NULL; + axutil_string_t *char_set_str = NULL; + + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_callback_info_t *callback_ctx; + axutil_hash_t *headers = NULL; + axis2_engine_t *engine = NULL; + axiom_soap_body_t *soap_body = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *binary_data_map = NULL; + axis2_char_t *soap_body_str = NULL; + axutil_stream_t *stream = NULL; + axis2_bool_t do_rest = AXIS2_FALSE; + axis2_bool_t run_as_get = AXIS2_FALSE; + axutil_property_t *http_error_property = NULL; + axutil_property_t *is_client_property = NULL; + axis2_bool_t is_application_client_side = AXIS2_FALSE; + axis2_char_t *mime_boundary = NULL; + axis2_bool_t check_for_fault = AXIS2_FALSE; + axis2_bool_t has_fault = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FAILURE); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + /* Note: the memory created above is freed in xml reader free function + as this is passed on to the reader */ + callback_ctx->in_stream = in_stream; + callback_ctx->env = env; + callback_ctx->content_length = content_length; + callback_ctx->unread_len = content_length; + callback_ctx->chunked_stream = NULL; + + headers = axis2_msg_ctx_get_transport_headers(msg_ctx, env); + if(headers) + { + axis2_http_header_t *encoding_header = NULL; + encoding_header = (axis2_http_header_t *)axutil_hash_get(headers, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, AXIS2_HASH_KEY_STRING); + + if(encoding_header) + { + axis2_char_t *encoding_value = NULL; + encoding_value = axis2_http_header_get_value(encoding_header, env); + if(encoding_value && 0 == axutil_strcasecmp(encoding_value, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + callback_ctx->chunked_stream = axutil_http_chunked_stream_create(env, in_stream); + if(!callback_ctx->chunked_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in" + " creating in chunked stream."); + return AXIS2_FAILURE; + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "HTTP" + " stream chunked"); + } + } + } + else + { + /* check content encoding from msg ctx property */ + axis2_char_t *value = axis2_msg_ctx_get_transfer_encoding(msg_ctx, env); + + if(value && axutil_strstr(value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + /* this is an UGLY hack to get some of the transports working + e.g. PHP transport where it strips the chunking info in case of chunking + and also gives out a content lenght of 0. + We need to fix the transport design to fix sutuations like this. + */ + callback_ctx->content_length = AXIS2_CHUNKED_CONTENT_LENGTH; + callback_ctx->unread_len = callback_ctx->content_length; + } + } + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)) + { + /* get mime boundry */ + mime_boundary = axis2_http_transport_utils_get_value_from_content_type(env, + content_type, AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + axiom_mime_parser_t *mime_parser = NULL; + int soap_body_len = 0; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axutil_param_t *callback_name_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + axis2_char_t *value_callback = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + if(buffer_size_param) + { + value_size = (axis2_char_t *)axutil_param_get_value(buffer_size_param, env); + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + if(max_buffers_param) + { + value_num = (axis2_char_t *)axutil_param_get_value(max_buffers_param, env); + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_MTOM_CACHING_CALLBACK); + if(callback_name_param) + { + value_callback = (axis2_char_t *)axutil_param_get_value(callback_name_param, env); + if(value_callback) + { + axiom_mime_parser_set_caching_callback_name(mime_parser, env, value_callback); + } + } + + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + + if(attachment_dir_param) + { + value_dir = (axis2_char_t *)axutil_param_get_value(attachment_dir_param, env); + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + if(mime_parser) + { + /*binary_data_map = + axiom_mime_parser_parse(mime_parser, env, + axis2_http_transport_utils_on_data_request, + (void *) callback_ctx, + mime_boundary);*/ + if(!binary_data_map) + { + return AXIS2_FAILURE; + } + soap_body_len = (int)axiom_mime_parser_get_soap_body_len(mime_parser, env); + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + } + + stream = axutil_stream_create_basic(env); + if(stream) + { + axutil_stream_write(stream, env, soap_body_str, soap_body_len); + callback_ctx->in_stream = stream; + callback_ctx->chunked_stream = NULL; + callback_ctx->content_length = soap_body_len; + callback_ctx->unread_len = soap_body_len; + } + axiom_mime_parser_free(mime_parser, env); + mime_parser = NULL; + } + /*AXIS2_FREE(env->allocator, mime_boundary);*/ + } + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + + char_set_str = axis2_http_transport_utils_get_charset_enc(env, content_type); + xml_reader = axiom_xml_reader_create_for_io(env, axis2_http_transport_utils_on_data_request, + NULL, (void *)callback_ctx, axutil_string_get_buffer(char_set_str, env)); + + if(!xml_reader) + { + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_charset_encoding(msg_ctx, env, char_set_str); + + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return AXIS2_FAILURE; + } + + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + is_soap11 = AXIS2_FALSE; + soap_builder = axiom_soap_builder_create(env, om_builder, + AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + if(!soap_envelope) + { + axiom_stax_builder_free(om_builder, env); + om_builder = NULL; + xml_reader = NULL; + axiom_soap_builder_free(soap_builder, env); + soap_builder = NULL; + axis2_msg_ctx_set_is_soap_11(msg_ctx, env, is_soap11); + return AXIS2_FAILURE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + do_rest = AXIS2_TRUE; + if(soap_action_header) + { + return AXIS2_FAILURE; + } + else + { + /* REST support */ + do_rest = AXIS2_TRUE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_X_WWW_FORM_URLENCODED)) + { + /* REST support */ + do_rest = AXIS2_TRUE; + run_as_get = AXIS2_TRUE; + } + else + { + http_error_property = axutil_property_create(env); + axutil_property_set_value(http_error_property, env, AXIS2_HTTP_UNSUPPORTED_MEDIA_TYPE); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_TRANSPORT_ERROR, http_error_property); + } + + if(do_rest) + { + /* REST support */ + axutil_param_t *rest_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ENABLE_REST); + if(rest_param && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, axutil_param_get_value(rest_param, + env))) + { + axiom_soap_body_t *def_body = NULL; + axiom_document_t *om_doc = NULL; + axiom_node_t *root_node = NULL; + if(!run_as_get) + { + soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + def_body = axiom_soap_envelope_get_body(soap_envelope, env); + om_doc = axiom_stax_builder_get_document(om_builder, env); + root_node = axiom_document_build_all(om_doc, env); + axiom_soap_body_add_child(def_body, env, root_node); + } + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_PUT); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + } + else + { + return AXIS2_FAILURE; + } + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FAILURE; + } + } + + if(run_as_get) + { + axis2_char_t *buffer = NULL; + axis2_char_t *new_url = NULL; + buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (content_length + 1)); + if(!buffer) + { + return AXIS2_FAILURE; + } + axis2_http_transport_utils_on_data_request(buffer, content_length, (void *)callback_ctx); + + new_url = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * ((int)(strlen(request_uri) + + strlen(buffer)) + 2)); + if(!new_url) + { + return AXIS2_FAILURE; + } + sprintf(new_url, "%s?%s", request_uri, buffer); + AXIS2_FREE(env->allocator, buffer); + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + axis2_http_transport_utils_get_request_params(env, new_url), AXIS2_HTTP_POST); + } + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + engine = axis2_engine_create(env, conf_ctx); + + if(!soap_envelope) + return AXIS2_FAILURE; + + soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(!soap_body) + return AXIS2_FAILURE; + + is_client_property = axis2_msg_ctx_get_property(msg_ctx, env, + AXIS2_TRANPORT_IS_APPLICATION_CLIENT_SIDE); + if(is_client_property) + { + axis2_char_t *prop_value = NULL; + prop_value = axutil_property_get_value(is_client_property, env); + if(prop_value && !axutil_strcmp(prop_value , AXIS2_VALUE_TRUE)) + { + is_application_client_side = AXIS2_TRUE; + } + } + if(mime_boundary || is_application_client_side) + { + check_for_fault = AXIS2_TRUE; + } + if(check_for_fault) + { + has_fault = axiom_soap_body_has_fault(soap_body, env); + } + if(has_fault) + { + status = axis2_engine_receive_fault(engine, env, msg_ctx); + } + else + { + status = axis2_engine_receive(engine, env, msg_ctx); + } + if(mime_boundary) + { + AXIS2_FREE(env->allocator, mime_boundary); + } + if(!axis2_msg_ctx_get_soap_envelope(msg_ctx, env) && AXIS2_FALSE == is_soap11) + { + axiom_soap_envelope_t *def_envelope = axiom_soap_envelope_create_default_soap_envelope(env, + AXIOM_SOAP12); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, def_envelope); + } + + if(engine) + { + axis2_engine_free(engine, env); + } + + if(soap_body_str) + { + AXIS2_FREE(env->allocator, soap_body_str); + } + + if(stream) + { + axutil_stream_free(stream, env); + } + + if(char_set_str) + { + axutil_string_free(char_set_str, env); + } + if(!soap_builder && om_builder) + { + axiom_stax_builder_free_self(om_builder, env); + om_builder = NULL; + } + return status; +} + +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) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_engine_t *engine = NULL; + axis2_bool_t do_rest = AXIS2_TRUE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FALSE); + + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FALSE); + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + if(soap_action_header) + { + do_rest = AXIS2_FALSE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + do_rest = AXIS2_FALSE; + } + + if(do_rest) + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_HEAD); + } + else + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_FALSE); + } + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FALSE; + } + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + request_params, AXIS2_HTTP_HEAD); + if(!soap_envelope) + { + return AXIS2_FALSE; + } + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + engine = axis2_engine_create(env, conf_ctx); + axis2_engine_receive(engine, env, msg_ctx); + return AXIS2_TRUE; +} + +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) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_engine_t *engine = NULL; + axis2_bool_t do_rest = AXIS2_TRUE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FALSE); + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + if(content_type && strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + if(soap_action_header) + { + do_rest = AXIS2_FALSE; + } + } + else if(content_type && strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + do_rest = AXIS2_FALSE; + } + + if(do_rest) + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_GET); + } + else + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_FALSE); + } + + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FALSE; + } + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + request_params, AXIS2_HTTP_GET); + if(!soap_envelope) + { + return AXIS2_FALSE; + } + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + engine = axis2_engine_create(env, conf_ctx); + axis2_engine_receive(engine, env, msg_ctx); + return AXIS2_TRUE; +} + +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) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_engine_t *engine = NULL; + axis2_bool_t do_rest = AXIS2_TRUE; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FALSE); + + axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, request_uri)); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) + { + if(soap_action_header) + { + do_rest = AXIS2_FALSE; + } + } + else if(strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) + { + do_rest = AXIS2_FALSE; + } + + if(do_rest) + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_rest_http_method(msg_ctx, env, AXIS2_HTTP_DELETE); + } + else + { + axis2_msg_ctx_set_doing_rest(msg_ctx, env, AXIS2_FALSE); + } + + soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded(env, msg_ctx, + request_params, AXIS2_HTTP_DELETE); + if(!soap_envelope) + { + return AXIS2_FALSE; + } + + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + if(AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, msg_ctx)) + { + return AXIS2_FALSE; + } + engine = axis2_engine_create(env, conf_ctx); + axis2_engine_receive(engine, env, msg_ctx); + return AXIS2_TRUE; +} + +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_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + return (axis2_msg_ctx_get_doing_mtom(msg_ctx, env)); +} + +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_char_t *query_str = NULL; + axis2_char_t *tmp = strchr(request_uri, AXIS2_Q_MARK); + axis2_char_t *tmp2 = NULL; + axis2_char_t *tmp_name = NULL; + axis2_char_t *tmp_value = NULL; + axutil_hash_t *ret = NULL; + + AXIS2_PARAM_CHECK(env->error, request_uri, NULL); + + if(!tmp || AXIS2_ESC_NULL == *(tmp + 1)) + { + return NULL; + } + query_str = axutil_strdup(env, tmp + 1); + + for(tmp2 = tmp = query_str; *tmp != AXIS2_ESC_NULL; ++tmp) + { + if(AXIS2_EQ == *tmp) + { + *tmp = AXIS2_ESC_NULL; + tmp_name = axutil_strdup(env, tmp2); + axis2_http_transport_utils_strdecode(env, tmp_name, tmp_name); + tmp2 = tmp + 1; + } + if(AXIS2_AND == *tmp) + { + *tmp = AXIS2_ESC_NULL; + tmp_value = axutil_strdup(env, tmp2); + axis2_http_transport_utils_strdecode(env, tmp_value, tmp_value); + tmp2 = tmp + 1; + } + if(tmp_name && NULL != tmp_value) + { + if(!ret) + { + ret = axutil_hash_make(env); + } + axutil_hash_set(ret, tmp_name, AXIS2_HASH_KEY_STRING, tmp_value); + tmp_name = NULL; + tmp_value = NULL; + } + } + if(tmp_name && AXIS2_ESC_NULL != *tmp2) + { + if(!ret) + { + ret = axutil_hash_make(env); + } + tmp_value = axutil_strdup(env, tmp2); + axis2_http_transport_utils_strdecode(env, tmp_value, tmp_value); + axutil_hash_set(ret, tmp_name, AXIS2_HASH_KEY_STRING, tmp_value); + } + + return ret; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_strdecode( + const axutil_env_t * env, + axis2_char_t * dest, + axis2_char_t * src) +{ + AXIS2_PARAM_CHECK(env->error, dest, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, src, AXIS2_FAILURE); + + for(; *src != AXIS2_ESC_NULL; ++dest, ++src) + { + if(src[0] == AXIS2_PERCENT && isxdigit((int)src[1]) && isxdigit((int)src[2])) + { + *dest = (axis2_char_t)(axis2_http_transport_utils_hexit(src[1]) * 16 + + axis2_http_transport_utils_hexit(src[2])); + /* We are sure that the conversion is valid */ + src += 2; + } + else + { + *dest = *src; + } + } + *dest = AXIS2_ESC_NULL; + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_transport_utils_hexit( + axis2_char_t c) +{ + if(c >= '0' && c <= '9') + { + return c - '0'; + } + if(c >= 'a' && c <= 'f') + { + return c - 'a' + 10; + } + if(c >= 'A' && c <= 'F') + { + return c - 'A' + 10; + } + return 0; /* shouldn't happen, we're guarded by isxdigit() */ +} + +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) +{ + return AXIS2_HTTP_NOT_FOUND; +} + +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) +{ + return AXIS2_HTTP_NOT_IMPLEMENTED; +} + +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) +{ + return AXIS2_HTTP_INTERNAL_SERVER_ERROR; +} + +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) +{ + return AXIS2_HTTP_METHOD_NOT_ALLOWED; +} + +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) +{ + return AXIS2_HTTP_NOT_ACCEPTABLE; +} + +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) +{ + return AXIS2_HTTP_BAD_REQUEST; +} + +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) +{ + return AXIS2_HTTP_REQUEST_TIMEOUT; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_conflict( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_CONFLICT; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_gone( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + return AXIS2_HTTP_GONE; +} + +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) +{ + return AXIS2_HTTP_PRECONDITION_FAILED; +} + +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) +{ + return AXIS2_HTTP_TOO_LARGE; +} + +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) +{ + return AXIS2_HTTP_SERVICE_UNAVILABLE; +} + +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) +{ + axutil_hash_t *services_map = NULL; + axutil_hash_t *errorneous_svc_map = NULL; + axis2_char_t *ret = NULL; + axis2_char_t *tmp2 = (axis2_char_t *)"

Deployed Services

"; + axutil_hash_index_t *hi = NULL; + axis2_bool_t svcs_exists = AXIS2_FALSE; + axis2_conf_t *conf = NULL; + AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + services_map = axis2_conf_get_all_svcs(conf, env); + errorneous_svc_map = axis2_conf_get_all_faulty_svcs(conf, env); + if(services_map && 0 != axutil_hash_count(services_map)) + { + void *service = NULL; + axis2_char_t *sname = NULL; + axutil_hash_t *ops = NULL; + svcs_exists = AXIS2_TRUE; + + for(hi = axutil_hash_first(services_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &service); + sname = axutil_qname_get_localpart(axis2_svc_get_qname(((axis2_svc_t *)service), env), + env); + ret = axutil_stracat(env, tmp2, "

"); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, sname); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "

"); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "

"); + tmp2 = ret; + + /** + *setting services description */ + ret = axutil_stracat(env, tmp2, axis2_svc_get_svc_desc((axis2_svc_t *)service, env)); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "

"); + tmp2 = ret; + ops = axis2_svc_get_all_ops(((axis2_svc_t *)service), env); + if(ops && 0 != axutil_hash_count(ops)) + { + axutil_hash_index_t *hi2 = NULL; + void *op = NULL; + axis2_char_t *oname = NULL; + + ret = axutil_stracat(env, tmp2, "Available Operations
    "); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + for(hi2 = axutil_hash_first(ops, env); hi2; hi2 = axutil_hash_next(env, hi2)) + { + axutil_hash_this(hi2, NULL, NULL, &op); + oname = axutil_qname_get_localpart(axis2_op_get_qname(((axis2_op_t *)op), env), + env); + ret = axutil_stracat(env, tmp2, "
  • "); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + + ret = axutil_stracat(env, tmp2, oname); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "
    • "); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + } + ret = axutil_stracat(env, tmp2, "
"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + } + else + { + ret = axutil_stracat(env, tmp2, "No operations Available"); + tmp2 = ret; + } + } + } + + if(errorneous_svc_map && 0 != axutil_hash_count(errorneous_svc_map)) + { + void *fsname = NULL; + svcs_exists = AXIS2_TRUE; + ret = axutil_stracat(env, tmp2, + "

Faulty \ + Services

"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + + for(hi = axutil_hash_first(errorneous_svc_map, env); hi; axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, (const void **)&fsname, NULL, NULL); + ret = axutil_stracat(env, tmp2, "

"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, (axis2_char_t *)fsname); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "

"); + AXIS2_FREE(env->allocator, tmp2); + tmp2 = ret; + } + } + if(AXIS2_FALSE == svcs_exists) + { + ret = axutil_strdup(env, "

There are no services deployed

"); + } + ret = axutil_stracat(env, "Axis2C :: Services" + "", tmp2); + tmp2 = ret; + ret = axutil_stracat(env, tmp2, "\r\n"); + + return ret; +} + +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_char_t *wsdl_string = NULL; + axis2_char_t *wsdl_path = NULL; + axis2_char_t **url_tok = NULL; + unsigned int len = 0; + axis2_char_t *svc_name = NULL; + axis2_conf_t *conf = NULL; + axutil_hash_t *services_map = NULL; + axutil_hash_index_t *hi = NULL; + + AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, request_url, NULL); + + url_tok = axutil_parse_request_url_for_svc_and_op(env, request_url); + if(url_tok[0]) + { + len = (int)strlen(url_tok[0]); + /* We are sure that the difference lies within the int range */ + url_tok[0][len - 5] = 0; + svc_name = url_tok[0]; + } + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + services_map = axis2_conf_get_all_svcs(conf, env); + + if(services_map && 0 != axutil_hash_count(services_map)) + { + void *service = NULL; + axis2_char_t *sname = NULL; + + for(hi = axutil_hash_first(services_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &service); + sname = axutil_qname_get_localpart(axis2_svc_get_qname(((axis2_svc_t *)service), env), + env); + if(!axutil_strcmp(svc_name, sname)) + { + wsdl_path = (axis2_char_t *)axutil_strdup(env, axis2_svc_get_svc_wsdl_path( + (axis2_svc_t *)service, env)); + if(!wsdl_path) + { + wsdl_path = axutil_strcat(env, axis2_svc_get_svc_folder_path( + (axis2_svc_t *)service, env), AXIS2_PATH_SEP_STR, svc_name, ".wsdl", NULL); + } + break; + } + + } + } + + if(wsdl_path) + { + FILE *wsdl_file = NULL; + axis2_char_t *content = NULL; + int c; + int size = AXIS2_FILE_READ_SIZE; + axis2_char_t *tmp; + int i = 0; + + content = (axis2_char_t *)AXIS2_MALLOC(env->allocator, size); + wsdl_file = fopen(wsdl_path, "r"); + if(wsdl_file) + { + c = fgetc(wsdl_file); + while(c != EOF) + { + if(i >= size) + { + size = size * 3; + tmp = (axis2_char_t *)AXIS2_MALLOC(env->allocator, size); + memcpy(tmp, content, i); + AXIS2_FREE(env->allocator, content); + content = tmp; + } + content[i++] = (axis2_char_t)c; + c = fgetc(wsdl_file); + } + content[i] = AXIS2_ESC_NULL; + wsdl_string = (axis2_char_t *)content; + fclose(wsdl_file); + } + + AXIS2_FREE(env->allocator, wsdl_path); + } + else + { + wsdl_string = axutil_strdup(env, "Unable to retrieve wsdl for this service"); + } + + return wsdl_string; +} + +AXIS2_EXTERN axutil_string_t *AXIS2_CALL +axis2_http_transport_utils_get_charset_enc( + const axutil_env_t * env, + const axis2_char_t * content_type) +{ + axis2_char_t *tmp = NULL; + axis2_char_t *tmp_content_type = NULL; + axis2_char_t *tmp2 = NULL; + axutil_string_t *str = NULL; + + AXIS2_PARAM_CHECK(env->error, content_type, NULL); + + tmp_content_type = (axis2_char_t *)content_type; + if(!tmp_content_type) + { + return axutil_string_create_const(env, + (axis2_char_t **)&AXIS2_TRANS_UTIL_DEFAULT_CHAR_ENCODING); + } + + tmp = strstr(tmp_content_type, AXIS2_HTTP_CHAR_SET_ENCODING); + + if(tmp) + { + tmp = strchr(tmp, AXIS2_EQ); + if(tmp) + { + tmp2 = strchr(tmp, AXIS2_SEMI_COLON); + if(!tmp2) + { + tmp2 = tmp + strlen(tmp); + } + } + + if(tmp2) + { + if('\'' == *(tmp2 - sizeof(axis2_char_t)) || '\"' == *(tmp2 - sizeof(axis2_char_t))) + { + tmp2 -= sizeof(axis2_char_t); + } + *tmp2 = AXIS2_ESC_NULL; + } + } + + if(tmp) + { + /* Following formats are acceptable + * charset="UTF-8" + * charser='UTF-8' + * charset=UTF-8 + * But for our requirements charset we get should be UTF-8 + */ + if(AXIS2_ESC_SINGLE_QUOTE == *(tmp + sizeof(axis2_char_t)) || AXIS2_ESC_DOUBLE_QUOTE + == *(tmp + sizeof(axis2_char_t))) + { + tmp += 2 * sizeof(axis2_char_t); + } + else + { + tmp += sizeof(axis2_char_t); + } + } + + if(tmp) + { + str = axutil_string_create(env, tmp); + } + else + { + str = axutil_string_create_const(env, + (axis2_char_t **)&AXIS2_TRANS_UTIL_DEFAULT_CHAR_ENCODING); + } + return str; +} + +int AXIS2_CALL +axis2_http_transport_utils_on_data_request( + char *buffer, + int size, + void *ctx) +{ + const axutil_env_t *env = NULL; + int len = -1; + axis2_callback_info_t *cb_ctx = (axis2_callback_info_t *)ctx; + + if(!buffer || !ctx) + { + return 0; + } + env = ((axis2_callback_info_t *)ctx)->env; + if(cb_ctx->unread_len <= 0 && -1 != cb_ctx->content_length) + { + return 0; + } + if(cb_ctx->chunked_stream) + { + --size; + /* reserve space to insert trailing null */ + len = axutil_http_chunked_stream_read(cb_ctx->chunked_stream, env, buffer, size); + if(len >= 0) + { + buffer[len] = AXIS2_ESC_NULL; + } + } + else + { + axutil_stream_t *in_stream = NULL; + in_stream = (axutil_stream_t *)((axis2_callback_info_t *)ctx)->in_stream; + --size; /* reserve space to insert trailing null */ + len = axutil_stream_read(in_stream, env, buffer, size); + if(len > 0) + { + buffer[len] = AXIS2_ESC_NULL; + ((axis2_callback_info_t *)ctx)->unread_len -= len; + } + else if(len == 0) + { + ((axis2_callback_info_t *)ctx)->unread_len = 0; + } + } + return len; +} + +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_op_ctx_t *op_ctx = NULL; + const axis2_char_t *char_set_enc = NULL; + axis2_char_t *content_type = NULL; + axutil_stream_t *in_stream = NULL; + axis2_callback_info_t *callback_ctx = NULL; + axis2_char_t *trans_enc = NULL; + int *content_length = NULL; + axutil_property_t *property = NULL; + axutil_hash_t *binary_data_map = NULL; + axiom_soap_envelope_t *soap_envelope = NULL; + axutil_stream_t *stream = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, soap_ns_uri, NULL); + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_TRANSPORT_IN); + if(property) + { + in_stream = axutil_property_get_value(property, env); + property = NULL; + } + callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); + /* Note: the memory created above is freed in xml reader free function + as this is passed on to the reader */ + if(!callback_ctx) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + callback_ctx->in_stream = in_stream; + callback_ctx->env = env; + callback_ctx->content_length = -1; + callback_ctx->unread_len = -1; + callback_ctx->chunked_stream = NULL; + + property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_HTTP_HEADER_CONTENT_LENGTH); + if(property) + { + content_length = axutil_property_get_value(property, env); + property = NULL; + } + + if(content_length) + { + callback_ctx->content_length = *content_length; + callback_ctx->unread_len = *content_length; + } + + if(!in_stream) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_IN_STREAM_IN_MSG_CTX, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, callback_ctx); + return NULL; + } + + trans_enc = axis2_msg_ctx_get_transfer_encoding(msg_ctx, env); + + if(trans_enc && 0 == axutil_strcmp(trans_enc, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + callback_ctx->chunked_stream = axutil_http_chunked_stream_create(env, in_stream); + if(!callback_ctx->chunked_stream) + { + return NULL; + } + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + axis2_ctx_t *ctx = axis2_op_ctx_get_base(op_ctx, env); + if(ctx) + { + property = axis2_ctx_get_property(ctx, env, AXIS2_CHARACTER_SET_ENCODING); + if(property) + { + char_set_enc = axutil_property_get_value(property, env); + property = NULL; + } + property = axis2_ctx_get_property(ctx, env, MTOM_RECIVED_CONTENT_TYPE); + if(property) + { + content_type = axutil_property_get_value(property, env); + property = NULL; + } + + } + } + + if(!char_set_enc) + { + char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; + } + if(content_type) + { + axis2_char_t *mime_boundary = NULL; + axis2_msg_ctx_set_doing_mtom(msg_ctx, env, AXIS2_TRUE); + /* get mime boundry */ + mime_boundary = axis2_http_transport_utils_get_value_from_content_type(env, content_type, + AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); + + if(mime_boundary) + { + axiom_mime_parser_t *mime_parser = NULL; + int soap_body_len = 0; + axis2_char_t *soap_body_str = NULL; + axutil_param_t *buffer_size_param = NULL; + axutil_param_t *max_buffers_param = NULL; + axutil_param_t *attachment_dir_param = NULL; + axutil_param_t *callback_name_param = NULL; + axis2_char_t *value_size = NULL; + axis2_char_t *value_num = NULL; + axis2_char_t *value_dir = NULL; + axis2_char_t *value_callback = NULL; + int size = 0; + int num = 0; + + mime_parser = axiom_mime_parser_create(env); + + /* Following are the parameters in the axis2.xml regarding MTOM */ + + buffer_size_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_BUFFER_SIZE); + if(buffer_size_param) + { + value_size = (axis2_char_t *)axutil_param_get_value(buffer_size_param, env); + + if(value_size) + { + size = atoi(value_size); + axiom_mime_parser_set_buffer_size(mime_parser, env, size); + } + } + + max_buffers_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_MTOM_MAX_BUFFERS); + if(max_buffers_param) + { + value_num = (axis2_char_t *)axutil_param_get_value(max_buffers_param, env); + if(value_num) + { + num = atoi(value_num); + axiom_mime_parser_set_max_buffers(mime_parser, env, num); + } + } + + callback_name_param = axis2_msg_ctx_get_parameter(msg_ctx, env, + AXIS2_MTOM_CACHING_CALLBACK); + if(callback_name_param) + { + value_callback = (axis2_char_t *)axutil_param_get_value(callback_name_param, env); + if(value_callback) + { + axiom_mime_parser_set_caching_callback_name(mime_parser, env, value_callback); + } + } + + attachment_dir_param = axis2_msg_ctx_get_parameter(msg_ctx, env, AXIS2_ATTACHMENT_DIR); + if(attachment_dir_param) + { + value_dir = (axis2_char_t *)axutil_param_get_value(attachment_dir_param, env); + if(value_dir) + { + axiom_mime_parser_set_attachment_dir(mime_parser, env, value_dir); + } + } + + if(mime_parser) + { + if(axiom_mime_parser_parse_for_soap(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, mime_boundary) + == AXIS2_FAILURE) + { + return NULL; + } + + binary_data_map = axiom_mime_parser_parse_for_attachments(mime_parser, env, + axis2_http_transport_utils_on_data_request, (void *)callback_ctx, + mime_boundary, NULL); + if(!binary_data_map) + { + return NULL; + } + + if(!binary_data_map) + { + return NULL; + } + + soap_body_len = (int)axiom_mime_parser_get_soap_body_len(mime_parser, env); + soap_body_str = axiom_mime_parser_get_soap_body_str(mime_parser, env); + } + + if(callback_ctx->chunked_stream) + { + axutil_http_chunked_stream_free(callback_ctx->chunked_stream, env); + callback_ctx->chunked_stream = NULL; + } + + stream = axutil_stream_create_basic(env); + if(stream) + { + axutil_stream_write(stream, env, soap_body_str, soap_body_len); + callback_ctx->in_stream = stream; + callback_ctx->chunked_stream = NULL; + callback_ctx->content_length = soap_body_len; + callback_ctx->unread_len = soap_body_len; + } + + axiom_mime_parser_free(mime_parser, env); + mime_parser = NULL; + if(mime_boundary) + { + AXIS2_FREE(env->allocator, mime_boundary); + } + + if(soap_body_str) + { + AXIS2_FREE(env->allocator, soap_body_str); + } + } + } + + if(AXIS2_TRUE != axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + axiom_xml_reader_t *xml_reader = NULL; + axiom_stax_builder_t *om_builder = NULL; + axiom_soap_builder_t *soap_builder = NULL; + + xml_reader = axiom_xml_reader_create_for_io(env, + axis2_http_transport_utils_on_data_request, NULL, (void *)callback_ctx, char_set_enc); + if(!xml_reader) + { + return NULL; + } + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return NULL; + } + soap_builder = axiom_soap_builder_create(env, om_builder, soap_ns_uri); + if(!soap_builder) + { + /* We should not be freeing om_builder here as it is done by + axiom_soap_builder_create in case of error - Samisa */ + om_builder = NULL; + xml_reader = NULL; + return NULL; + } + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + + if(binary_data_map) + { + axiom_soap_builder_set_mime_body_parts(soap_builder, env, binary_data_map); + } + + if(soap_envelope) + { + /* hack to get around MTOM problem */ + axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(soap_body) + { + axiom_soap_body_has_fault(soap_body, env); + } + } + if(stream) + { + axutil_stream_free(stream, env); + callback_ctx->in_stream = NULL; + } + if(callback_ctx->chunked_stream) + { + axutil_http_chunked_stream_free(callback_ctx->chunked_stream, env); + callback_ctx->chunked_stream = NULL; + } + + } + else + { + /* REST processing */ + axiom_xml_reader_t *xml_reader = NULL; + axiom_stax_builder_t *om_builder = NULL; + axiom_soap_body_t *def_body = NULL; + axiom_document_t *om_doc = NULL; + axiom_node_t *root_node = NULL; + + xml_reader = axiom_xml_reader_create_for_io(env, + axis2_http_transport_utils_on_data_request, NULL, (void *)callback_ctx, char_set_enc); + if(!xml_reader) + { + return NULL; + } + om_builder = axiom_stax_builder_create(env, xml_reader); + if(!om_builder) + { + axiom_xml_reader_free(xml_reader, env); + xml_reader = NULL; + return NULL; + } + soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + def_body = axiom_soap_envelope_get_body(soap_envelope, env); + om_doc = axiom_stax_builder_get_document(om_builder, env); + root_node = axiom_document_build_all(om_doc, env); + axiom_soap_body_add_child(def_body, env, root_node); + axiom_stax_builder_free_self(om_builder, env); + } + + return soap_envelope; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_value_from_content_type( + const axutil_env_t * env, + const axis2_char_t * content_type, + const axis2_char_t * key) +{ + axis2_char_t *tmp = NULL; + axis2_char_t *tmp_content_type = NULL; + axis2_char_t *tmp2 = NULL; + + AXIS2_PARAM_CHECK(env->error, content_type, NULL); + AXIS2_PARAM_CHECK(env->error, key, NULL); + + tmp_content_type = axutil_strdup(env, content_type); + if(!tmp_content_type) + { + return NULL; + } + tmp = strstr(tmp_content_type, key); + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_content_type); + return NULL; + } + + tmp = strchr(tmp, AXIS2_EQ); + tmp2 = strchr(tmp, AXIS2_SEMI_COLON); + + if(tmp2) + { + *tmp2 = AXIS2_ESC_NULL; + } + if(!tmp) + { + AXIS2_FREE(env->allocator, tmp_content_type); + return NULL; + } + + tmp2 = axutil_strdup(env, tmp + 1); + + AXIS2_FREE(env->allocator, tmp_content_type); + if(*tmp2 == AXIS2_DOUBLE_QUOTE) + { + tmp = tmp2; + tmp2 = axutil_strdup(env, tmp + 1); + tmp2[strlen(tmp2) - 1] = AXIS2_ESC_NULL; + if(tmp) + { + AXIS2_FREE(env->allocator, tmp); + tmp = NULL; + } + + } + /* handle XOP */ + if(*tmp2 == AXIS2_B_SLASH && *(tmp2 + 1) == '\"') + { + tmp = tmp2; + tmp2 = axutil_strdup(env, tmp + 2); + tmp2[strlen(tmp2) - 3] = AXIS2_ESC_NULL; + if(tmp) + { + AXIS2_FREE(env->allocator, tmp); + tmp = NULL; + } + } + return tmp2; +} + +AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL +axis2_http_transport_utils_handle_media_type_url_encoded( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axutil_hash_t * param_map, + axis2_char_t * method) +{ + axiom_soap_envelope_t *soap_env = NULL; + axiom_soap_body_t *soap_body = NULL; + axiom_element_t *body_child = NULL; + axiom_node_t *body_child_node = NULL; + axiom_node_t *body_element_node = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); + AXIS2_PARAM_CHECK(env->error, method, NULL); + + soap_env = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + if(!soap_env) + { + soap_env = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); + } + soap_body = axiom_soap_envelope_get_body(soap_env, env); + if(!soap_body) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, AXIS2_FAILURE); + return NULL; + } + + body_element_node = axiom_soap_body_get_base_node(soap_body, env); + + if(body_element_node) + { + body_child_node = axiom_node_get_first_child(body_element_node, env); + } + + if(!body_child_node) + { + if(!axis2_msg_ctx_get_op(msg_ctx, env)) + { + return NULL; + } + body_child = axiom_element_create_with_qname(env, NULL, axis2_op_get_qname( + axis2_msg_ctx_get_op(msg_ctx, env), env), &body_child_node); + axiom_soap_body_add_child(soap_body, env, body_child_node); + } + if(param_map) + { + axutil_hash_index_t *hi = NULL; + for(hi = axutil_hash_first(param_map, env); hi; hi = axutil_hash_next(env, hi)) + { + void *name = NULL; + void *value = NULL; + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + + axutil_hash_this(hi, (const void **)&name, NULL, (void **)&value); + element = axiom_element_create(env, NULL, (axis2_char_t *)name, NULL, &node); + axiom_element_set_text(element, env, (axis2_char_t *)value, node); + axiom_node_add_child(body_child_node, env, node); + } + } + return soap_env; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_transport_utils_dispatch_and_verify( + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_disp_t *rest_disp = NULL; + axis2_handler_t *handler = NULL; + + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + if(axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + rest_disp = axis2_rest_disp_create(env); + handler = axis2_disp_get_base(rest_disp, env); + axis2_handler_invoke(handler, env, msg_ctx); + + if(!axis2_msg_ctx_get_svc(msg_ctx, env) || !axis2_msg_ctx_get_op(msg_ctx, env)) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SVC_OR_OP_NOT_FOUND, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + return AXIS2_SUCCESS; +} + +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) +{ + axutil_array_list_t *accept_field_list = NULL; + axutil_array_list_t *accept_record_list = NULL; + accept_field_list = axutil_tokenize(env, accept_value, ','); + if(accept_field_list && axutil_array_list_size(accept_field_list, env) > 0) + { + axis2_char_t *token = NULL; + accept_record_list = axutil_array_list_create(env, axutil_array_list_size( + accept_field_list, env)); + do + { + if(token) + { + axis2_http_accept_record_t *rec = NULL; + rec = axis2_http_accept_record_create(env, token); + if(rec) + { + axutil_array_list_add(accept_field_list, env, rec); + } + AXIS2_FREE(env->allocator, token); + } + token = (axis2_char_t *)axutil_array_list_remove(accept_field_list, env, 0); + } + while(token); + } + if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0) + { + return accept_record_list; + } + return NULL; +} + +int +axis2_http_transport_utils_check_status_code( + int status_code) +{ + int status = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + switch(status_code) + { + case AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_CONTINUE_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_ACK_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_MOVED_PERMANENTLY_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_MULTIPLE_CHOICES_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_SEE_OTHER_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_TEMPORARY_REDIRECT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_GONE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_GONE_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL: + status = AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL; + break; + } + return status; +} + +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) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_msg_ctx_t *msg_ctx = NULL; + axutil_stream_t *out_stream = NULL; + axutil_string_t *soap_action = NULL; + axis2_bool_t processed = AXIS2_FALSE; + axis2_char_t *body_string = NULL; + axis2_char_t *ctx_uuid = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_char_t *peer_ip = NULL; + axutil_property_t *peer_property = NULL; + axis2_msg_ctx_t *out_msg_ctx = NULL; + axis2_msg_ctx_t **msg_ctx_map = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, request, AXIS2_CRITICAL_FAILURE); + AXIS2_PARAM_CHECK(env->error, request->request_uri, AXIS2_FALSE); + + if(!conf_ctx) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_CONFIGURATION_CONTEXT, AXIS2_FAILURE); + return AXIS2_CRITICAL_FAILURE; + } + + if(!request->content_type) + { + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_PLAIN; + } + + /** creating the out stream */ + out_stream = axutil_stream_create_basic(env); + + if(request->transfer_encoding) + axis2_msg_ctx_set_transfer_encoding(request->msg_ctx, env, request->transfer_encoding); + + axis2_msg_ctx_set_server_side(request->msg_ctx, env, AXIS2_TRUE); + msg_ctx = request->msg_ctx; + peer_ip = request->remote_ip; + + if(peer_ip) + { + peer_property = axutil_property_create(env); + axutil_property_set_value(peer_property, env, axutil_strdup(env, peer_ip)); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_SVR_PEER_IP_ADDR, peer_property); + } + + axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream); + + ctx_uuid = axutil_uuid_gen(env); + if(ctx_uuid) + { + axutil_string_t *uuid_str = axutil_string_create_assume_ownership(env, &ctx_uuid); + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, uuid_str); + axutil_string_free(uuid_str, env); + } + + axis2_msg_ctx_set_out_transport_info(msg_ctx, env, + &(request->out_transport_info->out_transport)); + + if(request->accept_header) + { + axutil_array_list_t *accept_record_list = NULL; + accept_record_list = axis2_http_transport_utils_process_accept_headers(env, + request->accept_header); + if(accept_record_list && axutil_array_list_size(accept_record_list, env) > 0) + { + axis2_msg_ctx_set_http_accept_record_list(msg_ctx, env, accept_record_list); + } + } + if(request->accept_charset_header) + { + axutil_array_list_t *accept_charset_record_list = NULL; + accept_charset_record_list = axis2_http_transport_utils_process_accept_headers(env, + request->accept_charset_header); + if(accept_charset_record_list) + { + axis2_msg_ctx_set_http_accept_charset_record_list(msg_ctx, env, + accept_charset_record_list); + } + } + if(request->accept_language_header) + { + axutil_array_list_t *accept_language_record_list = NULL; + accept_language_record_list = axis2_http_transport_utils_process_accept_headers(env, + request->accept_language_header); + if(accept_language_record_list) + { + axis2_msg_ctx_set_http_accept_language_record_list(msg_ctx, env, + accept_language_record_list); + } + } + + if(request->soap_action) + { + soap_action = axutil_string_create(env, request->soap_action); + } + + if(request->request_method == AXIS2_HTTP_METHOD_GET || request->request_method + == AXIS2_HTTP_METHOD_DELETE || request->request_method == AXIS2_HTTP_METHOD_HEAD) + { + + if(request->request_method == AXIS2_HTTP_METHOD_DELETE) + { + processed = axis2_http_transport_utils_process_http_delete_request(env, + request->msg_ctx, request->in_stream, out_stream, request->content_type, + soap_action, request->request_uri, conf_ctx, + axis2_http_transport_utils_get_request_params(env, request->request_uri)); + } + else if(request->request_method == AXIS2_HTTP_METHOD_HEAD) + { + processed = axis2_http_transport_utils_process_http_head_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, soap_action, + request->request_uri, conf_ctx, axis2_http_transport_utils_get_request_params(env, + request->request_uri)); + } + else if(request->request_method == AXIS2_HTTP_METHOD_GET) + { + processed = axis2_http_transport_utils_process_http_get_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, soap_action, + request->request_uri, conf_ctx, axis2_http_transport_utils_get_request_params(env, + request->request_uri)); + } + if(AXIS2_FALSE == processed) + { + axis2_bool_t is_services_path = AXIS2_FALSE; + int msg_ctx_status_code = axis2_msg_ctx_get_status_code(msg_ctx, env); + if(request->request_method != AXIS2_HTTP_METHOD_DELETE && request->request_url_prefix) + { + axis2_char_t *temp = NULL; + temp = strstr(request->request_uri, request->request_url_prefix); + if(temp) + { + temp += strlen(request->request_url_prefix); + if(*temp == '/') + { + temp++; + } + if(!*temp || *temp == '?' || *temp == '#') + { + is_services_path = AXIS2_TRUE; + } + } + } + if(is_services_path) + { + body_string = axis2_http_transport_utils_get_services_html(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + response->http_status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + } + else if(AXIS2_HTTP_METHOD_DELETE != request->request_method) + { + axis2_char_t *wsdl = NULL; + wsdl = strstr(request->request_uri, AXIS2_REQUEST_WSDL); + if(wsdl) + { + body_string = axis2_http_transport_utils_get_services_static_wsdl(env, + conf_ctx, request->request_uri); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + response->http_status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + } + } + else if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + + if(method_list && size) + { + /** 405 */ + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + + response->http_status_code = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME; + } + else + { + /** 404 */ + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME; + } + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL) + { + /* 400, Bad Request */ + body_string = axis2_http_transport_utils_get_bad_request(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_BAD_REQUEST_CODE_NAME; + + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL) + { + /* 408, Request Timeout */ + body_string = axis2_http_transport_utils_get_request_timeout(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_REQUEST_TIMEOUT_CODE_NAME; + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL) + { + /* 409, Conflict Types */ + body_string = axis2_http_transport_utils_get_conflict(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_CONFLICT_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_CONFLICT_CODE_NAME; + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_GONE_CODE_VAL) + { + /* 410, Gone. Resource no longer available */ + body_string = axis2_http_transport_utils_get_gone(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_GONE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_GONE_CODE_NAME; + + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL) + { + /*410, Precondition for the url failed */ + body_string = axis2_http_transport_utils_get_precondition_failed(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_PRECONDITION_FAILED_CODE_NAME; + + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL) + { + /* 413, Request entity too large */ + body_string + = axis2_http_transport_utils_get_request_entity_too_large(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_REQUEST_ENTITY_TOO_LARGE_CODE_NAME; + } + else if(msg_ctx_status_code == AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL) + { + /* 513, Service Unavailable */ + body_string = axis2_http_transport_utils_get_service_unavailable(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_SERVICE_UNAVAILABLE_CODE_NAME; + } + else + { + /* 500, Internal Server Error */ + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME; + } + + if(body_string) + { + response->response_data = body_string; + response->response_data_length = axutil_strlen(body_string); + } + status = AXIS2_SUCCESS; + } + } + else if(AXIS2_HTTP_METHOD_POST == request->request_method || AXIS2_HTTP_METHOD_PUT + == request->request_method) + { + if(AXIS2_HTTP_METHOD_POST == request->request_method) + { + processed = axis2_http_transport_utils_process_http_post_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, request->content_length, + soap_action, request->request_uri); + } + else + { + processed = axis2_http_transport_utils_process_http_put_request(env, request->msg_ctx, + request->in_stream, out_stream, request->content_type, request->content_length, + soap_action, request->request_uri); + } + if(AXIS2_FAILURE == processed && (AXIS2_HTTP_METHOD_PUT == request->request_method + || axis2_msg_ctx_get_doing_rest(msg_ctx, env))) + { + + if(env->error->error_number == AXIS2_ERROR_SVC_OR_OP_NOT_FOUND) + { + axutil_array_list_t *method_list = NULL; + int size = 0; + method_list = axis2_msg_ctx_get_supported_rest_http_methods(msg_ctx, env); + size = axutil_array_list_size(method_list, env); + if(method_list && size) + { + /** 405 */ + body_string = axis2_http_transport_utils_get_method_not_allowed(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_METHOD_NOT_ALLOWED_CODE_NAME; + } + else + { + /** 404 */ + body_string = axis2_http_transport_utils_get_not_found(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_FOUND_CODE_NAME; + } + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + } + else + { + /* 500, Internal Server Error */ + body_string = axis2_http_transport_utils_get_internal_server_error(env, conf_ctx); + response->http_status_code = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL; + response->http_status_code_name + = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME; + + } + + if(body_string) + { + response->response_data = body_string; + response->response_data_length = axutil_strlen(body_string); + } + status = AXIS2_SUCCESS; + } + else if(processed == AXIS2_FAILURE) + { + axis2_msg_ctx_t *fault_ctx = NULL; + axis2_char_t *fault_code = NULL; + axis2_engine_t *engine = axis2_engine_create(env, conf_ctx); + if(!engine) + { + /* Critical error, cannot proceed, send defaults document for 500 */ + return AXIS2_CRITICAL_FAILURE; + } + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP11_FAULT_CODE_SENDER; + } + else + { + fault_code = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" + AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER; + } + fault_ctx = axis2_engine_create_fault_msg_ctx(engine, env, request->msg_ctx, + fault_code, axutil_error_get_message(env->error)); + + axis2_engine_send_fault(engine, env, fault_ctx); + if (out_stream) + { + response->response_data = axutil_stream_get_buffer(out_stream, env); + response->response_data_length = axutil_stream_get_len (out_stream, env); + } + /* In case of a SOAP Fault, we have to set the status to 500, but still return */ + status = AXIS2_SUCCESS; + response->http_status_code = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_NAME; + } + } + else + { + response->response_data = axis2_http_transport_utils_get_not_implemented(env, conf_ctx); + request->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (response->response_data) + { + response->response_data_length = axutil_strlen(response->response_data); + } + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME; + status = AXIS2_SUCCESS; + } + + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + + if (op_ctx) + { + msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); + out_msg_ctx = msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_OUT]; + response->msg_ctx = out_msg_ctx; + } + + if (status == AXIS2_FAILURE) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (AXIS2_HTTP_METHOD_POST != request->request_method || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + if ((request->accept_header || request->accept_charset_header || + request->accept_language_header) && do_rest) + { + axis2_char_t *content_type_header_value = NULL; + axis2_char_t *temp = NULL; + axis2_char_t *language_header_value = NULL; + + content_type_header_value = (axis2_char_t *) request->content_type; + language_header_value = axis2_msg_ctx_get_content_language(out_msg_ctx,env); + if (content_type_header_value) + { + temp = axutil_strdup(env, content_type_header_value); + } + if (temp) + { + axis2_char_t *content_type = NULL; + axis2_char_t *char_set = NULL; + axis2_char_t *temp2 = NULL; + + temp2 = strchr(temp, ';'); + if (temp2) + { + *temp2 = '\0'; + temp2++; + char_set = axutil_strcasestr(temp2, AXIS2_HTTP_CHAR_SET_ENCODING); + } + if (char_set) + { + char_set = axutil_strltrim(env, char_set, " \t="); + } + if (char_set) + { + temp2 = strchr(char_set, ';'); + } + if (temp2) + { + *temp2 = '\0'; + } + content_type = axutil_strtrim(env, temp, NULL); + + if (temp) + { + AXIS2_FREE(env->allocator, temp); + temp = NULL; + } + if (content_type && request->accept_header && + !axutil_strcasestr(request->accept_header, content_type)) + { + temp2 = strchr(content_type, '/'); + if (temp2) + { + *temp2 = '\0'; + temp = AXIS2_MALLOC(env->allocator, + sizeof(axis2_char_t) * ((int)strlen(content_type) + 3)); + if (!temp) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FALSE; + } + sprintf(temp, "%s/*", content_type); + if (!axutil_strcasestr(request->accept_header, temp) && + !strstr(request->accept_header, AXIS2_HTTP_HEADER_ACCEPT_ALL)) + { + response->response_data = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + if (response->response_data) + { + response->response_data_length = axutil_strlen(response->response_data); + } + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_IMPLEMENTED_CODE_NAME; + status = AXIS2_TRUE; + } + AXIS2_FREE(env->allocator, temp); + } + } + if (content_type) + { + AXIS2_FREE(env->allocator, content_type); + } + if (char_set && request->accept_charset_header && + !axutil_strcasestr(request->accept_charset_header , char_set)) + { + response->response_data = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + + if (response->response_data) + { + response->response_data_length= axutil_strlen(response->response_data); + } + status = AXIS2_SUCCESS; + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME; + } + if (char_set) + { + AXIS2_FREE(env->allocator, char_set); + } + } + if (language_header_value) + { + if (request->accept_language_header && + !axutil_strcasestr(request->accept_language_header , language_header_value)) + { + response->response_data = + axis2_http_transport_utils_get_not_acceptable(env, conf_ctx); + response->content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_HTML; + if (response->response_data) + { + response->response_data_length = axutil_strlen(response->response_data); + } + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_NOT_ACCEPTABLE_CODE_NAME; + } + } + } + } + if (status == AXIS2_FAILURE) + { + axis2_bool_t do_rest = AXIS2_FALSE; + if (AXIS2_HTTP_METHOD_POST != request->request_method || + axis2_msg_ctx_get_doing_rest(msg_ctx, env)) + { + do_rest = AXIS2_TRUE; + } + if (op_ctx && axis2_op_ctx_get_response_written(op_ctx, env)) + { + if (do_rest) + { + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + response->output_headers = output_header_list; + } + + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + response->http_status_code = + axis2_http_transport_utils_check_status_code(status_code); + status = AXIS2_SUCCESS; + } + } + } + if (status == AXIS2_FAILURE) + { + status = AXIS2_SUCCESS; + if (out_stream) + { + response->response_data = axutil_stream_get_buffer(out_stream, env); + response->response_data_length = axutil_stream_get_len(out_stream, env); + response->http_status_code = AXIS2_HTTP_RESPONSE_OK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_OK_CODE_NAME; + } + } + } + else if (op_ctx) + { + if (do_rest) + { + if (out_msg_ctx) + { + int size = 0; + axutil_array_list_t *output_header_list = NULL; + output_header_list = axis2_msg_ctx_get_http_output_headers(out_msg_ctx, env); + if (output_header_list) + { + size = axutil_array_list_size(output_header_list, env); + response->output_headers = output_header_list; + } + if (axis2_msg_ctx_get_no_content(out_msg_ctx, env)) + { + if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + switch (status_code) + { + case AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL: + response->http_status_code = AXIS2_HTTP_RESPONSE_RESET_CONTENT_CODE_VAL; + break; + case AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL: + response->http_status_code = AXIS2_HTTP_RESPONSE_NOT_MODIFIED_CODE_VAL; + break; + default: + response->http_status_code = AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL; + break; + } + } + else + { + response->http_status_code = AXIS2_HTTP_RESPONSE_NO_CONTENT_CODE_VAL; + } + status = AXIS2_SUCCESS; + } + else if (axis2_msg_ctx_get_status_code(out_msg_ctx, env)) + { + int status_code = axis2_msg_ctx_get_status_code(out_msg_ctx, env); + response->http_status_code = + axis2_http_transport_utils_check_status_code(status_code); + status = AXIS2_SUCCESS; + } + } + } + if (status == AXIS2_FAILURE) + { + response->http_status_code = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_ACK_CODE_NAME; + status = AXIS2_SUCCESS; + } + } + else + { + status = AXIS2_SUCCESS; + response->http_status_code = AXIS2_HTTP_RESPONSE_ACK_CODE_VAL; + response->http_status_code_name = AXIS2_HTTP_RESPONSE_ACK_CODE_NAME; + } + } + axutil_string_free(soap_action, env); + msg_ctx = NULL; + + return status; +} + +/* This method takes an array_list as the input. It has items some + may be buffers and some may be files. This will send these part + one by one to the wire using the chunked stream.*/ +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) +{ + int i = 0; + axis2_status_t status = AXIS2_SUCCESS; + + for(i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + + /* If it is a buffer just write it to the wire. This includes mime_bounadaries, + * mime_headers and SOAP */ + if(mime_part->type == AXIOM_MIME_PART_BUFFER) + { + size_t written = 0; + while(written < mime_part->part_size) + { + int len = 0; + len = axutil_http_chunked_stream_write(chunked_stream, env, + mime_part->part + written, mime_part->part_size - written); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + else + { + written += len; + } + } + } + + /* If it is a file we load a very little portion to memory and send it as chunked , + * we keep on doing this until we find the end of the file */ + else if(mime_part->type == AXIOM_MIME_PART_FILE) + { + FILE *f = NULL; + axis2_byte_t *output_buffer = NULL; + int output_buffer_size = 0; + + f = fopen(mime_part->file_name, "rb"); + if(!f) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error opening file %s for reading", + mime_part->file_name); + return AXIS2_FAILURE; + } + + /* If the part_size is less than the defined buffer size then + * from the first write to the wire we can send the file */ + if(mime_part->part_size > AXIS2_MTOM_OUTPUT_BUFFER_SIZE) + { + output_buffer_size = AXIS2_MTOM_OUTPUT_BUFFER_SIZE; + } + else + { + output_buffer_size = (int)mime_part->part_size; + } + + output_buffer = AXIS2_MALLOC(env->allocator, output_buffer_size * sizeof(axis2_char_t)); + + /*This is the method responsible for writing to the wire */ + status = axis2_http_transport_utils_send_attachment_using_file(env, chunked_stream, + f, output_buffer, output_buffer_size); + AXIS2_FREE(env->allocator, output_buffer); + fclose(f); + } + + /* if the callback is given, send data using callback */ + else if((mime_part->type) == AXIOM_MIME_PART_CALLBACK) + { + void *handler = NULL; + axiom_mtom_sending_callback_t *callback = NULL; + + handler = axis2_http_transport_utils_initiate_callback(env, sending_callback_name, + mime_part->user_param, &callback); + if(handler) + { + status = axis2_http_transport_utils_send_attachment_using_callback(env, + chunked_stream, callback, handler, mime_part->user_param); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "MTOM Sending Callback loading failed"); + status = AXIS2_FAILURE; + } + + if(callback) + { + axutil_param_t *param = NULL; + param = callback->param; + AXIOM_MTOM_SENDING_CALLBACK_FREE(callback, env); + if(param) + { + axutil_param_free(param, env); + } + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unknown mime_part."); + status = AXIS2_FAILURE; + } + + if(status != AXIS2_SUCCESS) + { + break; + } + } + + if(status == AXIS2_SUCCESS) + { + /* send the end of chunk */ + status = axutil_http_chunked_stream_write_last_chunk(chunked_stream, env); + } + + return status; +} + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_file( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + FILE *fp, + axis2_byte_t *buffer, + int buffer_size) +{ + /*We do not load the whole file to memory. Just load a buffer_size portion + *and send it. Keep on doing this until the end of file */ + do + { + int written = 0; + int count = (int)fread(buffer, 1, buffer_size, fp); + if(ferror(fp) || (count < 0)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Error in reading file containing the attachment"); + return AXIS2_FAILURE; + } + + /* count == 0 is a valid case. If the file size is multiple of buffer_size, then last read + * will have count == 0 + */ + + /*Writing the part we loaded to memory to the wire*/ + while(written < count) + { + int len = axutil_http_chunked_stream_write(chunked_stream, env, + buffer + written, count - written); + if(len == -1) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "error in writing file to stream"); + return AXIS2_FAILURE; + } + + written += len; + } + } + while(!feof(fp)); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_destroy_mime_parts( + axutil_array_list_t *mime_parts, + const axutil_env_t *env) +{ + if (mime_parts) + { + int i = 0; + for (i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *) + axutil_array_list_get(mime_parts, env, i); + if (mime_part) + { + axiom_mime_part_free(mime_part, env); + } + } + axutil_array_list_free(mime_parts, 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) +{ + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + void *ptr = NULL; + + if(!callback_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "invalid callback name given"); + return NULL; + } + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Trying to load module = %s", callback_name); + + dll_desc = axutil_dll_desc_create(env); + axutil_dll_desc_set_name(dll_desc, env, callback_name); + impl_info_param = axutil_param_create(env, NULL, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + ptr = axutil_class_loader_create_dll(env, impl_info_param); + if (!ptr) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to load the module %s.", callback_name); + return NULL; + } + + *callback = (axiom_mtom_sending_callback_t *)ptr; + (*callback)->param = impl_info_param; + + return AXIOM_MTOM_SENDING_CALLBACK_INIT_HANDLER(*callback, env, user_param); +} + +static axis2_status_t +axis2_http_transport_utils_send_attachment_using_callback( + const axutil_env_t * env, + axutil_http_chunked_stream_t *chunked_stream, + axiom_mtom_sending_callback_t *callback, + void *handler, + void *user_param) +{ + int count = 0; + axis2_status_t status = AXIS2_SUCCESS; + axis2_char_t *buffer = NULL; + + /* Keep on loading the data in a loop until all the data is sent */ + while((count = AXIOM_MTOM_SENDING_CALLBACK_LOAD_DATA(callback, env, handler, &buffer)) > 0) + { + int written = 0; + while(written < count) + { + int len = 0; + len = axutil_http_chunked_stream_write(chunked_stream, env, + buffer + written, count - written); + if(len == -1) + { + status = AXIS2_FAILURE; + break; + } + + written += len; + } + } + + status = AXIOM_MTOM_SENDING_CALLBACK_CLOSE_HANDLER(callback, env, handler) && status; + return status; +} + +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) +{ + int size = 0; + int i = 0; + axis2_bool_t is_required = AXIS2_FALSE; + + size = axutil_array_list_size(mime_parts, env); + for(i = 0; i < size; i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + if(mime_part) + { + if(mime_part->type == AXIOM_MIME_PART_CALLBACK) + { + is_required = AXIS2_TRUE; + break; + } + } + } + + return is_required; +} + +static void +axis2_http_transport_utils_parse_session_str(const axutil_env_t *env, axis2_char_t *str, + axutil_hash_t *ht) +{ + while (*str) + { + axis2_char_t *next = axutil_strstr(str, ";"); + if (next) + { + axis2_char_t *key = NULL; + axis2_char_t *val = NULL; + + + /* Get key and value pairs */ + key = axis2_http_transport_utils_copy_key(env, str); + val = axis2_http_transport_utils_copy_value(env, str); + axutil_hash_set(ht, key, AXIS2_HASH_KEY_STRING, val); + + /* find next token */ + str = next + 1; + } + + } +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_transport_utils_get_session( + const axutil_env_t *env, + axis2_msg_ctx_t *msg_ctx) +{ + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + axutil_hash_t *ht = NULL; + axis2_char_t *session_id = NULL; + axis2_char_t *time_str = NULL; + axis2_char_t *header_value = NULL; + axutil_date_time_t *expire_time = NULL; + axis2_char_t session_value[256]; + axis2_http_out_transport_info_t *out_info = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_utils_get_session"); + ht = axis2_msg_ctx_get_property_value(msg_ctx, env, AXIS2_TRANSPORT_SESSION_TABLE); + if(!ht) + { + axis2_op_ctx_t *op_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + if(op_ctx) + { + in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); + if(in_msg_ctx) + { + ht = axis2_msg_ctx_get_property_value(in_msg_ctx, env, + AXIS2_TRANSPORT_SESSION_TABLE); + } + } + if(!ht) + { + return NULL; + } + } + session_id = axutil_hash_get(ht, "id", AXIS2_HASH_KEY_STRING); + if(!session_id) + { + /* Generate session and set it in session table */ + session_id = axutil_uuid_gen(env); + axutil_hash_set(ht, axutil_strdup(env, "id"), AXIS2_HASH_KEY_STRING, axutil_strdup(env, + session_id)); + + /* Generate expire time and set it in session table */ + expire_time = axutil_date_time_create_with_offset(env, AXIS2_TRANSPORT_SESSION_EXPIRE_DURATION); + time_str = axutil_strdup(env, axutil_date_time_serialize_date_time(expire_time, env)); + axutil_date_time_free(expire_time, env); + axutil_hash_set(ht, axutil_strdup(env, "expires"), AXIS2_HASH_KEY_STRING, time_str); + + sprintf(session_value, "%s", ""); + + for(hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + int len = -1; + + axutil_hash_this(hi, &key, NULL, &val); + name = (axis2_char_t *) key; + value = (axis2_char_t *) val; + if(name) + { + len = axutil_strlen(session_value); + sprintf(session_value + len, "%s=", name); + AXIS2_FREE(env->allocator, name); + } + if(value) + { + len = axutil_strlen(session_value); + sprintf(session_value + len, "%s;", value); + AXIS2_FREE(env->allocator, value); + } + } + + out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info( + msg_ctx, env); + if(!out_info) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, header_value); + return NULL; + } + status = AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_SESSION(out_info, env, session_id, session_value); + if(status != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Inserting session value failed for session id %s", session_id); + return NULL; + } + } + else + { + time_str = axutil_hash_get(ht, "expires", AXIS2_HASH_KEY_STRING); + } + header_value = AXIS2_MALLOC(env->allocator, 256 * sizeof(axis2_char_t)); + sprintf(header_value, "ID=%s; expires=%s;", session_id, time_str); + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_utils_get_session"); + return header_value; +} + +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) +{ + axutil_date_time_t *expire_time = NULL; + axutil_date_time_t *current_time = NULL; + axutil_date_time_comp_result_t result; + axis2_char_t *time_str = NULL; + axutil_hash_t *ht = NULL; + axutil_property_t *property = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_tranpsport_utils_set_session"); + + /* Check whether session has expired. If so set error and return */ + ht = axutil_hash_make(env); + axis2_http_transport_utils_parse_session_str(env, session_str, ht); + time_str = (axis2_char_t *) axutil_hash_get(ht, "time", AXIS2_HASH_KEY_STRING); + expire_time = axutil_date_time_create(env); + axutil_date_time_deserialize_date_time(expire_time, env, time_str); + current_time = axutil_date_time_create(env); + result = axutil_date_time_compare(current_time, env, expire_time); + axutil_date_time_free(current_time, env); + axutil_date_time_free(expire_time, env); + if(result == AXIS2_DATE_TIME_COMP_RES_EXPIRED) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + const void *key = NULL; + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Session time out"); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SESSION_TIMEOUT, AXIS2_FAILURE); + for(hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + name = (axis2_char_t *) key; + if(name) + { + AXIS2_FREE(env->allocator, name); + } + value = (axis2_char_t *) val; + if(value) + { + AXIS2_FREE(env->allocator, value); + } + } + axutil_hash_free(ht, env); + } + + property = axutil_property_create_with_args(env, 0, AXIS2_TRUE, 0, ht); + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_SESSION_TABLE, property); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_tranpsport_utils_set_session"); +} + +/** + * After receiving Set-Cookie header store it + */ +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) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axutil_property_t *property = NULL; + axutil_hash_t *session_map = NULL; + axis2_endpoint_ref_t *endpoint = NULL; + const axis2_char_t *address = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_utils_store_cookie"); + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_TRANSPORT_SESSION_MAP); + if(property) + { + session_map = axutil_property_get_value(property, env); + } + if(!session_map) + { + if(!cookie) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "No session map found and no cookie set. So return"); + return; + } + session_map = axutil_hash_make(env); + if(session_map) + { + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 1, + axis2_http_transport_utils_session_map_free_void_arg, session_map); + axis2_conf_ctx_set_property(conf_ctx, env, AXIS2_TRANSPORT_SESSION_MAP, property); + } + else + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return; + } + } + endpoint = axis2_msg_ctx_get_to(msg_ctx, env); + if(endpoint) + { + address = axis2_endpoint_ref_get_address(endpoint, env); + if(address) + { + axutil_url_t *url = NULL; + + url = axutil_url_parse_string(env, address); + if(url) + { + axis2_char_t *server = NULL; + server = axutil_url_get_server(url, env); + if(server) + { + if(cookie) + { + axutil_hash_set(session_map, axutil_strdup(env, server), AXIS2_HASH_KEY_STRING, + axutil_strdup(env, cookie)); + } + else /* We remove any cookie set for this endpoint */ + { + cookie = axutil_hash_get(session_map, server, AXIS2_HASH_KEY_STRING); + if(cookie) + { + AXIS2_FREE(env->allocator, cookie); + } + axutil_hash_set(session_map, axutil_strdup(env, server), AXIS2_HASH_KEY_STRING, NULL); + } + } + axutil_url_free(url, env); + } + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_utils_store_cookie"); +} + +/* Read from cookie store before sending */ +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) +{ + axutil_property_t *property = NULL; + axutil_hash_t *session_map = NULL; + axis2_endpoint_ref_t *endpoint = NULL; + const axis2_char_t *address = NULL; + axis2_char_t *cookie = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_utils_read_from_cookie_store"); + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + property = axis2_conf_ctx_get_property(conf_ctx, env, AXIS2_TRANSPORT_SESSION_MAP); + if(property) + { + session_map = axutil_property_get_value(property, env); + } + if(!session_map) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No session map stored"); + return NULL; + } + endpoint = axis2_msg_ctx_get_to(msg_ctx, env); + if(endpoint) + { + address = axis2_endpoint_ref_get_address(endpoint, env); + if(address) + { + axutil_url_t *url = NULL; + url = axutil_url_parse_string(env, address); + if(url) + { + axis2_char_t *server = NULL; + server = axutil_url_get_server(url, env); + if(server) + { + cookie = axutil_hash_get(session_map, server, AXIS2_HASH_KEY_STRING); + } + axutil_url_free(url, env); + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "cookie:%s", cookie); + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_utils_read_from_cookie_store"); + return cookie; +} + +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) +{ + axis2_char_t *next = NULL; + axis2_char_t *session_id = NULL; + + next = axutil_strstr(cookie, ";"); + if (next) + { + session_id = axis2_http_transport_utils_copy_value(env, cookie); + } + + return session_id; +} + +static axis2_char_t * +axis2_http_transport_utils_copy_key( + const axutil_env_t *env, + axis2_char_t *pair) +{ + axis2_char_t *p = axutil_strchr(pair, '='); + axis2_char_t *ret = NULL; + + if (p) + { + axis2_char_t c; + size_t len = p - pair; + c = pair[len]; + pair[len] = '\0'; + ret = axutil_strdup(env, pair); + pair[len] = c; + } + + return ret; +} + +static axis2_char_t * +axis2_http_transport_utils_copy_value( + const axutil_env_t *env, + axis2_char_t *pair) +{ + axis2_char_t *ret = NULL; + size_t len; + axis2_char_t c; + + pair = axutil_strchr(pair, '='); + if (pair) + { + pair++; + len = axutil_strchr(pair, ';') - pair; + c = pair[len]; + pair[len] = '\0'; + ret = axutil_strdup(env, pair); + pair[len] = c; + } + + return ret; +} + + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_transport_utils_session_map_free_void_arg( + void *sm_void, + const axutil_env_t *env) +{ + void *val = NULL; + const void *key = NULL; + axutil_hash_index_t *hi = NULL; + axutil_hash_t *ht = (axutil_hash_t *)sm_void; + + for(hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + + axutil_hash_this(hi, &key, NULL, &val); + name = (axis2_char_t *) key; + if(name) + { + AXIS2_FREE(env->allocator, name); + } + value = (axis2_char_t *) val; + if(value) + { + AXIS2_FREE(env->allocator, value); + } + } + axutil_hash_free(ht, env); +} + + diff --git a/src/core/transport/tcp/Makefile.am b/src/core/transport/tcp/Makefile.am new file mode 100644 index 0000000..79f45b7 --- /dev/null +++ b/src/core/transport/tcp/Makefile.am @@ -0,0 +1,3 @@ +SUBDIRS = sender receiver server +EXTRA_DIST=axis2_simple_tcp_svr_conn.h axis2_tcp_svr_thread.h axis2_tcp_transport_sender.h axis2_tcp_server.h axis2_tcp_transport.h axis2_tcp_worker.h + diff --git a/src/core/transport/tcp/axis2_simple_tcp_svr_conn.h b/src/core/transport/tcp/axis2_simple_tcp_svr_conn.h new file mode 100644 index 0000000..c0d3b89 --- /dev/null +++ b/src/core/transport/tcp/axis2_simple_tcp_svr_conn.h @@ -0,0 +1,155 @@ + +/* + * 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 + * + * tcp://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_tcp + * @{ + */ + +/** + * @file axis2_simple_tcp_svr_conn.h + * @brief Axis2 simple tcp server connection + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_simple_tcp_svr_conn axis2_simple_tcp_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_tcp_svr_conn_close( + axis2_simple_tcp_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_tcp_svr_conn_is_open( + axis2_simple_tcp_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_tcp_svr_conn_get_stream( + const axis2_simple_tcp_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_tcp_svr_conn_read_request( + axis2_simple_tcp_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 timeout timeout + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_simple_tcp_svr_conn_set_rcv_timeout( + axis2_simple_tcp_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_tcp_svr_conn_set_snd_timeout( + axis2_simple_tcp_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_tcp_svr_conn_get_svr_ip( + const axis2_simple_tcp_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_tcp_svr_conn_get_peer_ip( + const axis2_simple_tcp_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_tcp_svr_conn_free( + axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env); + + /** + * creates axis2_simple_tcp_svr_conn struct + * @param env pointer to environment struct + * @param sockfd sockfd + */ + AXIS2_EXTERN axis2_simple_tcp_svr_conn_t *AXIS2_CALL + + axis2_simple_tcp_svr_conn_create( + const axutil_env_t * env, + int sockfd); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_SIMPLE_HTTP_SVR_CONN_H */ diff --git a/src/core/transport/tcp/axis2_tcp_server.h b/src/core/transport/tcp/axis2_tcp_server.h new file mode 100644 index 0000000..e4557a1 --- /dev/null +++ b/src/core/transport/tcp/axis2_tcp_server.h @@ -0,0 +1,60 @@ + +/* +* 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_TCP_SERVER_H +#define AXIS2_TCP_SERVER_H + +/** + * @defgroup axis2_tcp_server tcp server + * @ingroup axis2_core_trans_tcp + * @{ + */ + +/** + * @file axis2_tcp_server.h + * @brief axis2 TCP Server implementation + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN axis2_transport_receiver_t *AXIS2_CALL + axis2_tcp_server_create( + const axutil_env_t * env, + const axis2_char_t * repo, + const int port); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_tcp_server_stop( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_TCP_SERVER_H */ diff --git a/src/core/transport/tcp/axis2_tcp_svr_thread.h b/src/core/transport/tcp/axis2_tcp_svr_thread.h new file mode 100644 index 0000000..aa22ea1 --- /dev/null +++ b/src/core/transport/tcp/axis2_tcp_svr_thread.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_TCP_SVR_THREAD_H +#define AXIS2_TCP_SVR_THREAD_H + +/** + * @defgroup axis2_tcp_svr_thread tcp server thread + * @ingroup axis2_core_trans_tcp + * @{ + */ + +/** + * @file axis2_tcp_svr_thread.h + * @brief axis2 TCP server listning thread implementation + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axist_tcp_svr_thread */ + typedef struct axis2_tcp_svr_thread axis2_tcp_svr_thread_t; + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_tcp_svr_thread_run( + axis2_tcp_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_tcp_svr_thread_destroy( + axis2_tcp_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_tcp_svr_thread_get_local_port( + const axis2_tcp_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_tcp_svr_thread_is_running( + axis2_tcp_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_tcp_svr_thread_set_worker( + axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env, + axis2_tcp_worker_t * worker); + + /** + * @param svr_thread pointer to server thread + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_tcp_svr_thread_free( + axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param port + */ + AXIS2_EXTERN axis2_tcp_svr_thread_t *AXIS2_CALL + + axis2_tcp_svr_thread_create( + const axutil_env_t * env, + int port); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_TCP_SVR_THREAD_H */ diff --git a/src/core/transport/tcp/axis2_tcp_transport.h b/src/core/transport/tcp/axis2_tcp_transport.h new file mode 100644 index 0000000..9c8c7db --- /dev/null +++ b/src/core/transport/tcp/axis2_tcp_transport.h @@ -0,0 +1,89 @@ + +/* +* 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_TCP_TRANSPORT_H +#define AXIS2_TCP_TRANSPORT_H + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @defgroup axis2_core_trans_tcp tcp transport + * @ingroup axis2_transport + * Description. + * @{ + */ + + /** + * @defgroup axis2_core_transport_tcp core tcp transport + * @ingroup axis2_core_trans_tcp + * @{ + */ + + /** + * @brief TCP protocol and message context constants. + * + */ +#define AXIS2_TCP_OUT_TRANSPORT_INFO "TCPOutTransportInfo" + + /** + * PROTOCOL_VERSION + */ +#define AXIS2_TCP_PROTOCOL_VERSION "PROTOCOL" + + /** + * SOCKET + */ +#define AXIS2_SOCKET "SOCKET" + + /** + * HEADER_HOST + */ +#define AXIS2_TCP_HOST "Host" + + /** + * SO_TIMEOUT + */ +#define AXIS2_TCP_SO_TIMEOUT "SO_TIMEOUT" + + /** + * CONNECTION_TIMEOUT + */ +#define AXIS2_TCP_CONNECTION_TIMEOUT "CONNECTION_TIMEOUT" + + /** + * DEFAULT_SO_TIMEOUT + */ +#define AXIS2_TCP_DEFAULT_SO_TIMEOUT 60000 + + /** + * DEFAULT_CONNECTION_TIMEOUT + */ +#define AXIS2_TCP_DEFAULT_CONNECTION_TIMEOUT 60000 + + /** + * Field TRANSPORT_TCP + */ +#define AXIS2_TRANSPORT_TCP "tcp" + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_TCP_TRANSPORT_H */ diff --git a/src/core/transport/tcp/axis2_tcp_transport_sender.h b/src/core/transport/tcp/axis2_tcp_transport_sender.h new file mode 100644 index 0000000..9d706e5 --- /dev/null +++ b/src/core/transport/tcp/axis2_tcp_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_TCP_TRANSPORT_SENDER_H +#define AXIS2_TCP_TRANSPORT_SENDER_H + +/** + * @defgroup axis2_tcp_transport_sender tcp transport sender + * @ingroup axis2_core_trans_tcp + * @{ + */ + +/** + * @file axis2_tcp_transport_sender.h + * @brief axis2 TCP 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_tcp_transport_sender_create( + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_TCP_TRANSPORT_SENDER_H */ diff --git a/src/core/transport/tcp/axis2_tcp_worker.h b/src/core/transport/tcp/axis2_tcp_worker.h new file mode 100644 index 0000000..dcd74fc --- /dev/null +++ b/src/core/transport/tcp/axis2_tcp_worker.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 + * + * tcp://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_TCP_WORKER_H +#define AXIS2_TCP_WORKER_H + +/** + * @defgroup axis2_tcp_worker tcp worker + * @ingroup axis2_core_trans_tcp + * @{ + */ + +/** + * @file axis2_tcp_worker.h + * @brief axis2 TCP Worker + */ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_tcp_worker */ + typedef struct axis2_tcp_worker axis2_tcp_worker_t; + + /** + * @param tcp_worker pointer to tcp 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_tcp_worker_process_request( + axis2_tcp_worker_t * tcp_worker, + const axutil_env_t * env, + axis2_simple_tcp_svr_conn_t * svr_conn, + axis2_char_t * simple_request); + + /** + * @param tcp_worker pointer to tcp 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_tcp_worker_set_svr_port( + axis2_tcp_worker_t * tcp_worker, + const axutil_env_t * env, + int port); + + /** + * @param tcp_worker pointer to tcp worker + * @param env pointer to environment strut + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_tcp_worker_free( + axis2_tcp_worker_t * tcp_worker, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context + */ + AXIS2_EXTERN axis2_tcp_worker_t *AXIS2_CALL + axis2_tcp_worker_create( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_TCP_WORKER_H */ diff --git a/src/core/transport/tcp/receiver/Makefile.am b/src/core/transport/tcp/receiver/Makefile.am new file mode 100644 index 0000000..e3543dc --- /dev/null +++ b/src/core/transport/tcp/receiver/Makefile.am @@ -0,0 +1,23 @@ +lib_LTLIBRARIES = libaxis2_tcp_receiver.la +libaxis2_tcp_receiver_la_LIBADD=$(top_builddir)/util/src/libaxutil.la\ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la + + +libaxis2_tcp_receiver_la_SOURCES = tcp_svr_thread.c \ + tcp_worker.c \ + simple_tcp_svr_conn.c \ + tcp_receiver.c + + +libaxis2_tcp_receiver_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport\ + -I$(top_builddir)/src/core/transport/tcp \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/tcp/receiver/simple_tcp_svr_conn.c b/src/core/transport/tcp/receiver/simple_tcp_svr_conn.c new file mode 100644 index 0000000..a5fd9a9 --- /dev/null +++ b/src/core/transport/tcp/receiver/simple_tcp_svr_conn.c @@ -0,0 +1,181 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +struct axis2_simple_tcp_svr_conn +{ + int socket; + axutil_stream_t *stream; + axis2_char_t *buffer; +}; + +AXIS2_EXTERN axis2_simple_tcp_svr_conn_t *AXIS2_CALL +axis2_simple_tcp_svr_conn_create( + const axutil_env_t * env, + int sockfd) +{ + axis2_simple_tcp_svr_conn_t *svr_conn = NULL; + AXIS2_ENV_CHECK(env, NULL); + svr_conn = (axis2_simple_tcp_svr_conn_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_simple_tcp_svr_conn_t)); + + if(!svr_conn) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + svr_conn->socket = sockfd; + svr_conn->stream = NULL; + svr_conn->buffer = NULL; + + if(-1 != svr_conn->socket) + { + svr_conn->stream = axutil_stream_create_socket(env, svr_conn->socket); + if(!svr_conn->stream) + { + axis2_simple_tcp_svr_conn_free((axis2_simple_tcp_svr_conn_t *)svr_conn, env); + return NULL; + } + } + return svr_conn; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_simple_tcp_svr_conn_free( + axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + axis2_simple_tcp_svr_conn_close(svr_conn, env); + + AXIS2_FREE(env->allocator, svr_conn); + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_simple_tcp_svr_conn_close( + axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + axutil_stream_free(svr_conn->stream, env); + if(-1 != svr_conn->socket) + { + axutil_network_handler_close_socket(env, svr_conn->socket); + svr_conn->socket = -1; + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_simple_tcp_svr_conn_is_open( + axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + if(-1 != svr_conn->socket) + { + return AXIS2_TRUE; + } + return AXIS2_FALSE; +} + +AXIS2_EXTERN axutil_stream_t *AXIS2_CALL +axis2_simple_tcp_svr_conn_get_stream( + const axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + return svr_conn->stream; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_simple_tcp_svr_conn_read_request( + axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + int size = 32000; + axis2_char_t str_line[32000]; + axis2_char_t tmp_buf[32000]; + int read = -1; + + AXIS2_ENV_CHECK(env, NULL); + + memset(str_line, 0, size); + while((read = axutil_stream_peek_socket(svr_conn->stream, env, tmp_buf, size - 1)) > 0) + { + tmp_buf[read] = '\0'; + if(read > 0) + { + read = axutil_stream_read(svr_conn->stream, env, tmp_buf, size - 1); + if(read > 0) + { + tmp_buf[read] = '\0'; + strcat(str_line, tmp_buf); + break; + } + else + { + break; + } + } + } + if(str_line > 0) + { + svr_conn->buffer = str_line; + } + return svr_conn->buffer; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_simple_tcp_svr_conn_set_rcv_timeout( + axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env, + int timeout) +{ + return axutil_network_handler_set_sock_option(env, svr_conn->socket, SO_RCVTIMEO, timeout); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_simple_tcp_svr_conn_set_snd_timeout( + axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env, + int timeout) +{ + return axutil_network_handler_set_sock_option(env, svr_conn->socket, SO_SNDTIMEO, timeout); +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_simple_tcp_svr_conn_get_svr_ip( + const axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + return axutil_network_handler_get_svr_ip(env, svr_conn->socket); +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_simple_tcp_svr_conn_get_peer_ip( + const axis2_simple_tcp_svr_conn_t * svr_conn, + const axutil_env_t * env) +{ + return axutil_network_handler_get_peer_ip(env, svr_conn->socket); +} diff --git a/src/core/transport/tcp/receiver/tcp_receiver.c b/src/core/transport/tcp/receiver/tcp_receiver.c new file mode 100644 index 0000000..0451217 --- /dev/null +++ b/src/core/transport/tcp/receiver/tcp_receiver.c @@ -0,0 +1,400 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * @brief TCP Client struct impl + * Axis2 TCP Client impl + */ + +typedef struct axis2_tcp_server_impl +{ + axis2_transport_receiver_t tcp_server; + axis2_tcp_svr_thread_t *svr_thread; + int port; + axis2_char_t *svr_ip; + axis2_conf_ctx_t *conf_ctx; + axis2_conf_ctx_t *conf_ctx_private; + axis2_conf_t *conf; + axis2_bool_t is_application_client_side; +} axis2_tcp_server_impl_t; + +#define AXIS2_INTF_TO_IMPL(tcp_server) \ + ((axis2_tcp_server_impl_t *)(tcp_server)) + +/***************************** Function headers *******************************/ + +axis2_status_t AXIS2_CALL +axis2_tcp_server_init( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_in_desc_t * in_desc); + +axis2_status_t AXIS2_CALL +axis2_tcp_server_start( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_tcp_server_stop( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +axis2_conf_ctx_t *AXIS2_CALL axis2_tcp_server_get_conf_ctx( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +axis2_endpoint_ref_t *AXIS2_CALL axis2_tcp_server_get_reply_to_epr( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + +axis2_endpoint_ref_t *AXIS2_CALL axis2_tcp_server_get_epr_for_service( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name); + + +axis2_bool_t AXIS2_CALL +axis2_tcp_server_is_running( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +static void AXIS2_CALL +axis2_tcp_server_set_is_application_client_side( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_bool_t is_application_client_side); + +void AXIS2_CALL axis2_tcp_server_free( + axis2_transport_receiver_t * server, + const axutil_env_t * env); + +static axis2_char_t* AXIS2_CALL +axis2_tcp_server_get_server_ip( +axis2_transport_receiver_t *server, +const axutil_env_t *env); + +static void AXIS2_CALL +axis2_tcp_server_set_server_ip( +axis2_transport_receiver_t *transport_receiver, +const axutil_env_t *env, + axis2_char_t *serverip); + +static const axis2_transport_receiver_ops_t tcp_transport_receiver_ops_var = { + axis2_tcp_server_init, + axis2_tcp_server_start, + axis2_tcp_server_get_reply_to_epr, + axis2_tcp_server_get_epr_for_service, + axis2_tcp_server_get_server_ip, + axis2_tcp_server_set_server_ip, + axis2_tcp_server_get_conf_ctx, + axis2_tcp_server_is_running, + axis2_tcp_server_set_is_application_client_side, + axis2_tcp_server_stop, + axis2_tcp_server_free }; + +AXIS2_EXTERN axis2_transport_receiver_t *AXIS2_CALL +axis2_tcp_server_create( + const axutil_env_t * env, + const axis2_char_t * repo, + const int port) +{ + axis2_tcp_server_impl_t *server_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + + server_impl = (axis2_tcp_server_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_tcp_server_impl_t)); + + if(!server_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + server_impl->svr_thread = NULL; + server_impl->conf_ctx = NULL; + server_impl->conf_ctx_private = NULL; + server_impl->port = port; + server_impl->svr_ip = NULL; + server_impl->tcp_server.ops = &tcp_transport_receiver_ops_var; + + if(repo) + { + + /** + * We first create a private conf ctx which is owned by this server + * we only free this private conf context. We should never free the + * server_impl->conf_ctx because it may own to any other object which + * may lead to double free + */ + server_impl->conf_ctx_private = axis2_build_conf_ctx(env, repo); + if(!server_impl->conf_ctx_private) + { + axis2_tcp_server_free((axis2_transport_receiver_t *)server_impl, env); + return NULL; + } + server_impl->conf_ctx = server_impl->conf_ctx_private; + } + return &(server_impl->tcp_server); +} + +void AXIS2_CALL +axis2_tcp_server_free( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + axis2_tcp_server_impl_t *server_impl = NULL; + AXIS2_ENV_CHECK(env, void); + server_impl = AXIS2_INTF_TO_IMPL(server); + if(server_impl->svr_thread) + { + axis2_tcp_svr_thread_destroy(server_impl->svr_thread, env); + axis2_tcp_svr_thread_free(server_impl->svr_thread, env); + server_impl->svr_thread = NULL; + } + + if(server_impl->conf_ctx_private) + { + axis2_conf_ctx_free(server_impl->conf_ctx_private, env); + server_impl->conf_ctx_private = NULL; + } + + /** + * Do not free this. It may own to some other object + */ + server_impl->conf_ctx = NULL; + AXIS2_FREE(env->allocator, server_impl); + return; +} + +static void AXIS2_CALL +axis2_tcp_server_set_is_application_client_side( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_bool_t is_application_client_side) +{ + axis2_tcp_server_impl_t *server_impl = NULL; + server_impl = AXIS2_INTF_TO_IMPL(server); + server_impl->is_application_client_side = is_application_client_side; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_server_init( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_in_desc_t * in_desc) +{ + axis2_tcp_server_impl_t *server_impl = NULL; + axis2_char_t *port_str = NULL; + axutil_param_t *param = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + server_impl = AXIS2_INTF_TO_IMPL(server); + + server_impl->conf_ctx = conf_ctx; + param = (axutil_param_t *)axutil_param_container_get_param( + axis2_transport_in_desc_param_container(in_desc, env), env, "port"); + if(param) + { + port_str = axutil_param_get_value(param, env); + } + if(port_str) + { + server_impl->port = atoi(port_str); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_server_start( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + + axis2_tcp_server_impl_t *server_impl = NULL; + axis2_tcp_worker_t *worker = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + server_impl = AXIS2_INTF_TO_IMPL(server); + server_impl->svr_thread = axis2_tcp_svr_thread_create(env, server_impl->port); + if(!server_impl->svr_thread) + { + return AXIS2_FAILURE; + } + worker = axis2_tcp_worker_create(env, server_impl->conf_ctx); + axis2_tcp_worker_set_svr_port(worker, env, server_impl->port); + if(!worker) + { + axis2_tcp_svr_thread_free(server_impl->svr_thread, env); + return AXIS2_FAILURE; + } + AXIS2_LOG_INFO(env->log, "Starting TCP server thread"); + axis2_tcp_svr_thread_set_worker(server_impl->svr_thread, env, worker); + axis2_tcp_svr_thread_run(server_impl->svr_thread, env); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_tcp_server_stop( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + AXIS2_LOG_INFO(env->log, "Terminating TCP server thread"); + if(AXIS2_INTF_TO_IMPL(server)->svr_thread) + { + axis2_tcp_svr_thread_destroy(AXIS2_INTF_TO_IMPL(server)->svr_thread, env); + } + AXIS2_LOG_INFO(env->log, "Successfully terminated TCP server" " thread"); + return AXIS2_SUCCESS; +} + +axis2_conf_ctx_t *AXIS2_CALL +axis2_tcp_server_get_conf_ctx( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, NULL); + return AXIS2_INTF_TO_IMPL(server)->conf_ctx; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_tcp_server_get_reply_to_epr( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name) +{ + axis2_endpoint_ref_t *epr = NULL; + const axis2_char_t *host_address = NULL; + axis2_char_t *svc_path = NULL; + axutil_url_t *url = NULL; + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, svc_name, NULL); + + host_address = "127.0.0.1"; /* TODO : get from axis2.xml */ + svc_path = axutil_stracat(env, "/axis2/services/", svc_name); + url = axutil_url_create(env, "tcp", host_address, AXIS2_INTF_TO_IMPL(server)->port, svc_path); + AXIS2_FREE(env->allocator, svc_path); + if(!url) + { + return NULL; + } + epr = axis2_endpoint_ref_create(env, axutil_url_to_external_form(url, env)); + axutil_url_free(url, env); + return epr; +} + +axis2_endpoint_ref_t *AXIS2_CALL +axis2_tcp_server_get_epr_for_service( + axis2_transport_receiver_t * server, + const axutil_env_t * env, + const axis2_char_t * svc_name) +{ + axis2_endpoint_ref_t *epr = NULL; + const axis2_char_t *host_address = NULL; + axis2_char_t *svc_path = NULL; + axutil_url_t *url = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_name, NULL); + host_address = "127.0.0.1"; /* TODO : get from axis2.xml */ + svc_path = axutil_stracat(env, "/axis2/services/", svc_name); + + url = axutil_url_create(env, "tcp", host_address, AXIS2_INTF_TO_IMPL(server)->port, svc_path); + AXIS2_FREE(env->allocator, svc_path); + if(!url) + { + return NULL; + } + epr = axis2_endpoint_ref_create(env, axutil_url_to_external_form(url, env)); + axutil_url_free(url, env); + return epr; +} + +axis2_bool_t AXIS2_CALL +axis2_tcp_server_is_running( + axis2_transport_receiver_t * server, + const axutil_env_t * env) +{ + axis2_tcp_server_impl_t *server_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + server_impl = AXIS2_INTF_TO_IMPL(server); + if(!server_impl->svr_thread) + { + return AXIS2_FALSE; + } + return axis2_tcp_svr_thread_is_running(server_impl->svr_thread, env); +} + +static axis2_char_t* AXIS2_CALL +axis2_tcp_server_get_server_ip( +axis2_transport_receiver_t *server, +const axutil_env_t *env) +{ + return AXIS2_INTF_TO_IMPL(server)->svr_ip; +} + +static void AXIS2_CALL +axis2_tcp_server_set_server_ip( +axis2_transport_receiver_t *server, +const axutil_env_t *env, + axis2_char_t *serverip) +{ + AXIS2_INTF_TO_IMPL(server)->svr_ip = serverip; +} + + +/** + * Following block distinguish the exposed part of the dll. + */ +AXIS2_EXPORT int +axis2_get_instance( + struct axis2_transport_receiver **inst, + const axutil_env_t * env) +{ + *inst = axis2_tcp_server_create(env, NULL, -1); + if(!(*inst)) + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT int +axis2_remove_instance( + axis2_transport_receiver_t * inst, + const axutil_env_t * env) +{ + if(inst) + { + axis2_transport_receiver_free(inst, env); + } + return AXIS2_SUCCESS; +} diff --git a/src/core/transport/tcp/receiver/tcp_svr_thread.c b/src/core/transport/tcp/receiver/tcp_svr_thread.c new file mode 100644 index 0000000..5543394 --- /dev/null +++ b/src/core/transport/tcp/receiver/tcp_svr_thread.c @@ -0,0 +1,297 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +AXIS2_EXPORT int axis2_tcp_socket_read_timeout = AXIS2_TCP_DEFAULT_SO_TIMEOUT; + +struct axis2_tcp_svr_thread +{ + int listen_socket; + axis2_bool_t stopped; + axis2_tcp_worker_t *worker; + int port; +}; + +typedef struct axis2_tcp_svr_thd_args +{ + axutil_env_t *env; + axis2_socket_t socket; + axis2_tcp_worker_t *worker; + axutil_thread_t *thread; +} axis2_tcp_svr_thd_args_t; + +AXIS2_EXTERN const axutil_env_t *AXIS2_CALL init_thread_env( + const axutil_env_t ** system_env); + +void *AXIS2_THREAD_FUNC axis2_svr_thread_worker_func( + axutil_thread_t * thd, + void *data); + +axis2_tcp_svr_thread_t *AXIS2_CALL +axis2_tcp_svr_thread_create( + const axutil_env_t * env, + int port) +{ + axis2_tcp_svr_thread_t *svr_thread = NULL; + AXIS2_ENV_CHECK(env, NULL); + + svr_thread = (axis2_tcp_svr_thread_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_tcp_svr_thread_t)); + + if(!svr_thread) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svr_thread->worker = NULL; + svr_thread->stopped = AXIS2_FALSE; + svr_thread->port = port; + svr_thread->listen_socket = (int)axutil_network_handler_create_server_socket(env, + svr_thread->port); + if(-1 == svr_thread->listen_socket) + { + axis2_tcp_svr_thread_free((axis2_tcp_svr_thread_t *)svr_thread, env); + return NULL; + } + + return svr_thread; +} + +void AXIS2_CALL +axis2_tcp_svr_thread_free( + axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(svr_thread->worker) + { + axis2_tcp_worker_free(svr_thread->worker, env); + svr_thread->worker = NULL; + } + if(-1 != svr_thread->listen_socket) + { + axutil_network_handler_close_socket(env, svr_thread->listen_socket); + svr_thread->listen_socket = -1; + } + svr_thread->stopped = AXIS2_TRUE; + + AXIS2_FREE(env->allocator, svr_thread); + return; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_svr_thread_run( + axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + while(AXIS2_FALSE == svr_thread->stopped) + { + int socket = -1; + axis2_tcp_svr_thd_args_t *arg_list = NULL; +#ifdef AXIS2_SVR_MULTI_THREADED + axutil_thread_t *worker_thread = NULL; +#endif + + socket = (int)axutil_network_handler_svr_socket_accept(env, svr_thread-> listen_socket); + if(!svr_thread->worker) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "Worker not ready yet." + " Cannot serve the request"); + axutil_network_handler_close_socket(env, socket); + continue; + } + arg_list = AXIS2_MALLOC(env->allocator, sizeof(axis2_tcp_svr_thd_args_t)); + if(!arg_list) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Memory allocation error in the svr thread loop"); + continue; + } + arg_list->env = (axutil_env_t *)env; + arg_list->socket = socket; + arg_list->worker = svr_thread->worker; +#ifdef AXIS2_SVR_MULTI_THREADED + worker_thread = axutil_thread_pool_get_thread(env->thread_pool, + axis2_svr_thread_worker_func, + (void *) arg_list); + if (!worker_thread) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Thread creation failed" + "server thread loop"); + continue; + } + axutil_thread_pool_thread_detach(env->thread_pool, worker_thread); +#else + axis2_svr_thread_worker_func(NULL, (void *)arg_list); +#endif + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_svr_thread_destroy( + axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE); + + if(AXIS2_TRUE == svr_thread->stopped) + { + return AXIS2_SUCCESS; + } + svr_thread->stopped = AXIS2_TRUE; + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Terminating TCP server " + "thread."); + if(svr_thread->listen_socket) + { + axutil_network_handler_close_socket(env, svr_thread->listen_socket); + svr_thread->listen_socket = -1; + } + return AXIS2_SUCCESS; +} + +int AXIS2_CALL +axis2_tcp_svr_thread_get_local_port( + const axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + return svr_thread->port; +} + +axis2_bool_t AXIS2_CALL +axis2_tcp_svr_thread_is_running( + axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env) +{ + return svr_thread->port; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_svr_thread_set_worker( + axis2_tcp_svr_thread_t * svr_thread, + const axutil_env_t * env, + axis2_tcp_worker_t * worker) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, worker, AXIS2_FAILURE); + svr_thread->worker = worker; + return AXIS2_SUCCESS; +} + +/** + * Thread worker function. + */ +void *AXIS2_THREAD_FUNC +axis2_svr_thread_worker_func( + axutil_thread_t * thd, + void *data) +{ + struct AXIS2_PLATFORM_TIMEB t1, t2; + axis2_simple_tcp_svr_conn_t *svr_conn = NULL; + axis2_char_t *request = NULL; + int millisecs = 0; + double secs = 0; + axis2_tcp_worker_t *tmp = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_env_t *env = NULL; + axis2_socket_t socket; + axutil_env_t *thread_env = NULL; + axis2_tcp_svr_thd_args_t *arg_list = NULL; + +#ifndef WIN32 +#ifdef AXIS2_SVR_MULTI_THREADED + signal(SIGPIPE, SIG_IGN); +#endif +#endif + + arg_list = (axis2_tcp_svr_thd_args_t *)data; + if(!arg_list) + { + return NULL; + } + AXIS2_PLATFORM_GET_TIME_IN_MILLIS(&t1); + env = arg_list->env; + thread_env = axutil_init_thread_env(env); + socket = arg_list->socket; + svr_conn = axis2_simple_tcp_svr_conn_create(thread_env, (int)socket); + axis2_simple_tcp_svr_conn_set_rcv_timeout(svr_conn, thread_env, axis2_tcp_socket_read_timeout); + request = axis2_simple_tcp_svr_conn_read_request(svr_conn, thread_env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "tcp request %s", request); + tmp = arg_list->worker; + status = axis2_tcp_worker_process_request(tmp, thread_env, svr_conn, request); + axis2_simple_tcp_svr_conn_free(svr_conn, thread_env); + + AXIS2_PLATFORM_GET_TIME_IN_MILLIS(&t2); + millisecs = t2.millitm - t1.millitm; + secs = difftime(t2.time, t1.time); + if(millisecs < 0) + { + millisecs += 1000; + secs--; + } + secs += millisecs / 1000.0; + + if(status == AXIS2_SUCCESS) + { +#if defined(WIN32) + AXIS2_LOG_INFO(thread_env->log, "Request served successfully"); +#else + AXIS2_LOG_INFO(thread_env->log, "Request served in %.3f seconds", secs); +#endif + } + else + { +#if defined(WIN32) + AXIS2_LOG_WARNING(thread_env->log, AXIS2_LOG_SI, + "Error occured in processing request "); +#else + AXIS2_LOG_WARNING(thread_env->log, AXIS2_LOG_SI, + "Error occured in processing request (%.3f seconds)", secs); +#endif + } + + AXIS2_FREE(thread_env->allocator, arg_list); + + if(thread_env) + { + /* There is a persistant problem: Uncomment this after fix + * the issue */ + /* axutil_free_thread_env(thread_env); */ + thread_env = NULL; + } +#ifdef AXIS2_SVR_MULTI_THREADED + axutil_thread_pool_exit_thread(env->thread_pool, thd); +#endif + + return NULL; +} diff --git a/src/core/transport/tcp/receiver/tcp_worker.c b/src/core/transport/tcp/receiver/tcp_worker.c new file mode 100644 index 0000000..217519d --- /dev/null +++ b/src/core/transport/tcp/receiver/tcp_worker.c @@ -0,0 +1,180 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_tcp_worker +{ + axis2_conf_ctx_t *conf_ctx; + int svr_port; +}; + +AXIS2_EXTERN axis2_tcp_worker_t *AXIS2_CALL +axis2_tcp_worker_create( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_tcp_worker_t *tcp_worker = NULL; + AXIS2_ENV_CHECK(env, NULL); + tcp_worker = (axis2_tcp_worker_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_tcp_worker_t)); + + if(!tcp_worker) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + tcp_worker->conf_ctx = conf_ctx; + tcp_worker->svr_port = 9090; /* default - must set later */ + + return tcp_worker; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_tcp_worker_free( + axis2_tcp_worker_t * tcp_worker, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + tcp_worker->conf_ctx = NULL; + + AXIS2_FREE(env->allocator, tcp_worker); + + return; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_tcp_worker_process_request( + axis2_tcp_worker_t * tcp_worker, + const axutil_env_t * env, + axis2_simple_tcp_svr_conn_t * svr_conn, + axis2_char_t * simple_request) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_transport_out_desc_t *out_desc = NULL; + axis2_transport_in_desc_t *in_desc = NULL; + axis2_msg_ctx_t *msg_ctx = NULL; + axiom_xml_reader_t *reader = NULL; + axiom_stax_builder_t *builder = NULL; + axiom_soap_builder_t *soap_builder = NULL; + axiom_soap_envelope_t *soap_envelope = NULL; + axis2_engine_t *engine = NULL; + axis2_status_t status = AXIS2_FALSE; + axutil_stream_t *svr_stream = NULL; + axis2_char_t *buffer = NULL; + int len = 0; + int write = -1; + axutil_stream_t *out_stream = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "start:axis2_tcp_worker_process_request"); + + out_stream = axutil_stream_create_basic(env); + reader = axiom_xml_reader_create_for_memory(env, simple_request, axutil_strlen(simple_request), + NULL, AXIS2_XML_PARSER_TYPE_BUFFER); + if(!reader) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create XML reader"); + return AXIS2_FAILURE; + } + + builder = axiom_stax_builder_create(env, reader); + if(!builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create Stax builder"); + return AXIS2_FAILURE; + } + + soap_builder + = axiom_soap_builder_create(env, builder, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + + if(!soap_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create SOAP builder"); + return AXIS2_FAILURE; + } + + conf_ctx = tcp_worker->conf_ctx; + + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "conf ctx not available"); + return AXIS2_FAILURE; + } + + out_desc = axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_TCP); + if(!out_desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport out not set"); + return AXIS2_FAILURE; + } + + in_desc = axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(conf_ctx, env), env, + AXIS2_TRANSPORT_ENUM_TCP); + + msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc); + axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE); + axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream); + + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope); + + engine = axis2_engine_create(env, conf_ctx); + status = axis2_engine_receive(engine, env, msg_ctx); + + svr_stream = axis2_simple_tcp_svr_conn_get_stream(svr_conn, env); + buffer = out_stream->buffer; + len = out_stream->len; + buffer[len] = 0; + if(svr_stream && buffer) + { + write = axutil_stream_write(svr_stream, env, buffer, len + 1); + if(write < 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "stream write failed"); + return AXIS2_FAILURE; + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "stream wrote:%s", buffer); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "end:axis2_tcp_worker_process_request"); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_tcp_worker_set_svr_port( + axis2_tcp_worker_t * worker, + const axutil_env_t * env, + int port) +{ + worker->svr_port = port; + return AXIS2_SUCCESS; +} diff --git a/src/core/transport/tcp/sender/Makefile.am b/src/core/transport/tcp/sender/Makefile.am new file mode 100644 index 0000000..1e35b3d --- /dev/null +++ b/src/core/transport/tcp/sender/Makefile.am @@ -0,0 +1,26 @@ +lib_LTLIBRARIES = libaxis2_tcp_sender.la + +libaxis2_tcp_sender_la_SOURCES = tcp_transport_sender.c + +libaxis2_tcp_sender_la_LIBADD = $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la\ + $(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la\ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la\ + $(top_builddir)/util/src/libaxutil.la\ + $(LIBCURL_LIBS)\ + $(SSL_LIBS) + + +libaxis2_tcp_sender_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport\ + -I$(top_builddir)/src/core/transport/tcp \ + -I$(top_builddir)/src/core/transport/tcp/sender/libcurl \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I.. \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/tcp/sender/tcp_transport_sender.c b/src/core/transport/tcp/sender/tcp_transport_sender.c new file mode 100644 index 0000000..62f34d3 --- /dev/null +++ b/src/core/transport/tcp/sender/tcp_transport_sender.c @@ -0,0 +1,477 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define RES_BUFF 50 + +/** + * TCP Transport Sender struct impl + * Axis2 TCP Transport Sender impl + */ + +typedef struct axis2_tcp_transport_sender_impl +{ + axis2_transport_sender_t transport_sender; + int connection_timeout; + int so_timeout; +} axis2_tcp_transport_sender_impl_t; + +#define AXIS2_INTF_TO_IMPL(transport_sender) \ + ((axis2_tcp_transport_sender_impl_t *) \ + (transport_sender)) + +/***************************** Function headers *******************************/ +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_invoke( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_clean_up( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_init( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_out_desc_t * out_desc); + +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_write_message( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_endpoint_ref_t * epr, + axiom_soap_envelope_t * out, + axiom_output_t * om_output); + +void AXIS2_CALL axis2_tcp_transport_sender_free( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env); + +static const axis2_transport_sender_ops_t tcp_transport_sender_ops_var = { + axis2_tcp_transport_sender_init, axis2_tcp_transport_sender_invoke, + axis2_tcp_transport_sender_clean_up, axis2_tcp_transport_sender_free }; + +axis2_transport_sender_t *AXIS2_CALL +axis2_tcp_transport_sender_create( + const axutil_env_t * env) +{ + axis2_tcp_transport_sender_impl_t *transport_sender_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + + transport_sender_impl = (axis2_tcp_transport_sender_impl_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_tcp_transport_sender_impl_t)); + + if(!transport_sender_impl) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + transport_sender_impl->connection_timeout = AXIS2_TCP_DEFAULT_CONNECTION_TIMEOUT; + transport_sender_impl->so_timeout = AXIS2_TCP_DEFAULT_SO_TIMEOUT; + transport_sender_impl->transport_sender.ops = &tcp_transport_sender_ops_var; + return &(transport_sender_impl->transport_sender); +} + +void AXIS2_CALL +axis2_tcp_transport_sender_free( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env) +{ + axis2_tcp_transport_sender_impl_t *transport_sender_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + transport_sender_impl = AXIS2_INTF_TO_IMPL(transport_sender); + AXIS2_FREE(env->allocator, transport_sender_impl); + return; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_invoke( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_op_t *op = NULL; + const axis2_char_t *mep_uri = NULL; + axis2_bool_t is_server = AXIS2_TRUE; + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_xml_writer_t *xml_writer = NULL; + axiom_output_t *om_output = NULL; + axis2_char_t *buffer = NULL; + axutil_stream_t *out_stream = NULL; + int buffer_size = 0; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axis2_transport_out_desc_t *trans_desc = NULL; + axutil_param_t *write_xml_declaration_param = NULL; + axutil_hash_t *transport_attrs = NULL; + axis2_bool_t write_xml_declaration = AXIS2_FALSE; + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "start:tcp transport sender invoke"); + + op = axis2_msg_ctx_get_op(msg_ctx, env); + mep_uri = axis2_op_get_msg_exchange_pattern(op, env); + + is_server = axis2_msg_ctx_get_server_side(msg_ctx, env); + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, + AXIS2_XML_PARSER_TYPE_BUFFER); + if(!xml_writer) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[tcp]Failed to create XML writer"); + return AXIS2_FAILURE; + } + + om_output = axiom_output_create(env, xml_writer); + if(!om_output) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[tcp]Failed to create OM output"); + axiom_xml_writer_free(xml_writer, env); + xml_writer = NULL; + return AXIS2_FAILURE; + } + + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx) + { + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + } + if(conf) + { + trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_TCP); + } + if(trans_desc) + { + write_xml_declaration_param = axutil_param_container_get_param( + axis2_transport_out_desc_param_container(trans_desc, env), env, AXIS2_XML_DECLARATION); + } + if(write_xml_declaration_param) + { + transport_attrs = axutil_param_get_attributes(write_xml_declaration_param, env); + if(transport_attrs) + { + axutil_generic_obj_t *obj = NULL; + axiom_attribute_t *write_xml_declaration_attr = NULL; + axis2_char_t *write_xml_declaration_attr_value = NULL; + + obj + = axutil_hash_get(transport_attrs, AXIS2_ADD_XML_DECLARATION, AXIS2_HASH_KEY_STRING); + if(obj) + { + write_xml_declaration_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, + env); + } + if(write_xml_declaration_attr) + { + write_xml_declaration_attr_value = axiom_attribute_get_value( + write_xml_declaration_attr, env); + } + if(write_xml_declaration_attr_value && 0 == axutil_strcasecmp( + write_xml_declaration_attr_value, AXIS2_VALUE_TRUE)) + { + write_xml_declaration = AXIS2_TRUE; + } + } + } + + if(write_xml_declaration) + { + axiom_output_write_xml_version_encoding(om_output, env); + } + + axiom_soap_envelope_serialize(soap_envelope, env, om_output, AXIS2_FALSE); + + buffer = (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env); + if(!buffer) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[tcp]Failed to serialize the SOAP envelope"); + return AXIS2_FAILURE; + } + buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); + buffer[buffer_size] = 0; + if(is_server) + { + out_stream = axis2_msg_ctx_get_transport_out_stream(msg_ctx, env); + axutil_stream_write(out_stream, env, buffer, buffer_size); + } + else + { + axis2_endpoint_ref_t *to = NULL; + axutil_url_t *to_url = NULL; + const axis2_char_t *to_str = NULL; + const axis2_char_t *host = NULL; + int port = 0; + int socket = -1; + axutil_stream_t *stream; + int write = -1; + int read = -1; + axis2_char_t buff[1]; + axis2_char_t *res_buffer = (axis2_char_t *)AXIS2_MALLOC(env->allocator, RES_BUFF); + int res_size = 0; + int size = 0; + axiom_xml_reader_t *reader = NULL; + axiom_stax_builder_t *builder = NULL; + axiom_soap_builder_t *soap_builder = NULL; + axiom_soap_envelope_t *soap_envelope = NULL; + + to = axis2_msg_ctx_get_to(msg_ctx, env); + + if(!to) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "To epr not presant"); + return AXIS2_FAILURE; + } + + to_str = axis2_endpoint_ref_get_address(to, env); + if(!to_str) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "unable to convert epr to string"); + return AXIS2_FAILURE; + } + + to_url = axutil_url_parse_string(env, to_str); + + if(!to_url) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "unable to parser string to url"); + return AXIS2_FAILURE; + } + + host = axutil_url_get_host(to_url, env); + if(!host) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "retrieving host failed"); + return AXIS2_FAILURE; + } + + port = axutil_url_get_port(to_url, env); + if(!port) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "retrieving port failed"); + return AXIS2_FAILURE; + } + socket = (int)axutil_network_handler_open_socket(env, (char *)host, port); + if(!socket) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "socket creation failed"); + return AXIS2_FAILURE; + } + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "open socket for host:%s port:%d", host, port); + + stream = axutil_stream_create_socket(env, socket); + if(!stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "stream creation failed"); + return AXIS2_FAILURE; + } + + write = axutil_stream_write(stream, env, buffer, buffer_size); + if(write < 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "stream write error"); + return AXIS2_FAILURE; + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "stream wrote soap msg: %s", buffer); + write = axutil_stream_write(stream, env, "\r\n\r\n", 4); + size = RES_BUFF; + while((read = axutil_stream_read(stream, env, &buff, 1)) > 0) + { + if(res_size >= size) + { + axis2_char_t *tmp_buff = NULL; + size <<= 2; + tmp_buff = AXIS2_MALLOC(env->allocator, size); + memcpy(tmp_buff, res_buffer, res_size); + AXIS2_FREE(env->allocator, res_buffer); + res_buffer = tmp_buff; + } + memcpy(res_buffer + res_size, buff, 1); + res_size++; + } + + axutil_network_handler_close_socket(env, stream->socket); + axutil_stream_close(stream, env); + axutil_stream_free(stream, env); + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "%s", res_buffer); + + reader = axiom_xml_reader_create_for_memory(env, res_buffer, (res_size - 1), NULL, + AXIS2_XML_PARSER_TYPE_BUFFER); + + if(!reader) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create XML reader"); + return AXIS2_FAILURE; + } + + builder = axiom_stax_builder_create(env, reader); + if(!builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create Stax builder"); + return AXIS2_FAILURE; + } + + soap_builder = axiom_soap_builder_create(env, builder, + AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); + if(!soap_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create SOAP builder"); + return AXIS2_FAILURE; + } + soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env); + + if(!soap_envelope) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create SOAP envelope"); + return AXIS2_FAILURE; + } + + axis2_msg_ctx_set_response_soap_envelope(msg_ctx, env, soap_envelope); + + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "end:tcp transport sender invoke"); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_clean_up( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + /* + * Clean up is not used. If the tcp sender needs + * to be cleaned up it should be done here. + */ + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_init( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_transport_out_desc_t * out_desc) +{ + axis2_char_t *temp = NULL; + axutil_param_t *temp_param = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, out_desc, AXIS2_FAILURE); + + temp_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container( + out_desc, env), env, AXIS2_TCP_SO_TIMEOUT); + if(temp_param) + { + temp = axutil_param_get_value(temp_param, env); + } + if(temp) + { + AXIS2_INTF_TO_IMPL(transport_sender)->so_timeout = AXIS2_ATOI(temp); + } + temp = (axis2_char_t *)axutil_param_container_get_param( + axis2_transport_out_desc_param_container(out_desc, env), env, AXIS2_TCP_CONNECTION_TIMEOUT); + if(temp_param) + { + temp = axutil_param_get_value(temp_param, env); + } + if(temp) + { + AXIS2_INTF_TO_IMPL(transport_sender)->connection_timeout = AXIS2_ATOI(temp); + } + + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_tcp_transport_sender_write_message( + axis2_transport_sender_t * transport_sender, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx, + axis2_endpoint_ref_t * epr, + axiom_soap_envelope_t * out, + axiom_output_t * om_output) +{ + + return AXIS2_TRUE; +} + +/** + * Following block distinguish the exposed part of the dll. + */ + +/* When building for static deployment, give the get and remove methods + * unique names. This avoids having the linker fail with duplicate symbol + * errors. + */ + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_get_instance( +#else + axis2_tcp_transport_sender_get_instance( +#endif + struct axis2_transport_sender **inst, + const axutil_env_t * env) +{ + *inst = axis2_tcp_transport_sender_create(env); + if(!(*inst)) + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_remove_instance( +#else + axis2_tcp_transport_sender_remove_instance( +#endif + axis2_transport_sender_t * inst, + const axutil_env_t * env) +{ + if(inst) + { + AXIS2_TRANSPORT_SENDER_FREE(inst, env); + } + return AXIS2_SUCCESS; +} diff --git a/src/core/transport/tcp/server/Makefile.am b/src/core/transport/tcp/server/Makefile.am new file mode 100644 index 0000000..5d7b263 --- /dev/null +++ b/src/core/transport/tcp/server/Makefile.am @@ -0,0 +1 @@ +SUBDIRS=simple_tcp_server diff --git a/src/core/transport/tcp/server/simple_tcp_server/Makefile.am b/src/core/transport/tcp/server/simple_tcp_server/Makefile.am new file mode 100644 index 0000000..1dafbad --- /dev/null +++ b/src/core/transport/tcp/server/simple_tcp_server/Makefile.am @@ -0,0 +1,30 @@ +prgbindir=$(bindir) +prgbin_PROGRAMS = axis2_tcp_server +SUBDIRS = +AM_CFLAGS = -g -pthread +axis2_tcp_server_SOURCES = tcp_server_main.c + +axis2_tcp_server_LDADD = $(LDFLAGS) \ + $(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/parser/$(WRAPPER_DIR)/libaxis2_parser.la \ + $(top_builddir)/src/core/description/libaxis2_description.la \ + $(top_builddir)/src/core/deployment/libaxis2_deployment.la \ + $(top_builddir)/src/core/context/libaxis2_context.la \ + $(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \ + $(top_builddir)/src/core/engine/libaxis2_engine.la \ + $(top_builddir)/src/core/transport/tcp/sender/libaxis2_tcp_sender.la \ + $(top_builddir)/src/core/transport/tcp/receiver/libaxis2_tcp_receiver.la \ + $(top_builddir)/neethi/src/libneethi.la \ + -lpthread + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description\ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/deployment\ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I../.. \ + -I$(top_builddir)/axiom/include diff --git a/src/core/transport/tcp/server/simple_tcp_server/tcp_server_main.c b/src/core/transport/tcp/server/simple_tcp_server/tcp_server_main.c new file mode 100644 index 0000000..dc2dbf9 --- /dev/null +++ b/src/core/transport/tcp/server/simple_tcp_server/tcp_server_main.c @@ -0,0 +1,262 @@ +/* + * 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 + * + * tcp://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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef AXIS2_TCP_SERVER_LOG_FILE_NAME +#define AXIS2_TCP_SERVER_LOG_FILE_NAME "axis2_tcp_server.log" +#endif + +#ifndef AXIS2_TCP_SERVER_PORT +#define AXIS2_TCP_SERVER_PORT 9091 +#endif + +#ifndef AXIS2_TCP_SERVER_REPO_PATH +#define AXIS2_TCP_SERVER_REPO_PATH "../" +#endif + +axutil_env_t *system_env = NULL; +axis2_transport_receiver_t *server = NULL; +int axis2_tcp_socket_read_timeout = 60000; + +/***************************** Function headers *******************************/ +axutil_env_t * +init_syetem_env( + axutil_allocator_t * allocator, + const axis2_char_t * log_file); + +void +system_exit( + axutil_env_t * env, + int status); + +void +usage( + axis2_char_t * prog_name); + +void +sig_handler( + int signal); + +/***************************** End of function headers ************************/ +axutil_env_t * +init_syetem_env( + axutil_allocator_t * allocator, + const axis2_char_t * log_file) +{ + axutil_error_t *error = axutil_error_create(allocator); + axutil_log_t *log = axutil_log_create(allocator, NULL, log_file); + axutil_thread_pool_t *thread_pool = axutil_thread_pool_init(allocator); + /* We need to init the parser in main thread before spawning child + * threads + */ + axiom_xml_reader_init(); + return axutil_env_create_with_error_log_thread_pool(allocator, error, log, thread_pool); +} + +void +system_exit( + axutil_env_t * env, + int status) +{ + axutil_allocator_t *allocator = NULL; + if(server) + { + axis2_transport_receiver_free(server, system_env); + } + if(env) + { + allocator = env->allocator; + axutil_env_free(env); + } + axiom_xml_reader_cleanup(); + exit(status); +} + +int +main( + int argc, + char *argv[]) +{ + axutil_allocator_t *allocator = NULL; + axutil_env_t *env = NULL; + extern char *optarg; + extern int optopt; + int c; + int log_file_size = AXUTIL_LOG_FILE_SIZE; + axutil_log_levels_t log_level = AXIS2_LOG_LEVEL_DEBUG; + const axis2_char_t *log_file = AXIS2_TCP_SERVER_LOG_FILE_NAME; + int port = AXIS2_TCP_SERVER_PORT; + const axis2_char_t *repo_path = AXIS2_TCP_SERVER_REPO_PATH; + + while((c = AXIS2_GETOPT(argc, argv, ":p:r:ht:l:s:f:")) != -1) + { + + switch(c) + { + case 'p': + port = AXIS2_ATOI(optarg); + break; + case 'r': + repo_path = optarg; + break; + case 't': + axis2_tcp_socket_read_timeout = AXIS2_ATOI(optarg) * 1000; + break; + case 'l': + log_level = AXIS2_ATOI(optarg); + if(log_level < AXIS2_LOG_LEVEL_CRITICAL) + log_level = AXIS2_LOG_LEVEL_CRITICAL; + if(log_level > AXIS2_LOG_LEVEL_TRACE) + log_level = AXIS2_LOG_LEVEL_TRACE; + break; + case 's': + log_file_size = 1024 * 1024 * AXIS2_ATOI(optarg); + break; + case 'f': + log_file = optarg; + break; + case 'h': + usage(argv[0]); + return 0; + case ':': + fprintf(stderr, "\nOption -%c requires an operand\n", optopt); + usage(argv[0]); + return -1; + case '?': + if(isprint(optopt)) + fprintf(stderr, "\nUnknown option `-%c'.\n", optopt); + usage(argv[0]); + return -1; + } + } + + allocator = axutil_allocator_init(NULL); + if(!allocator) + { + system_exit(NULL, -1); + } + env = init_syetem_env(allocator, log_file); + env->log->level = log_level; + env->log->size = log_file_size; + axutil_error_init(); + system_env = env; + +#ifndef WIN32 + signal(SIGINT, sig_handler); + signal(SIGPIPE, sig_handler); +#endif + + AXIS2_LOG_INFO(env->log, "Starting Axis2 TCP server...."); + AXIS2_LOG_INFO(env->log, "Server port : %d", port); + AXIS2_LOG_INFO(env->log, "Repo location : %s", repo_path); + AXIS2_LOG_INFO(env->log, "Read Timeout : %d ms", axis2_tcp_socket_read_timeout); + + server = axis2_tcp_server_create(env, repo_path, port); + if(!server) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server creation failed: Error code:" " %d :: %s", + env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); + system_exit(env, -1); + + } + printf("Started Simple Axis2 TCP Server ...\n"); + if(axis2_transport_receiver_start(server, env) == AXIS2_FAILURE) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Server start failed: Error code:" " %d :: %s", + env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); + system_exit(env, -1); + } + return 0; +} + +void +usage( + axis2_char_t * prog_name) +{ + fprintf(stdout, "\n Usage : %s", prog_name); + fprintf(stdout, " [-p PORT]"); + fprintf(stdout, " [-t TIMEOUT]"); + fprintf(stdout, " [-r REPO_PATH]"); + fprintf(stdout, " [-l LOG_LEVEL]"); + fprintf(stdout, " [-f LOG_FILE]\n"); + fprintf(stdout, " [-s LOG_FILE_SIZE]\n"); + fprintf(stdout, " Options :\n"); + fprintf(stdout, "\t-p PORT \t port number to use, default port is %d\n", AXIS2_TCP_SERVER_PORT); + fprintf(stdout, "\t-r REPO_PATH \t repository path, default is ../\n"); + fprintf(stdout, "\t-t TIMEOUT\t socket read timeout, default is 30 seconds\n"); + fprintf(stdout, "\t-l LOG_LEVEL\t log level, available log levels:" + "\n\t\t\t 0 - critical 1 - errors 2 - warnings" + "\n\t\t\t 3 - information 4 - debug 5- user 6 - trace" + "\n\t\t\t Default log level is 4(debug).\n"); +#ifndef WIN32 + fprintf(stdout, "\t-f LOG_FILE\t log file, default is $AXIS2C_HOME/logs/axis2.log" + "\n\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#else + fprintf(stdout, + "\t-f LOG_FILE\t log file, default is %%AXIS2C_HOME%%\\logs\\axis2.log" + "\n\t\t\t or axis2.log in current folder if AXIS2C_HOME not set\n"); +#endif + fprintf(stdout, + "\t-s LOG_FILE_SIZE\t Maximum log file size in mega bytes, default maximum size is 1MB.\n"); + fprintf(stdout, " Help :\n\t-h \t display this help screen.\n\n"); +} + +/** + * Signal handler + */ +#ifndef WIN32 + +void +sig_handler( + int signal) +{ + switch(signal) + { + case SIGINT: + { + AXIS2_LOG_INFO(system_env->log, "Received signal SIGINT. Server " + "shutting down"); + axis2_tcp_server_stop(server, system_env); + AXIS2_LOG_INFO(system_env->log, "Shutdown complete ..."); + system_exit(system_env, 0); + } + case SIGPIPE: + { + AXIS2_LOG_INFO(system_env->log, "Received signal SIGPIPE. Client " + "request serve aborted"); + return; + } + case SIGSEGV: + { + fprintf(stderr, "Received deadly signal SIGSEGV. Terminating\n"); + _exit(-1); + } + } +} +#endif diff --git a/src/core/transport/transport_receiver.c b/src/core/transport/transport_receiver.c new file mode 100644 index 0000000..009d24b --- /dev/null +++ b/src/core/transport/transport_receiver.c @@ -0,0 +1,114 @@ +/* + * 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. + */ + +#include + +AXIS2_EXTERN void AXIS2_CALL +axis2_transport_receiver_free( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env) +{ + (transport_receiver->ops)->free(transport_receiver, env); +} + +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) +{ + return (transport_receiver->ops)->init(transport_receiver, env, conf_ctx, transport_in); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_transport_receiver_start( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env) +{ + return (transport_receiver->ops)->start(transport_receiver, env); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_transport_receiver_stop( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env) +{ + return (transport_receiver->ops)->stop(transport_receiver, env); +} + +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) +{ + return (transport_receiver->ops)->get_reply_to_epr(transport_receiver, env, svc_name); +} + +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) +{ + return (transport_receiver->ops)->get_epr_for_service(transport_receiver, env, 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) +{ + return (transport_receiver->ops)->get_server_ip(transport_receiver, 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) +{ + (transport_receiver->ops)->set_server_ip(transport_receiver, env, serverip); +} + + +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) +{ + return (transport_receiver)->ops->get_conf_ctx(transport_receiver, env); +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_transport_receiver_is_running( + axis2_transport_receiver_t * transport_receiver, + const axutil_env_t * env) +{ + return (transport_receiver)->ops->is_running(transport_receiver, 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) +{ + (transport_receiver)->ops->set_is_application_client_side(transport_receiver, env, + is_application_client_side); +} diff --git a/src/core/util/Makefile.am b/src/core/util/Makefile.am new file mode 100644 index 0000000..e5609a2 --- /dev/null +++ b/src/core/util/Makefile.am @@ -0,0 +1,9 @@ +noinst_LTLIBRARIES = libaxis2_core_utils.la +#noinst_HEADERS = axis2_core_utils.h + +libaxis2_core_utils_la_SOURCES = core_utils.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/core/util/core_utils.c b/src/core/util/core_utils.c new file mode 100644 index 0000000..5ae9f31 --- /dev/null +++ b/src/core/util/core_utils.c @@ -0,0 +1,1635 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +/* internal structure to keep the rest map in a multi level hash */ +typedef struct +{ + /* the structure will keep as many as following fields */ + + /* if the mapped value is directly the operation */ + axis2_op_t *op_desc; + + /* if the mapped value is a constant, this keeps a hash map of + possible constants => corrosponding map_internal structure */ + axutil_hash_t *consts_map; + + /* if the mapped value is a param, this keeps a hash map of + possible param_values => corrosponding_map_internal structre */ + axutil_hash_t *params_map; + +} axutil_core_utils_map_internal_t; + +/* some functions to use internally in handling rest map */ +/* infer op from the live url */ +axis2_op_t * +axis2_core_utils_infer_op_from_parent_rest_map( + const axutil_env_t *env, + axutil_hash_t *rest_map, + axis2_char_t *live_url, + axutil_array_list_t *param_keys, + axutil_array_list_t *param_values); + +/* build the restmap recursively - internal function*/ +axis2_status_t AXIS2_CALL +axis2_core_utils_internal_build_rest_map_recursively( + const axutil_env_t * env, + axis2_char_t * url, + axutil_core_utils_map_internal_t *mapping_struct, + axis2_op_t *op_desc); + +/* infer op from the live url recursively */ +axis2_op_t *AXIS2_CALL +axis2_core_utils_internal_infer_op_from_rest_map_recursively( + const axutil_env_t *env, + const axutil_core_utils_map_internal_t *parent_mapping_struct, + axis2_char_t *live_url, + axutil_array_list_t *param_keys, + axutil_array_list_t *param_values); + +/* match a pattern with a url component */ +axis2_status_t +axis2_core_utils_match_url_component_with_pattern( + const axutil_env_t *env, + axis2_char_t *pattern, + axis2_char_t *url_component, + axutil_array_list_t *param_keys, + axutil_array_list_t *param_values); + +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_ctx_t *ctx = NULL; + axis2_msg_ctx_t *new_msg_ctx = NULL; + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_transport_in_desc_t *transport_in = NULL; + axis2_transport_out_desc_t *transport_out = NULL; + axis2_msg_info_headers_t *old_msg_info_headers = NULL; + axis2_msg_info_headers_t *msg_info_headers = NULL; + axis2_endpoint_ref_t *reply_to = NULL; + axis2_endpoint_ref_t *fault_to = NULL; + axis2_endpoint_ref_t *to = NULL; + const axis2_char_t *msg_id = NULL; + axis2_relates_to_t *relates_to = NULL; + const axis2_char_t *action = NULL; + axis2_op_ctx_t *op_ctx = NULL; + axis2_svc_ctx_t *svc_ctx = NULL; + axis2_bool_t doing_rest = AXIS2_FALSE; + axis2_bool_t doing_mtom = AXIS2_FALSE; + axis2_bool_t server_side = AXIS2_FALSE; + axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; + axis2_char_t *msg_uuid = NULL; + axutil_stream_t *out_stream = NULL; + axutil_param_t *expose_headers_param = NULL; + axis2_bool_t expose_headers = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, in_msg_ctx, NULL); + + conf_ctx = axis2_msg_ctx_get_conf_ctx(in_msg_ctx, env); + transport_in = axis2_msg_ctx_get_transport_in_desc(in_msg_ctx, env); + transport_out = axis2_msg_ctx_get_transport_out_desc(in_msg_ctx, env); + + new_msg_ctx = axis2_msg_ctx_create(env, conf_ctx, transport_in, transport_out); + if(!new_msg_ctx) + { + return NULL; + } + + if(transport_in) + { + expose_headers_param = axutil_param_container_get_param( + axis2_transport_in_desc_param_container(transport_in, env), env, AXIS2_EXPOSE_HEADERS); + } + if(expose_headers_param) + { + axis2_char_t *expose_headers_value = NULL; + expose_headers_value = axutil_param_get_value(expose_headers_param, env); + if(expose_headers_value && 0 == axutil_strcasecmp(expose_headers_value, AXIS2_VALUE_TRUE)) + { + expose_headers = AXIS2_TRUE; + } + } + if(expose_headers) + { + axis2_msg_ctx_set_transport_headers(new_msg_ctx, env, + axis2_msg_ctx_extract_transport_headers(in_msg_ctx, env)); + } + axis2_msg_ctx_set_http_accept_record_list(new_msg_ctx, env, + axis2_msg_ctx_extract_http_accept_record_list(in_msg_ctx, env)); + axis2_msg_ctx_set_http_accept_charset_record_list(new_msg_ctx, env, + axis2_msg_ctx_extract_http_accept_charset_record_list(in_msg_ctx, env)); + axis2_msg_ctx_set_http_accept_language_record_list(new_msg_ctx, env, + axis2_msg_ctx_extract_http_accept_language_record_list(in_msg_ctx, env)); + + old_msg_info_headers = axis2_msg_ctx_get_msg_info_headers(in_msg_ctx, env); + if(!old_msg_info_headers) + { + return NULL; + } + msg_info_headers = axis2_msg_ctx_get_msg_info_headers(new_msg_ctx, env); + if(!msg_info_headers) + { + /* if there is no msg info header in ew msg ctx, then create one */ + msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL); + if(!msg_info_headers) + return NULL; + axis2_msg_ctx_set_msg_info_headers(new_msg_ctx, env, msg_info_headers); + } + + msg_uuid = axutil_uuid_gen(env); + axis2_msg_info_headers_set_message_id(msg_info_headers, env, msg_uuid); + if(msg_uuid) + { + AXIS2_FREE(env->allocator, msg_uuid); + msg_uuid = NULL; + } + reply_to = axis2_msg_info_headers_get_reply_to(old_msg_info_headers, env); + axis2_msg_info_headers_set_to(msg_info_headers, env, reply_to); + + fault_to = axis2_msg_info_headers_get_fault_to(old_msg_info_headers, env); + axis2_msg_info_headers_set_fault_to(msg_info_headers, env, fault_to); + + to = axis2_msg_info_headers_get_to(old_msg_info_headers, env); + axis2_msg_info_headers_set_from(msg_info_headers, env, to); + + msg_id = axis2_msg_info_headers_get_message_id(old_msg_info_headers, env); + + /* we can create with default Relates to namespace. + Actual namespace based on addressing version will be created in addressing out handler */ + relates_to = axis2_relates_to_create(env, msg_id, + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE); + axis2_msg_info_headers_set_relates_to(msg_info_headers, env, relates_to); + + action = axis2_msg_info_headers_get_action(old_msg_info_headers, env); + axis2_msg_info_headers_set_action(msg_info_headers, env, action); + + op_ctx = axis2_msg_ctx_get_op_ctx(in_msg_ctx, env); + axis2_msg_ctx_set_op_ctx(new_msg_ctx, env, op_ctx); + + svc_ctx = axis2_msg_ctx_get_svc_ctx(in_msg_ctx, env); + axis2_msg_ctx_set_svc_ctx(new_msg_ctx, env, svc_ctx); + + ctx = axis2_msg_ctx_get_base(in_msg_ctx, env); + if(ctx) + { + axis2_ctx_t *new_ctx = axis2_msg_ctx_get_base(new_msg_ctx, env); + if(new_ctx) + { + axis2_ctx_set_property_map(new_ctx, env, axis2_ctx_get_property_map(ctx, env)); + } + } + + out_stream = axis2_msg_ctx_get_transport_out_stream(in_msg_ctx, env); + axis2_msg_ctx_set_transport_out_stream(new_msg_ctx, env, out_stream); + axis2_msg_ctx_set_out_transport_info(new_msg_ctx, env, axis2_msg_ctx_get_out_transport_info( + in_msg_ctx, env)); + + /* Setting the character set encoding */ + doing_rest = axis2_msg_ctx_get_doing_rest(in_msg_ctx, env); + axis2_msg_ctx_set_doing_rest(new_msg_ctx, env, doing_rest); + + doing_mtom = axis2_msg_ctx_get_doing_mtom(in_msg_ctx, env); + axis2_msg_ctx_set_doing_mtom(new_msg_ctx, env, doing_mtom); + + server_side = axis2_msg_ctx_get_server_side(in_msg_ctx, env); + axis2_msg_ctx_set_server_side(new_msg_ctx, env, server_side); + + svc_grp_ctx = axis2_msg_ctx_get_svc_grp_ctx(in_msg_ctx, env); + axis2_msg_ctx_set_svc_grp_ctx(new_msg_ctx, env, svc_grp_ctx); + + axis2_msg_ctx_set_is_soap_11(new_msg_ctx, env, axis2_msg_ctx_get_is_soap_11(in_msg_ctx, env)); + axis2_msg_ctx_set_keep_alive(new_msg_ctx, env, axis2_msg_ctx_is_keep_alive(in_msg_ctx, env)); + + axis2_msg_ctx_set_charset_encoding(new_msg_ctx, env, axis2_msg_ctx_get_charset_encoding( + in_msg_ctx, env)); + + return new_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_msg_info_headers_t *msg_info_headers = NULL; + if(!out_msg_ctx) + return; + + msg_info_headers = axis2_msg_ctx_get_msg_info_headers(out_msg_ctx, env); + if(msg_info_headers) + { + axis2_msg_info_headers_set_to(msg_info_headers, env, NULL); + axis2_msg_info_headers_set_fault_to(msg_info_headers, env, NULL); + axis2_msg_info_headers_set_from(msg_info_headers, env, NULL); + axis2_msg_info_headers_set_reply_to(msg_info_headers, env, NULL); + } + + axis2_msg_ctx_set_op_ctx(out_msg_ctx, env, NULL); + axis2_msg_ctx_set_svc_ctx(out_msg_ctx, env, NULL); + axis2_msg_ctx_reset_transport_out_stream(out_msg_ctx, env); + axis2_msg_ctx_reset_out_transport_info(out_msg_ctx, env); + axis2_msg_ctx_set_svc_grp_ctx(out_msg_ctx, env, NULL); + + return; +} + +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) +{ + axutil_qname_t *ret_qname = NULL; + AXIS2_PARAM_CHECK(env->error, name, NULL); + + if(version && 0 != axutil_strlen(version)) + { + axis2_char_t *mod_name1 = NULL; + axis2_char_t *mod_name = NULL; + mod_name1 = axutil_stracat(env, name, "-"); + if(!mod_name1) + { + return NULL; + } + mod_name = axutil_stracat(env, mod_name1, version); + if(!mod_name) + { + AXIS2_FREE(env->allocator, mod_name1); + mod_name1 = NULL; + return NULL; + } + ret_qname = axutil_qname_create(env, mod_name, NULL, NULL); + AXIS2_FREE(env->allocator, mod_name); + AXIS2_FREE(env->allocator, mod_name1); + return ret_qname; + } + ret_qname = axutil_qname_create(env, name, NULL, NULL); + return ret_qname; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_core_utils_calculate_default_module_version( + const axutil_env_t * env, + axutil_hash_t * modules_map, + axis2_conf_t * axis_conf) +{ + axutil_hash_t *default_modules = NULL; + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + AXIS2_PARAM_CHECK(env->error, modules_map, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, axis_conf, AXIS2_FAILURE); + + default_modules = axutil_hash_make(env); + if(!default_modules) + { + return AXIS2_FAILURE; + } + for(hi = axutil_hash_first(modules_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axis2_module_desc_t *mod_desc = NULL; + + axutil_hash_this(hi, NULL, NULL, &val); + mod_desc = (axis2_module_desc_t *)val; + if(mod_desc) + { + const axutil_qname_t *module_qname = NULL; + module_qname = axis2_module_desc_get_qname(mod_desc, env); + if(module_qname) + { + axis2_char_t *mod_name_with_ver = NULL; + mod_name_with_ver = axutil_qname_get_localpart(module_qname, env); + if(mod_name_with_ver) + { + axis2_char_t *module_name_str = NULL; + axis2_char_t *module_ver_str = NULL; + axis2_char_t *current_def_ver = NULL; + + module_name_str = axis2_core_utils_get_module_name(env, mod_name_with_ver); + if(!module_name_str) + { + return AXIS2_FAILURE; + } + module_ver_str = axis2_core_utils_get_module_version(env, mod_name_with_ver); + current_def_ver = axutil_hash_get(default_modules, module_name_str, + AXIS2_HASH_KEY_STRING); + if(current_def_ver) + { + if(module_ver_str && AXIS2_TRUE == axis2_core_utils_is_latest_mod_ver(env, + module_ver_str, current_def_ver)) + { + axutil_hash_set(default_modules, module_name_str, + AXIS2_HASH_KEY_STRING, module_ver_str); + } + else + { + if(module_name_str) + { + AXIS2_FREE(env->allocator, module_name_str); + } + if(module_ver_str) + { + AXIS2_FREE(env->allocator, module_ver_str); + } + } + } + else + { + axutil_hash_set(default_modules, module_name_str, AXIS2_HASH_KEY_STRING, + module_ver_str); + } + + if(module_name_str) + { + AXIS2_FREE(env->allocator, module_name_str); + } + } + } + } + val = NULL; + } + + hi = NULL; + val = NULL; + for(hi = axutil_hash_first(default_modules, env); hi; hi = axutil_hash_next(env, hi)) + { + void *key_string = NULL; + axutil_hash_this(hi, (const void **)&key_string, NULL, &val); + if(key_string && NULL != val) + { + axis2_conf_add_default_module_version(axis_conf, env, (axis2_char_t *)key_string, + (axis2_char_t *)val); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Added default module" + " version : %s for module : %s", (axis2_char_t *)val, (axis2_char_t *)key_string); + } + } + + if(default_modules) + { + axutil_hash_free(default_modules, env); + default_modules = NULL; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_core_utils_get_module_name( + const axutil_env_t * env, + axis2_char_t * module_name) +{ + axis2_char_t version_seperator = '-'; + axis2_char_t *name = NULL; + axis2_char_t *version_sep_loc = NULL; + + AXIS2_PARAM_CHECK(env->error, module_name, NULL); + + name = axutil_strdup(env, module_name); + if(!name) + { + return NULL; + } + version_sep_loc = axutil_rindex(name, version_seperator); + if(version_sep_loc) + { + *version_sep_loc = '\0'; + } + return 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_char_t version_seperator = '-'; + axis2_char_t *version_sep_loc = NULL; + + AXIS2_PARAM_CHECK(env->error, module_name, NULL); + + version_sep_loc = axutil_rindex(module_name, version_seperator); + if(version_sep_loc) + { + return axutil_strdup(env, version_sep_loc + sizeof(axis2_char_t)); + } + return NULL; +} + +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) +{ + double cur_ver = 0.0; + double mod_ver = 0.0; + AXIS2_PARAM_CHECK(env->error, module_ver, AXIS2_FALSE); + AXIS2_PARAM_CHECK(env->error, current_def_ver, AXIS2_FALSE); + cur_ver = atof(current_def_ver); + mod_ver = atof(module_ver); + if(mod_ver > cur_ver) + { + return AXIS2_TRUE; + } + return AXIS2_FAILURE; +} + +/* build the rest map - external function */ +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_char_t *first_delimitter = NULL; + axis2_char_t *next_level_url = NULL; + axis2_char_t *mapping_key = NULL; + axutil_core_utils_map_internal_t *mapping_struct = NULL; + axis2_status_t status = AXIS2_SUCCESS; + axis2_char_t *bracket_start = NULL; + + first_delimitter = axutil_strchr(url, '/'); + + if(first_delimitter) + { + /* if there is another recursive level, + this will get the url of that level */ + next_level_url = first_delimitter + 1; + *first_delimitter = '\0'; + } + + if((bracket_start = axutil_strchr(url, '{'))) + { + /* we support multiple param per url component, + but we validate only one param */ + if(axutil_strchr(bracket_start, '}')) + { + /* this is validated */ + } + + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid URL Format, no closing bracket in declaring parameters"); + return AXIS2_FAILURE; + } + } + + /* only constants are allowed in this level, so here url become the mapping_key */ + mapping_key = url; + + if(*mapping_key == '\0') /* empty mapping key */ + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid URL Format: empty mapping key"); + return AXIS2_FAILURE; + } + + /* retrieve or create the mapping structure for the key*/ + mapping_struct = axutil_hash_get(rest_map, mapping_key, AXIS2_HASH_KEY_STRING); + if(!mapping_struct) + { + mapping_struct = (axutil_core_utils_map_internal_t*)AXIS2_MALLOC(env->allocator, + sizeof(axutil_core_utils_map_internal_t)); + if(!mapping_struct) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + return AXIS2_FAILURE; + + } + memset(mapping_struct, 0, sizeof(axutil_core_utils_map_internal_t)); + + mapping_key = axutil_strdup(env, mapping_key); + axutil_hash_set(rest_map, mapping_key, AXIS2_HASH_KEY_STRING, mapping_struct); + } + + if(!next_level_url) + { + /* if no next level url, put the op_desc in right this level */ + if(mapping_struct->op_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DUPLICATE_URL_REST_MAPPING, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Duplicate URL Mapping found"); + return AXIS2_FAILURE; + } + mapping_struct->op_desc = op_desc; + } + else + { + /* we have to build the map_internal structure recursively */ + status = axis2_core_utils_internal_build_rest_map_recursively(env, next_level_url, + mapping_struct, op_desc); + } + + return status; + +} + +/* build the restmap recursively - internal function*/ +axis2_status_t AXIS2_CALL +axis2_core_utils_internal_build_rest_map_recursively( + const axutil_env_t * env, + axis2_char_t * url, + axutil_core_utils_map_internal_t *parent_mapping_struct, + axis2_op_t *op_desc) +{ + + /* Here url is expected to be in the form + {student}/marks/{subject} or + marks/{subject} + */ + + axis2_char_t *first_delimitter = NULL; + axis2_char_t *next_level_url = NULL; + axis2_char_t *mapping_key = NULL; + axutil_core_utils_map_internal_t *mapping_struct = NULL; + axutil_hash_t *cur_level_rest_map = NULL; + axis2_status_t status = AXIS2_SUCCESS; + axis2_char_t *bracket_start = NULL; + + axis2_bool_t is_key_a_param = AXIS2_FALSE; + + first_delimitter = axutil_strchr(url, '/'); + + if(first_delimitter) + { + /* if there is another recurisive level, + this will get the url of that level */ + next_level_url = first_delimitter + 1; + *first_delimitter = '\0'; + } + + if((bracket_start = axutil_strchr(url, '{'))) + { + /* we support multiple param per url component, + but we validate only one param */ + if(axutil_strchr(bracket_start, '}')) + { + is_key_a_param = AXIS2_TRUE; + } + + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid URL Format, no closing bracket in declaring parameters"); + return AXIS2_FAILURE; + } + } + + /* here the url become the mapping_key */ + mapping_key = url; + + if(*mapping_key == '\0') /* empty mappng key */ + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid URL Format: empty mapping key"); + return AXIS2_FAILURE; + } + + if(is_key_a_param) + { + /* set the rest map as the params_map */ + if(parent_mapping_struct->params_map == NULL) + { + parent_mapping_struct->params_map = axutil_hash_make(env); + if(!parent_mapping_struct->params_map) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + return AXIS2_FAILURE; + } + } + cur_level_rest_map = parent_mapping_struct->params_map; + } + else + { + /* set the rest map as the consts_map */ + if(parent_mapping_struct->consts_map == NULL) + { + parent_mapping_struct->consts_map = axutil_hash_make(env); + if(!parent_mapping_struct->consts_map) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + return AXIS2_FAILURE; + } + } + cur_level_rest_map = parent_mapping_struct->consts_map; + } + + /* retrieve or create the maping structure for the key*/ + mapping_struct = axutil_hash_get(cur_level_rest_map, mapping_key, AXIS2_HASH_KEY_STRING); + if(!mapping_struct) + { + mapping_struct = (axutil_core_utils_map_internal_t*)AXIS2_MALLOC(env->allocator, + sizeof(axutil_core_utils_map_internal_t)); + if(!mapping_struct) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + return AXIS2_FAILURE; + + } + memset(mapping_struct, 0, sizeof(axutil_core_utils_map_internal_t)); + + mapping_key = axutil_strdup(env, mapping_key); + axutil_hash_set(cur_level_rest_map, mapping_key, AXIS2_HASH_KEY_STRING, mapping_struct); + } + + if(!next_level_url) + { + /* if no next level url, put the op_desc in right this level */ + if(mapping_struct->op_desc) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DUPLICATE_URL_REST_MAPPING, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Duplicate URL Mapping found"); + return AXIS2_FAILURE; + } + mapping_struct->op_desc = op_desc; + } + else + { + /* we have to build the map_internal structure recursively */ + status = axis2_core_utils_internal_build_rest_map_recursively(env, next_level_url, + mapping_struct, op_desc); + } + + return status; +} + +/* free the rest map recursively */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_core_utils_free_rest_map( + const axutil_env_t *env, + axutil_hash_t *rest_map) +{ + + axutil_hash_index_t *hi = NULL; + const void *key = NULL; + void *val = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + for(hi = axutil_hash_first(rest_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, &key, NULL, &val); + + if(val) + { + axutil_core_utils_map_internal_t *mapping_struct = NULL; + mapping_struct = (axutil_core_utils_map_internal_t*)val; + + /* freeing the consts_map and params_map */ + if(mapping_struct->consts_map) + { + axis2_core_utils_free_rest_map(env, mapping_struct->consts_map); + } + + if(mapping_struct->params_map) + { + axis2_core_utils_free_rest_map(env, mapping_struct->params_map); + } + AXIS2_FREE(env->allocator, mapping_struct); + } + + if(key) + { + AXIS2_FREE(env->allocator, (axis2_char_t *)key); + key = NULL; + } + } + axutil_hash_free(rest_map, env); + return status; +} + +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_char_t *addition_params_str = NULL; + axis2_char_t *adjusted_local_url = NULL; + + axis2_char_t *live_mapping_url = NULL; + axis2_char_t *local_url = NULL; + + axis2_op_t *op = NULL; + + int key_len = 0; + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Checking for operation using " + "REST HTTP Location fragment : %s", location); + + /* we are creating a dup of the location */ + local_url = (axis2_char_t*)axutil_strdup(env, location); + if(!local_url) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create the live rest mapping url"); + return NULL; + } + + /* checking the existence of the addition parameters + after the question mark '?' */ + addition_params_str = strchr(local_url, '?'); + if(addition_params_str) + { + *addition_params_str = '\0'; + addition_params_str++; + } + + /* if the first character is '/' ignore that */ + if(*local_url == '/') + { + adjusted_local_url = local_url + 1; + } + else + { + adjusted_local_url = local_url; + } + + /* now create the mapping url */ + key_len = axutil_strlen(method) + axutil_strlen(adjusted_local_url) + 2; + + live_mapping_url + = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * key_len)); + + if(!live_mapping_url) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create the live rest mapping url"); + AXIS2_FREE(env->allocator, local_url); + return NULL; + } + + sprintf(live_mapping_url, "%s:%s", method, adjusted_local_url); + + op = axis2_core_utils_infer_op_from_parent_rest_map(env, axis2_svc_get_rest_map(svc, env), + live_mapping_url, param_keys, param_values); + + if(op) + { + axis2_char_t *params_str; + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "Operation found using target endpoint uri fragment"); + + /* here we are going to extract out the additional parameters + * put after '?' mark */ + params_str = addition_params_str; + while(params_str && *params_str != '\0') + { + axis2_char_t *next_params_str = NULL; + axis2_char_t *key_value_seperator = NULL; + + axis2_char_t *key = NULL; + axis2_char_t *value = NULL; + + /* we take one parameter pair to the params_str */ + next_params_str = strchr(params_str, '&'); + if(next_params_str) + { + *next_params_str = '\0'; + } + + key_value_seperator = strchr(params_str, '='); + if(key_value_seperator) + { + /* devide the key value pair */ + *key_value_seperator = '\0'; + key = params_str; + value = key_value_seperator + 1; + } + else + { + /* there is no '=' symbol, that mean only the key exist */ + key = params_str; + } + if(key) + { + key = axutil_strdup(env, key); + axutil_array_list_add(param_keys, env, key); + } + if(value) + { + value = axutil_strdup(env, value); + axutil_array_list_add(param_values, env, value); + } + + if(next_params_str) + { + /* if there was an '&' character then */ + params_str = next_params_str + 1; + } + else + { + params_str = NULL; /* just to end the loop */ + } + } + } + + if(live_mapping_url) + { + AXIS2_FREE(env->allocator, live_mapping_url); + } + if(local_url) + { + AXIS2_FREE(env->allocator, local_url); + } + return op; +} + +/* infer op from the live url */ +axis2_op_t * +axis2_core_utils_infer_op_from_parent_rest_map( + const axutil_env_t *env, + axutil_hash_t *rest_map, + axis2_char_t *live_url, + axutil_array_list_t *param_keys, + axutil_array_list_t *param_values) +{ + axis2_char_t *first_delimitter = NULL; + axis2_char_t *next_level_url = NULL; + axis2_char_t *url_component = NULL; + + axis2_op_t *op_desc = NULL; + axutil_core_utils_map_internal_t *mapping_struct = NULL; + + first_delimitter = axutil_strchr(live_url, '/'); + + if(first_delimitter) + { + /* if there is another recursive level, + this will get the url of that level */ + next_level_url = first_delimitter + 1; + *first_delimitter = '\0'; + } + + /* so live url is the url_component */ + url_component = live_url; + + /* check it in the hash map */ + mapping_struct = (axutil_core_utils_map_internal_t*)axutil_hash_get(rest_map, url_component, + AXIS2_HASH_KEY_STRING); + + if(mapping_struct) + { + if(!next_level_url) + { + /* if no level exists, find it here */ + op_desc = mapping_struct->op_desc; + } + else + { + + op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env, + mapping_struct, next_level_url, param_keys, param_values); + } + } + if(!op_desc) + { + /* if the url is not mapped to the given constant url + * we have to match it with the url pattern */ + + axutil_hash_index_t *hi = NULL; + const void *key = NULL; + void *val = NULL; + axis2_status_t matched_status = AXIS2_FAILURE; + + for(hi = axutil_hash_first(rest_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, &key, NULL, &val); + + if(key == url_component) + { + continue; /* skip the already checked key */ + } + if(key && val) + { + axis2_char_t *hash_key = (axis2_char_t*)key; + axis2_char_t *dup_url_component = NULL; + axis2_char_t *dup_pattern = NULL; + + /* temporary param keys and values for each entry */ + axutil_array_list_t *tmp_param_keys = NULL; + axutil_array_list_t *tmp_param_values = NULL; + + tmp_param_keys = axutil_array_list_create(env, 10); + if(!tmp_param_keys) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + + return NULL; + } + tmp_param_values = axutil_array_list_create(env, 10); + if(!tmp_param_values) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + axutil_array_list_free(tmp_param_keys, env); + return NULL; + } + + dup_url_component = axutil_strdup(env, url_component); + if(!dup_url_component) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + axutil_array_list_free(tmp_param_keys, env); + axutil_array_list_free(tmp_param_values, env); + return NULL; + } + dup_pattern = axutil_strdup(env, hash_key); + if(!dup_pattern) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + axutil_array_list_free(tmp_param_keys, env); + axutil_array_list_free(tmp_param_values, env); + AXIS2_FREE(env->allocator, dup_url_component); + return NULL; + } + + matched_status = axis2_core_utils_match_url_component_with_pattern(env, + dup_pattern, dup_url_component, tmp_param_keys, tmp_param_values); + + AXIS2_FREE(env->allocator, dup_url_component); + AXIS2_FREE(env->allocator, dup_pattern); + + if(matched_status == AXIS2_SUCCESS && val) + { + mapping_struct = (axutil_core_utils_map_internal_t*)val; + + if(!next_level_url) + { + op_desc = mapping_struct->op_desc; + } + else + { + + op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env, + mapping_struct, next_level_url, tmp_param_keys, tmp_param_values); + } + if(op_desc) + { + /* we are done, the url is matched with a pattern */ + /* but before leaving should merge the param arrays */ + + int i = 0; + void *param_key = NULL; + void *param_value = NULL; + + for(i = 0; i < axutil_array_list_size(tmp_param_keys, env); i++) + { + /* size(tmp_param_keys) == size(tmp_param_values) */ + param_key = axutil_array_list_get(tmp_param_keys, env, i); + param_value = axutil_array_list_get(tmp_param_values, env, i); + + /* add it to original array */ + axutil_array_list_add(param_keys, env, param_key); + axutil_array_list_add(param_values, env, param_value); + + } + /* since of is found, no more searches needed */ + break; + } + } + /* freeing the temporary arrays */ + axutil_array_list_free(tmp_param_keys, env); + axutil_array_list_free(tmp_param_values, env); + } + } + } + + if(!op_desc) + { + /* no more to look up */ + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "REST maping structure is NULL for the accessed URL"); + return NULL; + } + + return op_desc; +} + +/* infer op from the live url recursively */ +axis2_op_t *AXIS2_CALL +axis2_core_utils_internal_infer_op_from_rest_map_recursively( + const axutil_env_t *env, + const axutil_core_utils_map_internal_t *parent_mapping_struct, + axis2_char_t *live_url, + axutil_array_list_t *param_keys, + axutil_array_list_t *param_values) +{ + + axis2_char_t *first_delimitter = NULL; + axis2_char_t *next_level_url = NULL; + axis2_char_t *url_component = NULL; + + axis2_op_t *op_desc = NULL; + axutil_core_utils_map_internal_t *child_mapping_struct = NULL; + + axutil_hash_index_t *hi = NULL; + const void *key = NULL; + void *val = NULL; + + first_delimitter = axutil_strchr(live_url, '/'); + + if(first_delimitter) + { + /* if there is another recurisive level, + this will get the url of that level */ + next_level_url = first_delimitter + 1; + *first_delimitter = '\0'; + } + + /* so live url is the url_component */ + url_component = live_url; + + /* first check the url component in the constants array list */ + if(parent_mapping_struct->consts_map) + { + child_mapping_struct = axutil_hash_get(parent_mapping_struct->consts_map, url_component, + AXIS2_HASH_KEY_STRING); + } + + /* if the url component exists in the consts_map, go through it inside */ + + if(child_mapping_struct) + { + if(!next_level_url) + { + /* there is no another level, so the op should be here */ + + op_desc = child_mapping_struct->op_desc; + + if(!op_desc) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "The operation descriptor not found constant given in the url"); + } + /* rather than returning NULL we continue to search params_map */ + + } + else + { + + op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env, + child_mapping_struct, next_level_url, param_keys, param_values); + } + } + + if(op_desc) + { + /* if the op for the accessed url found, no further searching is needed */ + return op_desc; + } + + /* if it is not found in the consts_map we have to assume it is in a params_map */ + + if(!parent_mapping_struct->params_map) + { + /* wrong operation, abort to continue to let calling function to check other operations */ + if(first_delimitter) + { + /* restore the delimmiters */ + *first_delimitter = '/'; + } + return NULL; + } + + for(hi = axutil_hash_first(parent_mapping_struct->params_map, env); hi; hi = axutil_hash_next( + env, hi)) + { + axutil_hash_this(hi, &key, NULL, &val); + + if(key && val) + { + int i = 0; + axis2_char_t *hash_key = (axis2_char_t*)key; + axis2_status_t matched_status = AXIS2_SUCCESS; + axis2_char_t *dup_url_component = NULL; + axis2_char_t *dup_pattern = NULL; + + /* temporary param keys and values for each entry */ + axutil_array_list_t *tmp_param_keys; + axutil_array_list_t *tmp_param_values; + + tmp_param_keys = axutil_array_list_create(env, 10); + if(!tmp_param_keys) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + + return NULL; + } + tmp_param_values = axutil_array_list_create(env, 10); + if(!tmp_param_values) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + axutil_array_list_free(tmp_param_keys, env); + return NULL; + } + + dup_url_component = axutil_strdup(env, url_component); + if(!dup_url_component) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + axutil_array_list_free(tmp_param_keys, env); + axutil_array_list_free(tmp_param_values, env); + return NULL; + } + dup_pattern = axutil_strdup(env, hash_key); + if(!dup_pattern) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + axutil_array_list_free(tmp_param_keys, env); + axutil_array_list_free(tmp_param_values, env); + AXIS2_FREE(env->allocator, dup_url_component); + return NULL; + } + + matched_status = axis2_core_utils_match_url_component_with_pattern(env, dup_pattern, + dup_url_component, tmp_param_keys, tmp_param_values); + + AXIS2_FREE(env->allocator, dup_url_component); + AXIS2_FREE(env->allocator, dup_pattern); + + if(matched_status == AXIS2_SUCCESS) + { + child_mapping_struct = (axutil_core_utils_map_internal_t*)val; + + if(!next_level_url) + { + /* there is no another level, so the op should be here */ + op_desc = child_mapping_struct->op_desc; + + } + else + { + + /* if there is next level, we should check that level too */ + op_desc = axis2_core_utils_internal_infer_op_from_rest_map_recursively(env, + child_mapping_struct, next_level_url, tmp_param_keys, tmp_param_values); + } + + if(op_desc) + { + /* the operation is found */ + /* but before leaving should merge the param arrays */ + + int i = 0; + void *param_key = NULL; + void *param_value = NULL; + for(i = 0; i < axutil_array_list_size(tmp_param_keys, env); i++) + { + /* size(tmp_param_keys) == size(tmp_param_values) */ + param_key = axutil_array_list_get(tmp_param_keys, env, i); + param_value = axutil_array_list_get(tmp_param_values, env, i); + + /* add it to original array */ + axutil_array_list_add(param_keys, env, param_key); + axutil_array_list_add(param_values, env, param_value); + + } + + /* freeing the temporary arrays */ + axutil_array_list_free(tmp_param_keys, env); + axutil_array_list_free(tmp_param_values, env); + /* since of is found, no more searches needed */ + break; + } + } + + /* if we come here => op is not yet found */ + /* just freeing the temp key and value arrays */ + for(i = 0; i < axutil_array_list_size(tmp_param_keys, env); i++) + { + void *value = axutil_array_list_get(tmp_param_keys, env, i); + if(value) + { + AXIS2_FREE(env->allocator, value); + } + } + for(i = 0; i < axutil_array_list_size(tmp_param_values, env); i++) + { + void *value = axutil_array_list_get(tmp_param_values, env, i); + if(value) + { + AXIS2_FREE(env->allocator, value); + } + } + axutil_array_list_free(tmp_param_keys, env); + axutil_array_list_free(tmp_param_values, env); + } + } + + if(!op_desc) + { + /* this is not an error, since the calling function + may find another opertion match with the url */ + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, + "The operation descriptor not found for the accessed URL"); + + if(first_delimitter) + { + /* restore the delimmiters */ + *first_delimitter = '/'; + } + } + return op_desc; +} + +/* match a pattern with a url component */ +axis2_status_t +axis2_core_utils_match_url_component_with_pattern( + const axutil_env_t *env, + axis2_char_t *pattern, + axis2_char_t *url_component, + axutil_array_list_t *param_keys, + axutil_array_list_t *param_values) +{ + axutil_array_list_t *const_components = NULL; + axis2_char_t *c = NULL; + axis2_char_t *url_c = NULL; + axis2_char_t *pattern_c = NULL; + axis2_char_t *const_part = NULL; + axis2_char_t *param_part = NULL; + axis2_char_t *param_value = NULL; + axis2_status_t status = AXIS2_SUCCESS; + /* here the state can have following values + 0 - inside a constant + 1 - inside a param + */ + int loop_state = 0; + int i = 0; + int pattern_ending_with_param = 0; + + /* the constant that undergoing matching */ + int matching_constant_index = 0; + axis2_char_t *matching_constant = NULL; + + /* dividing the pattern to consts */ + const_components = axutil_array_list_create(env, 10); + if(!const_components) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + } + /* check whether the pattern ending with a param */ + if(*(pattern + axutil_strlen(pattern) - 1) == '}') + { + pattern_ending_with_param = 1; + } + + const_part = pattern; + /* a parse to fil the const array and key array */ + for(c = pattern; c && *c != '\0'; c++) + { + if(loop_state == 0) + { + /* inside a constant */ + if(*c == '{') + { + if(const_part == c) + { + /* no const part */ + } + else + { + /* add the constant */ + *c = '\0'; + const_part = axutil_strdup(env, const_part); + if(!const_part) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + + status = AXIS2_FAILURE; + break; + + } + axutil_array_list_add(const_components, env, const_part); + + } + param_part = c + 1; /* start the param */ + loop_state = 1; /* moving to the param from next iteration */ + } + else if(*c == '}') + { + /* invalid state */ + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s", + url_component); + + status = AXIS2_FAILURE; + break; + } + } + else + { + /* inside a param */ + if(*c == '}') + { + if(*(c + 1) == '{') /* you can not have two params without a constant in between */ + { + /* invalid state */ + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR( + env->log, + AXIS2_LOG_SI, + "Error in parsing the url for %s, Please put constant between 2 parameters", + url_component); + + status = AXIS2_FAILURE; + break; + } + if(param_part == c) + { + /* no param part */ + } + else + { + /* add the param */ + *c = '\0'; + param_part = axutil_strdup(env, param_part); + + if(param_part == NULL) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + status = AXIS2_FAILURE; + break; + } + axutil_array_list_add(param_keys, env, param_part); + + const_part = c + 1; /* start the const */ + } + loop_state = 0; /* moving to the const from next iteration */ + } + else if(*c == '{') + { + /* invalid state */ + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s", + url_component); + + status = AXIS2_FAILURE; + break; + + } + } + } + /* loop should stop in state 0 */ + if(loop_state != 0) + { + status = AXIS2_FAILURE; + } + + if(const_part != c) + { + /* add the tailing const */ + const_part = axutil_strdup(env, const_part); + if(!const_part) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + status = AXIS2_FAILURE; + } + axutil_array_list_add(const_components, env, const_part); + } + + if(axutil_array_list_size(const_components, env) == 0 && status == AXIS2_SUCCESS) + { + /* no constants mean, the url componenent itself is the value */ + url_component = axutil_strdup(env, url_component); + if(url_component) + { + axutil_array_list_add(param_values, env, url_component); + + /* free the empty const array */ + + axutil_array_list_free(const_components, env); + return AXIS2_SUCCESS; + } + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + status = AXIS2_FAILURE; + + } + + if(status == AXIS2_FAILURE) + { + /* invalid state */ + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s", url_component); + + /* free the const array */ + for(i = 0; i < axutil_array_list_size(const_components, env); i++) + { + void *value; + value = axutil_array_list_get(const_components, env, i); + + AXIS2_FREE(env->allocator, value); + } + + axutil_array_list_free(const_components, env); + + return status; + } + + /* we are tracking the loop_state here too - this is useful only to track start*/ + /* we are using the param_value part to track the matching param value */ + if(*pattern != '{') + { + /* starting_with_constant */ + loop_state = 0; + param_value = NULL; + } + else + { + /* starting_with_param */ + loop_state = 1; + param_value = url_component; + + } + + matching_constant_index = 0; + matching_constant = axutil_array_list_get(const_components, env, 0); + + /* now parse the url component */ + for(url_c = url_component; *url_c != '\0' && status == AXIS2_SUCCESS && matching_constant + != NULL; url_c++) + { + axis2_char_t *tmp_url_c = url_c; + pattern_c = matching_constant; + + while(*tmp_url_c == *pattern_c && *tmp_url_c != '\0' && *pattern_c != '\0') + { + tmp_url_c++; + pattern_c++; + } + + if(*pattern_c == '\0') + { + /* we finised matching the constant pattern successfuly*/ + if(loop_state == 0) + { + /* loop_state => we expected there is a constant */ + } + else + { + /* we expected a param, but the constant is found => + url_c should mark the end of the param */ + if(param_value == NULL) + { + /* unexpected invalid state */ + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_URL_FORMAT, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing the url for %s", + url_component); + status = AXIS2_FAILURE; + } + *url_c = '\0'; + param_value = axutil_strdup(env, param_value); + + if(param_value == NULL) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + status = AXIS2_FAILURE; + break; + } + axutil_array_list_add(param_values, env, param_value); + + } + /* next the param part is starting */ + param_value = tmp_url_c; + + loop_state = 1; /* the end of the constant expects, start of a variable */ + + /* so we found one constant, go for the other */ + matching_constant_index++; + matching_constant = axutil_array_list_get(const_components, env, + matching_constant_index); + + tmp_url_c--; + /* increment the url_c to tmp_url_c */ + url_c = tmp_url_c; + } + else + { + /* pattern not matched */ + if(loop_state == 0) + { + /* we are expected this to be a constant, but it has not happend + * mean: the pattern match failed + */ + status = AXIS2_FAILURE; + break; + } + } + + } + + if(matching_constant_index != axutil_array_list_size(const_components, env)) + { + status = AXIS2_FAILURE; + } + + if(pattern_ending_with_param) + { + if(param_value) + { + param_value = axutil_strdup(env, param_value); + + if(param_value == NULL) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot create internal rest mapping structure"); + status = AXIS2_FAILURE; + } + else + { + axutil_array_list_add(param_values, env, param_value); + } + } + } + else if(*url_c != '\0') + { + /* here the pattern ending is a constant (not a param), and matches all are already made + * but some url part left => this is a not mach */ + status = AXIS2_FAILURE; + } + + /* finally freeing the const array */ + for(i = 0; i < axutil_array_list_size(const_components, env); i++) + { + void *value; + value = axutil_array_list_get(const_components, env, i); + + AXIS2_FREE(env->allocator, value); + } + axutil_array_list_free(const_components, env); + + return status; +} diff --git a/src/modules/Makefile.am b/src/modules/Makefile.am new file mode 100644 index 0000000..8dffd11 --- /dev/null +++ b/src/modules/Makefile.am @@ -0,0 +1 @@ +SUBDIRS = mod_addr mod_log diff --git a/src/modules/mod_addr/Makefile.am b/src/modules/mod_addr/Makefile.am new file mode 100644 index 0000000..3e61c1e --- /dev/null +++ b/src/modules/mod_addr/Makefile.am @@ -0,0 +1,21 @@ +prglibdir=$(prefix)/modules/addressing +prglib_LTLIBRARIES = libaxis2_mod_addr.la +prglib_DATA= module.xml +EXTRA_DIST = module.xml +libaxis2_mod_addr_la_SOURCES = addr_in_handler.c \ + addr_out_handler.c \ + mod_addr.c + +libaxis2_mod_addr_la_LIBADD = $(top_builddir)/axiom/src/om/libaxis2_axiom.la \ + $(top_builddir)/util/src/libaxutil.la + +libaxis2_mod_addr_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include diff --git a/src/modules/mod_addr/addr_in_handler.c b/src/modules/mod_addr/addr_in_handler.c new file mode 100644 index 0000000..2c4de3b --- /dev/null +++ b/src/modules/mod_addr/addr_in_handler.c @@ -0,0 +1,746 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +axis2_status_t AXIS2_CALL +axis2_addr_in_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); + +axis2_bool_t +axis2_addr_in_check_element( + const axutil_env_t * env, + axutil_qname_t * expected_qname, + axutil_qname_t * actual_qname); + +axis2_status_t +axis2_addr_in_extract_svc_grp_ctx_id( + const axutil_env_t * env, + axiom_soap_header_t * soap_header, + axis2_msg_ctx_t * msg_ctx); + +axis2_status_t +axis2_addr_in_extract_ref_params( + const axutil_env_t * env, + axiom_soap_header_t * soap_header, + axis2_msg_info_headers_t * msg_info_headers); + +axis2_status_t +axis2_addr_in_extract_to_epr_ref_params( + const axutil_env_t * env, + axis2_endpoint_ref_t * to_epr, + axiom_soap_header_t * soap_header, + const axis2_char_t * addr_ns); + +axis2_status_t +axis2_addr_in_extract_epr_information( + const axutil_env_t * env, + axiom_soap_header_block_t * soap_header_block, + axis2_endpoint_ref_t * endpoint_ref, + const axis2_char_t * addr_ns); + +axis2_status_t +axis2_addr_in_extract_addr_params( + const axutil_env_t * env, + axiom_soap_header_t * soap_header, + axis2_msg_info_headers_t ** msg_info_headers, + axutil_array_list_t * addr_headers, + const axis2_char_t * addr_ns, + axis2_msg_ctx_t * msg_ctx); + +void +axis2_addr_in_create_fault_envelope( + const axutil_env_t * env, + const axis2_char_t * header_name, + const axis2_char_t * addr_ns_str, + axis2_msg_ctx_t * msg_ctx); + +/******************************************************************************/ + +AXIS2_EXTERN axis2_handler_t *AXIS2_CALL +axis2_addr_in_handler_create( + const axutil_env_t * env, + axutil_string_t * name) +{ + axis2_handler_t *handler = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + handler = axis2_handler_create(env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create addressing in handler"); + return NULL; + } + + /* Handler init is handled by conf loading, so no need to do it here */ + + axis2_handler_set_invoke(handler, env, axis2_addr_in_handler_invoke); + + return handler; +} + +axis2_status_t AXIS2_CALL +axis2_addr_in_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_header_t *soap_header = NULL; + axutil_property_t *property = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + AXIS2_LOG_INFO(env->log, "Starting addressing in handler"); + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + if(soap_envelope) + { + soap_header = axiom_soap_envelope_get_header(soap_envelope, env); + if(soap_header) + { + axutil_array_list_t *addr_headers = NULL; + axis2_ctx_t *ctx = NULL; + axis2_char_t *addr_ns_str = NULL; + axis2_msg_info_headers_t *msg_info_headers = axis2_msg_ctx_get_msg_info_headers( + msg_ctx, env); + + addr_headers = axiom_soap_header_get_header_blocks_with_namespace_uri(soap_header, env, + AXIS2_WSA_NAMESPACE_SUBMISSION); + if(addr_headers) + { + addr_ns_str = axutil_strdup(env, AXIS2_WSA_NAMESPACE_SUBMISSION); + /*status = + axis2_addr_in_extract_addr_submission_info(env, soap_header, + &msg_info_headers, + addr_headers, + msg_ctx);*/ + status = axis2_addr_in_extract_addr_params(env, soap_header, &msg_info_headers, + addr_headers, AXIS2_WSA_NAMESPACE_SUBMISSION, msg_ctx); + } + else + { + addr_headers = axiom_soap_header_get_header_blocks_with_namespace_uri(soap_header, + env, AXIS2_WSA_NAMESPACE); + if(addr_headers) + { + addr_ns_str = axutil_strdup(env, AXIS2_WSA_NAMESPACE); + /*status = axis2_addr_in_extract_addr_final_info(env, + soap_header, + &msg_info_headers, + addr_headers, + msg_ctx);*/ + status = axis2_addr_in_extract_addr_params(env, soap_header, &msg_info_headers, + addr_headers, AXIS2_WSA_NAMESPACE, msg_ctx); + + axis2_addr_in_extract_ref_params(env, soap_header, + axis2_msg_ctx_get_msg_info_headers(msg_ctx, env)); + + } + else + { + /* addressing headers are not present in the SOAP message */ + AXIS2_LOG_INFO(env->log, AXIS2_LOG_SI, + "No Addressing Headers present in the IN message. Addressing In Handler cannot do anything."); + return AXIS2_SUCCESS; /* no addressing heades means addressing not in use */ + } + } + + ctx = axis2_msg_ctx_get_base(msg_ctx, env); + if(ctx) + { + property = axutil_property_create(env); + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_value(property, env, addr_ns_str); + axis2_ctx_set_property(ctx, env, AXIS2_WSA_VERSION, property); + } + + /* extract service group context, if available */ + axis2_addr_in_extract_svc_grp_ctx_id(env, soap_header, msg_ctx); + + axutil_array_list_free(addr_headers, env); + return status; + } + } + + return AXIS2_SUCCESS; +} + +axis2_status_t +axis2_addr_in_extract_svc_grp_ctx_id( + const axutil_env_t * env, + axiom_soap_header_t * soap_header, + axis2_msg_ctx_t * msg_ctx) +{ + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + + node = axiom_soap_header_get_base_node(soap_header, env); + + if(node && axiom_node_get_node_type(node, env) == AXIOM_ELEMENT) + { + axutil_qname_t *qname = NULL; + + element = (axiom_element_t *)axiom_node_get_data_element(node, env); + qname = axutil_qname_create(env, AXIS2_SVC_GRP_ID, AXIS2_NAMESPACE_URI, + AXIS2_NAMESPACE_PREFIX); + if(qname) + { + axiom_node_t *child_node = NULL; + axiom_element_t *child_element = NULL; + + child_element = axiom_element_get_first_child_with_qname(element, env, qname, node, + &child_node); + if(child_element) + { + axis2_conf_ctx_t *conf_ctx = NULL; + + axis2_char_t *grp_id = axiom_element_get_text(child_element, env, child_node); + conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + if(conf_ctx && grp_id) + { + axutil_string_t *svc_grp_ctx_id_str = axutil_string_create(env, grp_id); + axis2_svc_grp_ctx_t *svc_ctx_grp_ctx = axis2_conf_ctx_get_svc_grp_ctx(conf_ctx, + env, grp_id); + if(!svc_ctx_grp_ctx) + { + return AXIS2_FAILURE; + } + axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); + axutil_string_free(svc_grp_ctx_id_str, env); + + return AXIS2_SUCCESS; + } + } + } + axutil_qname_free(qname, env); + } + return AXIS2_FAILURE; +} + +axis2_status_t +axis2_addr_in_extract_addr_params( + const axutil_env_t * env, + axiom_soap_header_t * soap_header, + axis2_msg_info_headers_t ** msg_info_headers_p, + axutil_array_list_t * addr_headers, + const axis2_char_t * addr_ns_str, + axis2_msg_ctx_t * msg_ctx) +{ + axutil_hash_t *header_block_ht = NULL; + axutil_hash_index_t *hash_index = NULL; + axis2_msg_info_headers_t *msg_info_headers = *(msg_info_headers_p); + axis2_status_t status = AXIS2_SUCCESS; + axis2_bool_t to_found = AXIS2_FALSE; + axis2_bool_t reply_to_found = AXIS2_FALSE; + axis2_bool_t fault_to_found = AXIS2_FALSE; + axis2_bool_t action_found = AXIS2_FALSE; + axis2_bool_t msg_id_found = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_info_headers_p, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, addr_headers, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE); + + if(!msg_info_headers) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No messgae info header. Creating new"); + msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL); + if(!msg_info_headers) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MSG_INFO_HEADERS, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No message information headers available"); + return AXIS2_FAILURE; + } + } + + header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env); + if(!header_block_ht) + { + return AXIS2_FAILURE; + } + + /* Iterate thru header blocks */ + for(hash_index = axutil_hash_first(header_block_ht, env); hash_index; hash_index + = axutil_hash_next(env, hash_index)) + { + void *hb = NULL; + axiom_soap_header_block_t *header_block = NULL; + axiom_node_t *header_block_node = NULL; + axiom_element_t *header_block_ele = NULL; + axis2_char_t *ele_localname = NULL; + axis2_endpoint_ref_t *epr = NULL; + axis2_char_t *role = NULL; + + axutil_hash_this(hash_index, NULL, NULL, &hb); + + header_block = (axiom_soap_header_block_t *)hb; + header_block_node = axiom_soap_header_block_get_base_node(header_block, env); + header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node, env); + ele_localname = axiom_element_get_localname(header_block_ele, env); + + role = axiom_soap_header_block_get_role(header_block, env); + if(role && !axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NONE)) + { + /* Role is none, no need of processing */ + continue; + } + + if(!axutil_strcmp(ele_localname, AXIS2_WSA_TO)) + { + /* Here the addressing epr overidde what ever already there in the message context */ + + epr = axis2_endpoint_ref_create(env, axiom_element_get_text(header_block_ele, env, + header_block_node)); + if(AXIS2_TRUE == to_found) + { + /* Duplicate To */ + axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_TO, addr_ns_str, msg_ctx); + status = AXIS2_FAILURE; + continue; + } + axis2_msg_info_headers_set_to(msg_info_headers, env, epr); + + axis2_addr_in_extract_to_epr_ref_params(env, epr, soap_header, addr_ns_str); + axiom_soap_header_block_set_processed(header_block, env); + to_found = AXIS2_TRUE; + } + else if(!axutil_strcmp(ele_localname, AXIS2_WSA_FROM)) + { + epr = axis2_msg_info_headers_get_from(msg_info_headers, env); + if(!epr) + { + /* The address is not known now. Pass the empty + string and fill this once the element + under this is processed. */ + + epr = axis2_endpoint_ref_create(env, ""); + axis2_msg_info_headers_set_from(msg_info_headers, env, epr); + } + axis2_addr_in_extract_epr_information(env, header_block, epr, addr_ns_str); + axiom_soap_header_block_set_processed(header_block, env); + } + else if(!axutil_strcmp(ele_localname, AXIS2_WSA_REPLY_TO)) + { + epr = axis2_msg_info_headers_get_reply_to(msg_info_headers, env); + + if(reply_to_found == AXIS2_TRUE) + { + /* Duplicate Reply To */ + axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_REPLY_TO, addr_ns_str, + msg_ctx); + status = AXIS2_FAILURE; + continue; + } + + if(!epr) + { + epr = axis2_endpoint_ref_create(env, ""); + axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr); + } + axis2_addr_in_extract_epr_information(env, header_block, epr, addr_ns_str); + axiom_soap_header_block_set_processed(header_block, env); + reply_to_found = AXIS2_TRUE; + } + else if(!axutil_strcmp(ele_localname, AXIS2_WSA_FAULT_TO)) + { + epr = axis2_msg_info_headers_get_fault_to(msg_info_headers, env); + + if(fault_to_found == AXIS2_TRUE) + { + /* Duplicate Fault To */ + axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_FAULT_TO, addr_ns_str, + msg_ctx); + status = AXIS2_FAILURE; + axis2_msg_info_headers_set_fault_to(msg_info_headers, env, NULL); + continue; + } + + if(!epr) + { + epr = axis2_endpoint_ref_create(env, ""); + axis2_msg_info_headers_set_fault_to(msg_info_headers, env, epr); + } + axis2_addr_in_extract_epr_information(env, header_block, epr, addr_ns_str); + axiom_soap_header_block_set_processed(header_block, env); + fault_to_found = AXIS2_TRUE; + } + else if(!axutil_strcmp(ele_localname, AXIS2_WSA_MESSAGE_ID)) + { + axis2_char_t *text = NULL; + + if(msg_id_found == AXIS2_TRUE) + { + /* Duplicate Message ID */ + axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_MESSAGE_ID, addr_ns_str, + msg_ctx); + status = AXIS2_FAILURE; + continue; + } + + text = axiom_element_get_text(header_block_ele, env, header_block_node); + axis2_msg_info_headers_set_in_message_id(msg_info_headers, env, text); + axiom_soap_header_block_set_processed(header_block, env); + msg_id_found = AXIS2_TRUE; + } + else if(!axutil_strcmp(ele_localname, AXIS2_WSA_ACTION)) + { + axis2_char_t *text = NULL; + + if(action_found == AXIS2_TRUE) + { + /* Duplicate Action */ + axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_ACTION, addr_ns_str, + msg_ctx); + status = AXIS2_FAILURE; + continue; + } + + text = axiom_element_get_text(header_block_ele, env, header_block_node); + axis2_msg_info_headers_set_action(msg_info_headers, env, text); + axiom_soap_header_block_set_processed(header_block, env); + action_found = AXIS2_TRUE; + } + else if(!axutil_strcmp(ele_localname, AXIS2_WSA_RELATES_TO)) + { + axis2_char_t *address = NULL; + axutil_qname_t *rqn = NULL; + axiom_attribute_t *relationship_type = NULL; + const axis2_char_t *relationship_type_value = NULL; + axis2_relates_to_t *relates_to = NULL; + + rqn = axutil_qname_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, NULL, NULL); + relationship_type = axiom_element_get_attribute(header_block_ele, env, rqn); + + if(!relationship_type) + { + if(!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ns_str)) + { + relationship_type_value = + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION; + } + else + { + relationship_type_value = + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE; + } + } + else + { + relationship_type_value = axiom_attribute_get_value(relationship_type, env); + } + + address = axiom_element_get_text(header_block_ele, env, header_block_node); + relates_to = axis2_relates_to_create(env, address, relationship_type_value); + + axis2_msg_info_headers_set_relates_to(msg_info_headers, env, relates_to); + axiom_soap_header_block_set_processed(header_block, env); + + axutil_qname_free(rqn, env); + } + } + + /* If an action is not found, it's a false*/ + if(action_found == AXIS2_FALSE) + { + axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_ACTION, addr_ns_str, msg_ctx); + status = AXIS2_FAILURE; + } + + return status; +} + +axis2_status_t +axis2_addr_in_extract_epr_information( + const axutil_env_t * env, + axiom_soap_header_block_t * soap_header_block, + axis2_endpoint_ref_t * endpoint_ref, + const axis2_char_t * addr_ns_str) +{ + axutil_qname_t *epr_addr_qn = NULL; + axutil_qname_t *epr_ref_qn = NULL; + axutil_qname_t *wsa_meta_qn = NULL; + axiom_node_t *header_block_node = NULL; + axiom_element_t *header_block_ele = NULL; + axiom_child_element_iterator_t *child_ele_iter = NULL; + + AXIS2_PARAM_CHECK(env->error, soap_header_block, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, endpoint_ref, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE); + + header_block_node = axiom_soap_header_block_get_base_node(soap_header_block, env); + header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node, env); + + child_ele_iter = axiom_element_get_child_elements(header_block_ele, env, header_block_node); + if(!child_ele_iter) + { + return AXIS2_FAILURE; + } + + epr_addr_qn = axutil_qname_create(env, EPR_ADDRESS, addr_ns_str, NULL); + epr_ref_qn = axutil_qname_create(env, EPR_REFERENCE_PARAMETERS, addr_ns_str, NULL); + wsa_meta_qn = axutil_qname_create(env, AXIS2_WSA_METADATA, addr_ns_str, NULL); + + while(AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(child_ele_iter, env)) + { + axiom_node_t *child_node = NULL; + axiom_element_t *child_ele = NULL; + axutil_qname_t *child_qn = NULL; + child_node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(child_ele_iter, env); + child_ele = (axiom_element_t *)axiom_node_get_data_element(child_node, env); + + child_qn = axiom_element_get_qname(child_ele, env, child_node); + if(axis2_addr_in_check_element(env, epr_addr_qn, child_qn)) + { + axis2_endpoint_ref_set_address(endpoint_ref, env, axiom_element_get_text(child_ele, + env, child_node)); + } + else if(axis2_addr_in_check_element(env, epr_ref_qn, child_qn)) + { + axiom_child_element_iterator_t *ref_param_iter = NULL; + + ref_param_iter = axiom_element_get_child_elements(child_ele, env, child_node); + if(ref_param_iter) + { + while(AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(ref_param_iter, env)) + { + axiom_node_t *om_node = NULL; + axiom_element_t *om_ele = NULL; + om_node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(ref_param_iter, env); + om_ele = (axiom_element_t *)axiom_node_get_data_element(om_node, env); + axis2_endpoint_ref_add_ref_param(endpoint_ref, env, om_node); + } + } + + } + else if(axis2_addr_in_check_element(env, wsa_meta_qn, child_qn)) + { + /* FIXME : Can we remove this?*/ + } + } + axutil_qname_free(epr_addr_qn, env); + axutil_qname_free(epr_ref_qn, env); + axutil_qname_free(wsa_meta_qn, env); + + return AXIS2_SUCCESS; +} + +axis2_status_t +axis2_addr_in_extract_ref_params( + const axutil_env_t * env, + axiom_soap_header_t * soap_header, + axis2_msg_info_headers_t * msg_info_headers) +{ + axutil_hash_t *header_block_ht = NULL; + axutil_hash_index_t *hash_index = NULL; + axutil_qname_t *wsa_qname = NULL; + + AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_info_headers, AXIS2_FAILURE); + + header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env); + if(!header_block_ht) + { + return AXIS2_FAILURE; + } + wsa_qname = axutil_qname_create(env, AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, + AXIS2_WSA_NAMESPACE, NULL); + + for(hash_index = axutil_hash_first(header_block_ht, env); hash_index; hash_index + = axutil_hash_next(env, hash_index)) + { + void *hb = NULL; + axiom_soap_header_block_t *header_block = NULL; + axiom_node_t *header_block_node = NULL; + axiom_element_t *header_block_ele = NULL; + + axutil_hash_this(hash_index, NULL, NULL, &hb); + + header_block = (axiom_soap_header_block_t *)hb; + header_block_node = axiom_soap_header_block_get_base_node(header_block, env); + + if(header_block_node && (axiom_node_get_node_type(header_block_node, env) == AXIOM_ELEMENT)) + { + axiom_attribute_t *om_attr = NULL; + axis2_char_t *attr_value = NULL; + header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node, + env); + om_attr = axiom_element_get_attribute(header_block_ele, env, wsa_qname); + if(om_attr) + { + attr_value = axiom_attribute_get_value(om_attr, env); + if(!axutil_strcmp(attr_value, AXIS2_WSA_TYPE_ATTRIBUTE_VALUE)) + { + axis2_msg_info_headers_add_ref_param(msg_info_headers, env, header_block_node); + } + } + } + } + + axutil_qname_free(wsa_qname, env); + + return AXIS2_SUCCESS; +} + +axis2_status_t +axis2_addr_in_extract_to_epr_ref_params( + const axutil_env_t * env, + axis2_endpoint_ref_t * to_epr, + axiom_soap_header_t * soap_header, + const axis2_char_t * addr_ns_str) +{ + axutil_hash_t *header_blocks_ht = NULL; + axutil_hash_index_t *hash_index = NULL; + axutil_qname_t *is_ref_qn = NULL; + + AXIS2_PARAM_CHECK(env->error, to_epr, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE); + + header_blocks_ht = axiom_soap_header_get_all_header_blocks(soap_header, env); + if(!header_blocks_ht) + { + return AXIS2_FAILURE; + } + + is_ref_qn = axutil_qname_create(env, "IsReferenceParameter", addr_ns_str, NULL); + + if(!is_ref_qn) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create qname for %s", + addr_ns_str); + return AXIS2_FAILURE; + } + + for(hash_index = axutil_hash_first(header_blocks_ht, env); hash_index; hash_index + = axutil_hash_next(env, hash_index)) + { + axiom_element_t *header_block_ele = NULL; + axiom_node_t *header_block_node = NULL; + axiom_soap_header_block_t *header_block = NULL; + void *hb = NULL; + axiom_attribute_t *is_ref_param_attr = NULL; + axis2_char_t *attr_value = NULL; + + axutil_hash_this(hash_index, NULL, NULL, &hb); + if(hb) + { + header_block = (axiom_soap_header_block_t *)hb; + header_block_node = axiom_soap_header_block_get_base_node(header_block, env); + header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node, + env); + is_ref_param_attr = axiom_element_get_attribute(header_block_ele, env, is_ref_qn); + if(is_ref_param_attr) + { + attr_value = axiom_attribute_get_localname(is_ref_param_attr, env); + if(!axutil_strcmp("true", attr_value)) + { + axis2_endpoint_ref_add_ref_param(to_epr, env, header_block_node); + } + } + } + } + + axutil_qname_free(is_ref_qn, env); + return AXIS2_SUCCESS; +} + +axis2_bool_t +axis2_addr_in_check_element( + const axutil_env_t * env, + axutil_qname_t * expected_qname, + axutil_qname_t * actual_qname) +{ + axis2_char_t *exp_qn_lpart = NULL; + axis2_char_t *act_qn_lpart = NULL; + axis2_char_t *exp_qn_nsuri = NULL; + axis2_char_t *act_qn_nsuri = NULL; + + AXIS2_PARAM_CHECK(env->error, expected_qname, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, actual_qname, AXIS2_FAILURE); + + exp_qn_lpart = axutil_qname_get_localpart(expected_qname, env); + act_qn_lpart = axutil_qname_get_localpart(actual_qname, env); + + exp_qn_nsuri = axutil_qname_get_localpart(expected_qname, env); + act_qn_nsuri = axutil_qname_get_localpart(actual_qname, env); + + return ((!axutil_strcmp(exp_qn_lpart, act_qn_lpart)) && (!axutil_strcmp(exp_qn_nsuri, + act_qn_nsuri))); +} + +void +axis2_addr_in_create_fault_envelope( + const axutil_env_t * env, + const axis2_char_t * header_name, + const axis2_char_t * addr_ns_str, + axis2_msg_ctx_t * msg_ctx) +{ + axiom_soap_envelope_t *envelope = NULL; + axutil_array_list_t *sub_codes = NULL; + int soap_version = AXIOM_SOAP12; + axiom_node_t *text_om_node = NULL; + axiom_element_t *text_om_ele = NULL; + axiom_namespace_t *ns1 = NULL; + + if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) + { + soap_version = AXIOM_SOAP11; + } + + ns1 = axiom_namespace_create(env, addr_ns_str, AXIS2_WSA_DEFAULT_PREFIX); + text_om_ele = axiom_element_create(env, NULL, "ProblemHeaderQName", ns1, &text_om_node); + axiom_element_set_text(text_om_ele, env, header_name, text_om_node); + + sub_codes = axutil_array_list_create(env, 2); + if(sub_codes) + { + axutil_array_list_add(sub_codes, env, "wsa:InvalidAddressingHeader"); + axutil_array_list_add(sub_codes, env, "wsa:InvalidCardinality"); + } + + envelope + = axiom_soap_envelope_create_default_soap_fault_envelope( + env, + "soapenv:Sender", + "A header representing a Message Addressing Property is not valid and the message cannot be processed", + soap_version, sub_codes, text_om_node); + axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, envelope); + axis2_msg_ctx_set_wsa_action(msg_ctx, env, "http://www.w3.org/2005/08/addressing/fault"); + return; +} diff --git a/src/modules/mod_addr/addr_out_handler.c b/src/modules/mod_addr/addr_out_handler.c new file mode 100644 index 0000000..dbf47a4 --- /dev/null +++ b/src/modules/mod_addr/addr_out_handler.c @@ -0,0 +1,833 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +axis2_status_t AXIS2_CALL +axis2_addr_out_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); + +axis2_status_t +axis2_addr_out_handler_add_to_soap_header( + const axutil_env_t * env, + axis2_endpoint_ref_t * endpoint_ref, + const axis2_char_t * type, + axiom_soap_header_t * soap_header, + const axis2_char_t * addr_ns); + +axis2_status_t +axis2_addr_out_handler_add_to_header( + const axutil_env_t * env, + axis2_endpoint_ref_t * epr, + axiom_node_t ** parent_node, + const axis2_char_t * addr_ns); + +axis2_status_t +axis2_addr_out_handler_process_any_content_type( + const axutil_env_t * env, + axis2_any_content_type_t * reference_values, + axiom_node_t * parent_ele_node, + const axis2_char_t * addr_ns); + +axiom_node_t * +axis2_addr_out_handler_process_string_info( + const axutil_env_t * env, + const axis2_char_t * value, + const axis2_char_t * type, + axiom_soap_header_t ** soap_header, + const axis2_char_t * addr_ns); + +AXIS2_EXTERN axis2_handler_t *AXIS2_CALL +axis2_addr_out_handler_create( + const axutil_env_t * env, + axutil_string_t * name) +{ + axis2_handler_t *handler = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + handler = axis2_handler_create(env); + if(!handler) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create addressing out handler"); + return NULL; + } + + axis2_handler_set_invoke(handler, env, axis2_addr_out_handler_invoke); + + return handler; +} + +axis2_status_t AXIS2_CALL +axis2_addr_out_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx) +{ + axis2_char_t *addr_ver_from_msg_ctx = NULL; + const axis2_char_t *addr_ns = NULL; + axis2_msg_info_headers_t *msg_info_headers = NULL; + axis2_ctx_t *ctx = NULL; + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_soap_header_t *soap_header = NULL; + axiom_node_t *soap_header_node = NULL; + axiom_element_t *soap_header_ele = NULL; + axis2_endpoint_ref_t *epr_to = NULL; + axis2_endpoint_ref_t *epr_reply_to = NULL; + axis2_endpoint_ref_t *epr_from = NULL; + axis2_endpoint_ref_t *epr_fault_to = NULL; + axutil_property_t *property = NULL; + const axis2_char_t *wsa_action = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + AXIS2_LOG_INFO(env->log, "Starting addressing out handler"); + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + if(!soap_envelope) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP envelope. Stop processing addressing"); + return AXIS2_SUCCESS; /* Can happen in case of ONE-WAY services/clients */ + } + + msg_info_headers = axis2_msg_ctx_get_msg_info_headers(msg_ctx, env); + + if(msg_info_headers) + { + wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env); + } + else + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No addressing in use"); + return AXIS2_SUCCESS; /* No addressing in use */ + } + + if(!wsa_action || !*wsa_action) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No action present. Stop processing addressing"); + return AXIS2_SUCCESS; /* If no action present, assume no addressing in use */ + } + + ctx = axis2_msg_ctx_get_base(msg_ctx, env); + property = axis2_ctx_get_property(ctx, env, AXIS2_WSA_VERSION); + + if(property) + { + addr_ver_from_msg_ctx = axutil_property_get_value(property, env); + property = NULL; + } + + /* Setting version 1.0 as the default addressing namespace */ + addr_ns = AXIS2_WSA_NAMESPACE; + + if(addr_ver_from_msg_ctx) + { + if(!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ver_from_msg_ctx)) + { + addr_ns = AXIS2_WSA_NAMESPACE_SUBMISSION; + } + } + else if(axis2_msg_ctx_get_op_ctx(msg_ctx, env)) + { + axis2_op_ctx_t *op_ctx = NULL; + axis2_msg_ctx_t *in_msg_ctx = NULL; + op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); + + if(op_ctx) + { + in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); + } + + if(in_msg_ctx) + { + axis2_ctx_t *in_ctx = NULL; + in_ctx = axis2_msg_ctx_get_base(in_msg_ctx, env); + + property = axis2_ctx_get_property(in_ctx, env, AXIS2_WSA_VERSION); + if(property) + { + addr_ns = axutil_property_get_value(property, env); + property = NULL; + } + + if(!addr_ns || !*addr_ns) + { + addr_ns = AXIS2_WSA_NAMESPACE; + } + } + } + + soap_header = axiom_soap_envelope_get_header(soap_envelope, env); + if(!soap_header) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No SOAP header. Stop processing addressing"); + return AXIS2_SUCCESS; /* No SOAP header, so no point proceeding */ + } + else + { + /* By this time, we definitely have some addressing information to be sent. This is because, + * we have tested at the start of this whether msg_info_headers are null or not. + * So rather than declaring addressing namespace in each and every addressing header, lets + * define that in the Header itself. + */ + const axis2_char_t *action = NULL; + const axis2_char_t *address = NULL; + const axis2_char_t *svc_group_context_id = NULL; + const axis2_char_t *message_id = NULL; + axis2_relates_to_t *relates_to = NULL; + axiom_node_t *relates_to_header_node = NULL; + axiom_element_t *relates_to_header_ele = NULL; + axiom_namespace_t *addressing_namespace = NULL; + + soap_header_node = axiom_soap_header_get_base_node(soap_header, env); + soap_header_ele = (axiom_element_t *)axiom_node_get_data_element(soap_header_node, env); + + addressing_namespace = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + + axiom_element_declare_namespace(soap_header_ele, env, soap_header_node, + addressing_namespace); + + epr_to = axis2_msg_info_headers_get_to(msg_info_headers, env); + + if(epr_to) + { + axiom_soap_body_t *body = axiom_soap_envelope_get_body(soap_envelope, env); + + if(body) + { + /* In case of a SOAP fault, we got to send the response to + the adress specified by FaultTo */ + if(axiom_soap_body_has_fault(body, env)) + { + axis2_endpoint_ref_t *epr_fault_to = axis2_msg_info_headers_get_fault_to( + msg_info_headers, env); + if(epr_fault_to) + { + const axis2_char_t *fault_to_address = axis2_endpoint_ref_get_address( + epr_fault_to, env); + if(fault_to_address) + { + if(axutil_strcmp(AXIS2_WSA_NONE_URL, fault_to_address) + && axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, fault_to_address)) + { + axis2_endpoint_ref_set_address(epr_to, env, fault_to_address); + } + } + } + } + } + + address = axis2_endpoint_ref_get_address(epr_to, env); + if(address && *address) + { + axiom_node_t *to_header_block_node = NULL; + axiom_soap_header_block_t *to_header_block = NULL; + axutil_array_list_t *ref_param_list = NULL; + int size = 0; + + to_header_block = axiom_soap_header_add_header_block(soap_header, env, + AXIS2_WSA_TO, addressing_namespace); + to_header_block_node = axiom_soap_header_block_get_base_node(to_header_block, env); + if(to_header_block_node) + { + axiom_element_t *to_header_block_element = NULL; + to_header_block_element = (axiom_element_t *)axiom_node_get_data_element( + to_header_block_node, env); + if(to_header_block_element) + { + axiom_element_set_text(to_header_block_element, env, address, + to_header_block_node); + } + } + + ref_param_list = axis2_endpoint_ref_get_ref_param_list(epr_to, env); + + size = axutil_array_list_size(ref_param_list, env); + if(ref_param_list && size > 0) + { + axiom_soap_header_block_t *reference_header_block = NULL; + axiom_node_t *reference_node = NULL; + int i = 0; + + for(i = 0; i < size; i++) + { + axiom_node_t *temp_node = NULL; + + temp_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i); + if(temp_node) + { + axiom_element_t *temp_ele = NULL; + + temp_ele = axiom_node_get_data_element(temp_node, env); + if(temp_ele) + { + reference_header_block = axiom_soap_header_add_header_block( + soap_header, env, axiom_element_get_localname(temp_ele, env), + axiom_element_get_namespace(temp_ele, env, temp_node)); + + reference_node = axiom_soap_header_block_get_base_node( + reference_header_block, env); + if(reference_node) + { + axiom_element_t *reference_ele = NULL; + reference_ele = (axiom_element_t *)axiom_node_get_data_element( + reference_node, env); + + if(reference_ele) + { + axiom_namespace_t *addr_ns_obj = NULL; + axiom_attribute_t *reference_attr = NULL; + + addr_ns_obj = axiom_namespace_create(env, addr_ns, + AXIS2_WSA_DEFAULT_PREFIX); + reference_attr = axiom_attribute_create(env, + /*"isReferenceParameter"*/ + AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, "true", + addr_ns_obj); + axiom_element_add_attribute(reference_ele, env, + reference_attr, reference_node); + axiom_element_set_text(reference_ele, env, + axiom_element_get_text(temp_ele, env, temp_node), + reference_node); + } + } + } + } + } + } + } + }/* if(epr_to) */ + + action = axis2_msg_info_headers_get_action(msg_info_headers, env); + if(action && *action) + { + axis2_addr_out_handler_process_string_info(env, action, AXIS2_WSA_ACTION, &soap_header, + addr_ns); + } + + epr_reply_to = axis2_msg_info_headers_get_reply_to(msg_info_headers, env); + if(!epr_reply_to) + { + const axis2_char_t *anonymous_uri = NULL; + axis2_bool_t anonymous = axis2_msg_info_headers_get_reply_to_anonymous( + msg_info_headers, env); + axis2_bool_t none = axis2_msg_info_headers_get_reply_to_none(msg_info_headers, env); + if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) + { + if(none) + { + anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION; + } + else if(anonymous) + { + anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; + } + } + else + { + if(none) + { + anonymous_uri = AXIS2_WSA_NONE_URL; + } + else if(anonymous) + { + anonymous_uri = AXIS2_WSA_ANONYMOUS_URL; + } + } + + if(anonymous_uri) + { + epr_reply_to = axis2_endpoint_ref_create(env, anonymous_uri); + } + + if(epr_reply_to) + { + axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr_reply_to); + } + } + + /* add the service group id as a reference parameter */ + svc_group_context_id = axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id(msg_ctx, + env), env); + + axis2_addr_out_handler_add_to_soap_header(env, epr_reply_to, AXIS2_WSA_REPLY_TO, + soap_header, addr_ns); + + epr_from = axis2_msg_info_headers_get_from(msg_info_headers, env); + + if(epr_from) + { + axis2_addr_out_handler_add_to_soap_header(env, epr_from, AXIS2_WSA_FROM, soap_header, + addr_ns); + + } + + epr_fault_to = axis2_msg_info_headers_get_fault_to(msg_info_headers, env); + if(!epr_fault_to) + { + const axis2_char_t *anonymous_uri = NULL; + axis2_bool_t anonymous = axis2_msg_info_headers_get_fault_to_anonymous( + msg_info_headers, env); + axis2_bool_t none = axis2_msg_info_headers_get_fault_to_none(msg_info_headers, env); + if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) + { + if(none) + { + anonymous_uri = AXIS2_WSA_NONE_URL_SUBMISSION; + } + else if(anonymous) + { + anonymous_uri = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; + } + } + else + { + if(none) + anonymous_uri = AXIS2_WSA_NONE_URL; + else if(anonymous) + anonymous_uri = AXIS2_WSA_ANONYMOUS_URL; + } + + if(anonymous_uri) + { + epr_fault_to = axis2_endpoint_ref_create(env, anonymous_uri); + } + } + + if(epr_fault_to) + { + /* optional */ + axis2_addr_out_handler_add_to_soap_header(env, epr_fault_to, AXIS2_WSA_FAULT_TO, + soap_header, addr_ns); + } + + message_id = axis2_msg_info_headers_get_message_id(msg_info_headers, env); + + if(message_id) + { + axis2_addr_out_handler_process_string_info(env, message_id, AXIS2_WSA_MESSAGE_ID, + &soap_header, addr_ns); + } + + relates_to = axis2_msg_info_headers_get_relates_to(msg_info_headers, env); + + if(relates_to) + { + const axis2_char_t *value = NULL; + value = axis2_relates_to_get_value(relates_to, env); + relates_to_header_node = axis2_addr_out_handler_process_string_info(env, value, + AXIS2_WSA_RELATES_TO, &soap_header, addr_ns); + } + + if(relates_to_header_node) + { + const axis2_char_t *relationship_type = NULL; + relationship_type = axis2_relates_to_get_relationship_type(relates_to, env); + if(relationship_type && *relationship_type) + { + axiom_attribute_t *om_attr = NULL; + axiom_namespace_t *addr_ns_obj = NULL; + axiom_namespace_t *dec_ns = NULL; + relates_to_header_ele = (axiom_element_t *)axiom_node_get_data_element( + relates_to_header_node, env); + if(relates_to_header_ele) + { + dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env, + addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + if(dec_ns) + { + addr_ns_obj = dec_ns; + } + else + { + addr_ns_obj + = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + } + + if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) + { + om_attr = axiom_attribute_create(env, + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION, + addr_ns_obj); + } + else + { + om_attr = axiom_attribute_create(env, + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, + AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE, addr_ns_obj); + } + + axiom_element_add_attribute(relates_to_header_ele, env, om_attr, + relates_to_header_node); + + dec_ns = axiom_element_find_declared_namespace(relates_to_header_ele, env, + addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + if(!dec_ns) + { + dec_ns = axiom_element_find_namespace(relates_to_header_ele, env, + relates_to_header_node, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + if(dec_ns) + { + axiom_namespace_free(addr_ns_obj, env); + addr_ns_obj = NULL; + axiom_attribute_set_namespace(om_attr, env, dec_ns); + } + } + } + + } + } + } + return AXIS2_SUCCESS; +} + +axiom_node_t * +axis2_addr_out_handler_process_string_info( + const axutil_env_t * env, + const axis2_char_t * value, + const axis2_char_t * type, + axiom_soap_header_t ** soap_header_p, + const axis2_char_t * addr_ns) +{ + axiom_soap_header_t *soap_header = NULL; + axiom_soap_header_block_t *header_block = NULL; + axiom_node_t *header_block_node = NULL; + axiom_element_t *header_block_ele = NULL; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, value, NULL); + AXIS2_PARAM_CHECK(env->error, type, NULL); + AXIS2_PARAM_CHECK(env->error, soap_header_p, NULL); + AXIS2_PARAM_CHECK(env->error, addr_ns, NULL); + + soap_header = *(soap_header_p); + + if(value && *value) + { + axiom_namespace_t *addr_ns_obj = NULL; + addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + header_block = axiom_soap_header_add_header_block(soap_header, env, type, addr_ns_obj); + header_block_node = axiom_soap_header_block_get_base_node(header_block, env); + header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node, env); + if(header_block_ele) + { + axiom_namespace_t *dec_ns = NULL; + axiom_element_set_text(header_block_ele, env, value, header_block_node); + dec_ns = axiom_element_find_declared_namespace(header_block_ele, env, addr_ns, + AXIS2_WSA_DEFAULT_PREFIX); + if(!dec_ns) + { + axiom_namespace_free(addr_ns_obj, env); + addr_ns_obj = NULL; + } + } + } + return header_block_node; +} + +axis2_status_t +axis2_addr_out_handler_add_to_soap_header( + const axutil_env_t * env, + axis2_endpoint_ref_t * endpoint_ref, + const axis2_char_t * type, + axiom_soap_header_t * soap_header, + const axis2_char_t * addr_ns) +{ + axiom_soap_header_block_t *header_block = NULL; + const axis2_char_t *address = NULL; + axutil_array_list_t *ref_param_list = NULL; + axutil_array_list_t *meta_data_list = NULL; + axutil_array_list_t *extension_list = NULL; + axiom_node_t *header_block_node = NULL; + axiom_node_t *header_node = NULL; + axiom_namespace_t *addr_ns_obj = NULL; + int size = 0; + + AXIS2_PARAM_CHECK(env->error, endpoint_ref, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, type, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE); + + header_node = axiom_soap_header_get_base_node(soap_header, env); + + addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + header_block = axiom_soap_header_add_header_block(soap_header, env, type, addr_ns_obj); + + if(addr_ns_obj) + { + axiom_namespace_free(addr_ns_obj, env); + addr_ns_obj = NULL; + } + + address = axis2_endpoint_ref_get_address(endpoint_ref, env); + if(address && *address) + { + axiom_node_t *hb_node = NULL; + axiom_element_t *hb_ele = NULL; + axiom_node_t *address_node = NULL; + axiom_element_t *address_ele = NULL; + hb_node = axiom_soap_header_block_get_base_node(header_block, env); + hb_ele = (axiom_element_t *)axiom_node_get_data_element(hb_node, env); + + addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + + address_ele = axiom_element_create(env, hb_node, EPR_ADDRESS, addr_ns_obj, &address_node); + if(address_ele) + { + axiom_namespace_t *dec_ns = NULL; + axiom_element_set_text(address_ele, env, address, address_node); + dec_ns = axiom_element_find_declared_namespace(address_ele, env, addr_ns, + AXIS2_WSA_DEFAULT_PREFIX); + } + } + + header_block_node = axiom_soap_header_block_get_base_node(header_block, env); + axis2_addr_out_handler_add_to_header(env, endpoint_ref, &header_block_node, addr_ns); + + ref_param_list = axis2_endpoint_ref_get_ref_param_list(endpoint_ref, env); + if(ref_param_list && axutil_array_list_size(ref_param_list, env) > 0) + { + axiom_node_t *reference_node = NULL; + axiom_element_t *reference_ele = NULL; + axutil_array_list_t *ref_attribute_list = NULL; + int i = 0; + + addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + + reference_ele = axiom_element_create(env, header_block_node, EPR_REFERENCE_PARAMETERS, + addr_ns_obj, &reference_node); + + ref_attribute_list = axis2_endpoint_ref_get_ref_attribute_list(endpoint_ref, env); + if(ref_attribute_list) + { + int j = 0; + + size = axutil_array_list_size(ref_attribute_list, env); + for(j = 0; j < size; j++) + { + axiom_attribute_t *attr = (axiom_attribute_t *)axutil_array_list_get( + ref_attribute_list, env, j); + if(attr) + { + axiom_element_add_attribute(reference_ele, env, attr, reference_node); + } + } + } + + size = axutil_array_list_size(ref_param_list, env); + for(i = 0; i < size; i++) + { + axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(ref_param_list, env, i); + if(ref_node) + { + axiom_node_add_child(reference_node, env, ref_node); + } + } + + } + + meta_data_list = axis2_endpoint_ref_get_metadata_list(endpoint_ref, env); + if(meta_data_list && axutil_array_list_size(meta_data_list, env) > 0) + { + axiom_node_t *reference_node = NULL; + axiom_element_t *reference_ele = NULL; + axutil_array_list_t *meta_attribute_list = NULL; + int i = 0; + + if(!reference_node) /* may be we alredy created this in ref params block */ + { + addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + + reference_ele = axiom_element_create(env, header_block_node, AXIS2_WSA_METADATA, + addr_ns_obj, &reference_node); + } + + meta_attribute_list = axis2_endpoint_ref_get_metadata_attribute_list(endpoint_ref, env); + if(meta_attribute_list) + { + int j = 0; + size = axutil_array_list_size(meta_attribute_list, env); + for(j = 0; j < size; j++) + { + axiom_attribute_t *attr = (axiom_attribute_t *)axutil_array_list_get( + meta_attribute_list, env, j); + if(attr) + { + axiom_element_add_attribute(reference_ele, env, attr, reference_node); + } + } + } + + size = axutil_array_list_size(meta_data_list, env); + for(i = 0; i < size; i++) + { + axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(meta_data_list, env, i); + if(ref_node) + { + axiom_node_add_child(reference_node, env, ref_node); + } + } + } + + extension_list = axis2_endpoint_ref_get_extension_list(endpoint_ref, env); + if(extension_list && axutil_array_list_size(extension_list, env) > 0) + { + int i = 0; + + size = axutil_array_list_size(extension_list, env); + for(i = 0; i < size; i++) + { + axiom_node_t *ref_node = (axiom_node_t *)axutil_array_list_get(extension_list, env, i); + if(ref_node) + { + axiom_node_add_child(header_block_node, env, ref_node); + } + } + } + + return AXIS2_SUCCESS; +} + +axis2_status_t +axis2_addr_out_handler_add_to_header( + const axutil_env_t * env, + axis2_endpoint_ref_t * epr, + axiom_node_t ** parent_node_p, + const axis2_char_t * addr_ns) +{ + axiom_node_t *parent_node = NULL; + const axutil_qname_t *interface_qname = NULL; + axiom_node_t *interface_node = NULL; + axiom_element_t *interface_ele = NULL; + const axis2_char_t *element_localname = NULL; + axis2_svc_name_t *service_name = NULL; + axiom_namespace_t *addr_ns_obj = NULL; + + AXIS2_PARAM_CHECK(env->error, epr, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, parent_node_p, AXIS2_FAILURE); + + parent_node = *(parent_node_p); + + interface_qname = axis2_endpoint_ref_get_interface_qname(epr, env); + + if(interface_qname) + { + axis2_char_t *text = NULL; + axis2_char_t *qname_prefix = NULL; + axis2_char_t *qname_localpart = NULL; + + addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + + if(!axutil_strcmp(addr_ns, AXIS2_WSA_NAMESPACE_SUBMISSION)) + { + element_localname = EPR_PORT_TYPE; + } + else + { + element_localname = AXIS2_WSA_INTERFACE_NAME; + } + + interface_ele = axiom_element_create(env, parent_node, element_localname, addr_ns_obj, + &interface_node); + qname_prefix = axutil_qname_get_prefix(interface_qname, env); + qname_localpart = axutil_qname_get_localpart(interface_qname, env); + + text = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (axutil_strlen(qname_prefix) + + axutil_strlen(qname_localpart) + 2)); + sprintf(text, "%s:%s", qname_prefix, qname_localpart); + axiom_element_set_text(interface_ele, env, text, interface_node); + AXIS2_FREE(env->allocator, text); + if(interface_ele) + { + axiom_namespace_t *dec_ns = NULL; + dec_ns = axiom_element_find_declared_namespace(interface_ele, env, addr_ns, + AXIS2_WSA_DEFAULT_PREFIX); + if(!dec_ns) + { + axiom_namespace_free(addr_ns_obj, env); + addr_ns_obj = NULL; + } + } + + } + + service_name = axis2_endpoint_ref_get_svc_name(epr, env); + return AXIS2_SUCCESS; +} + +axis2_status_t +axis2_addr_out_handler_process_any_content_type( + const axutil_env_t * env, + axis2_any_content_type_t * reference_values, + axiom_node_t * parent_ele_node, + const axis2_char_t * addr_ns) +{ + axutil_hash_t *value_ht = NULL; + axutil_hash_index_t *hash_index = NULL; + + if(reference_values) + { + const void *key = NULL; + void *val = NULL; + axis2_ssize_t len = 0; + value_ht = axis2_any_content_type_get_value_map(reference_values, env); + if(!value_ht) + { + return AXIS2_FAILURE; + } + + for(hash_index = axutil_hash_first(value_ht, env); hash_index; hash_index + = axutil_hash_next(env, hash_index)) + { + axutil_hash_this(hash_index, &key, &len, &val); + if(key) + { + axiom_node_t *node = NULL; + axiom_element_t *ele = NULL; + ele = axiom_element_create(env, parent_ele_node, key, NULL, &node); + if(ele) + { + if(!axutil_strcmp(AXIS2_WSA_NAMESPACE, addr_ns)) + { + axiom_namespace_t *addr_ns_obj = NULL; + axiom_attribute_t *att = NULL; + addr_ns_obj + = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); + att = axiom_attribute_create(env, + AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, + AXIS2_WSA_TYPE_ATTRIBUTE_VALUE, addr_ns_obj); + } + axiom_element_set_text(ele, env, val, node); + } + } + } + } + return AXIS2_SUCCESS; +} diff --git a/src/modules/mod_addr/mod_addr.c b/src/modules/mod_addr/mod_addr.c new file mode 100644 index 0000000..f92400c --- /dev/null +++ b/src/modules/mod_addr/mod_addr.c @@ -0,0 +1,155 @@ +/* + * 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. + */ +#include +#include +#include + +axis2_status_t AXIS2_CALL +axis2_mod_addr_shutdown( + axis2_module_t * module, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_mod_addr_init( + axis2_module_t * module, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_module_desc_t * module_desc); + +axis2_status_t AXIS2_CALL +axis2_mod_addr_fill_handler_create_func_map( + axis2_module_t * module, + const axutil_env_t * env); + +static const axis2_module_ops_t addr_module_ops_var = { axis2_mod_addr_init, + axis2_mod_addr_shutdown, axis2_mod_addr_fill_handler_create_func_map }; + +axis2_module_t * +axis2_mod_addr_create( + const axutil_env_t * env) +{ + axis2_module_t *module = NULL; + + module = AXIS2_MALLOC(env->allocator, sizeof(axis2_module_t)); + + if(!module) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create the addressing module"); + return NULL; + } + + module->ops = &addr_module_ops_var; + module->handler_create_func_map = NULL; + + return module; +} + +axis2_status_t AXIS2_CALL +axis2_mod_addr_init( + axis2_module_t * module, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_module_desc_t * module_desc) +{ + /* Any initialization stuff of mod_addr goes here */ + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_mod_addr_shutdown( + axis2_module_t * module, + const axutil_env_t * env) +{ + if(module->handler_create_func_map) + { + axutil_hash_free(module->handler_create_func_map, env); + module->handler_create_func_map = NULL; + } + + if(module) + { + AXIS2_FREE(env->allocator, module); + module = NULL; + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_mod_addr_fill_handler_create_func_map( + axis2_module_t * module, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module, AXIS2_FAILURE); + + module->handler_create_func_map = axutil_hash_make(env); + + if(!module->handler_create_func_map) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create the function map"); + return AXIS2_FAILURE; + } + axutil_hash_set(module->handler_create_func_map, ADDR_IN_HANDLER, AXIS2_HASH_KEY_STRING, + axis2_addr_in_handler_create); + + axutil_hash_set(module->handler_create_func_map, ADDR_OUT_HANDLER, AXIS2_HASH_KEY_STRING, + axis2_addr_out_handler_create); + + return AXIS2_SUCCESS; +} + +/** + * Following block distinguish the exposed part of the dll. + */ + +AXIS2_EXPORT int +axis2_get_instance( + axis2_module_t ** inst, + const axutil_env_t * env) +{ + *inst = axis2_mod_addr_create(env); + if(!(*inst)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create addressing module"); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT int +axis2_remove_instance( + axis2_module_t * inst, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + + if(inst) + { + status = axis2_mod_addr_shutdown(inst, env); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Addressing module not found"); + } + + return status; +} diff --git a/src/modules/mod_addr/module.xml b/src/modules/mod_addr/module.xml new file mode 100644 index 0000000..8fd59a8 --- /dev/null +++ b/src/modules/mod_addr/module.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/src/modules/mod_log/Makefile.am b/src/modules/mod_log/Makefile.am new file mode 100644 index 0000000..9e1064c --- /dev/null +++ b/src/modules/mod_log/Makefile.am @@ -0,0 +1,22 @@ +prglibdir=$(prefix)/modules/logging +prglib_LTLIBRARIES = libaxis2_mod_log.la +prglib_DATA= module.xml +EXTRA_DIST = module.xml mod_log.h +libaxis2_mod_log_la_SOURCES = log_in_handler.c \ + log_out_handler.c \ + mod_log.c + +libaxis2_mod_log_la_LIBADD = \ + $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/axiom/src/om/libaxis2_axiom.la + +libaxis2_mod_log_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include\ + -I$(top_builddir)/axiom/include diff --git a/src/modules/mod_log/log_in_handler.c b/src/modules/mod_log/log_in_handler.c new file mode 100644 index 0000000..e7f7464 --- /dev/null +++ b/src/modules/mod_log/log_in_handler.c @@ -0,0 +1,90 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +axis2_status_t AXIS2_CALL +axutil_log_in_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); + +AXIS2_EXTERN axis2_handler_t *AXIS2_CALL +axutil_log_in_handler_create( + const axutil_env_t * env, + axutil_string_t * name) +{ + axis2_handler_t *handler = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + handler = axis2_handler_create(env); + if(!handler) + { + return NULL; + } + + axis2_handler_set_invoke(handler, env, axutil_log_in_handler_invoke); + + return handler; +} + +axis2_status_t AXIS2_CALL +axutil_log_in_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_node_t *ret_node = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + AXIS2_LOG_INFO(env->log, "Starting logging in handler ........."); + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + if(soap_envelope) + { + /* ensure SOAP buider state is in sync */ + axiom_soap_envelope_get_body(soap_envelope, env); + ret_node = axiom_soap_envelope_get_base_node(soap_envelope, env); + + if(ret_node) + { + axis2_char_t *om_str = NULL; + om_str = axiom_node_to_string(ret_node, env); + if(om_str) + { + AXIS2_LOG_INFO(env->log, "Input message: %s", om_str); + } + } + } + + return AXIS2_SUCCESS; +} diff --git a/src/modules/mod_log/log_out_handler.c b/src/modules/mod_log/log_out_handler.c new file mode 100644 index 0000000..14af2b6 --- /dev/null +++ b/src/modules/mod_log/log_out_handler.c @@ -0,0 +1,88 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +axis2_status_t AXIS2_CALL +axutil_log_out_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx); + +AXIS2_EXTERN axis2_handler_t *AXIS2_CALL +axutil_log_out_handler_create( + const axutil_env_t * env, + axutil_string_t * name) +{ + axis2_handler_t *handler = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + handler = axis2_handler_create(env); + if(!handler) + { + return NULL; + } + + axis2_handler_set_invoke(handler, env, axutil_log_out_handler_invoke); + + return handler; +} + +axis2_status_t AXIS2_CALL +axutil_log_out_handler_invoke( + struct axis2_handler * handler, + const axutil_env_t * env, + struct axis2_msg_ctx * msg_ctx) +{ + axiom_soap_envelope_t *soap_envelope = NULL; + axiom_node_t *ret_node = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + AXIS2_LOG_INFO(env->log, "Starting logging out handler ........."); + + soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + if(soap_envelope) + { + ret_node = axiom_soap_envelope_get_base_node(soap_envelope, env); + + if(ret_node) + { + axis2_char_t *om_str = NULL; + om_str = axiom_node_to_string(ret_node, env); + if(om_str) + { + AXIS2_LOG_INFO(env->log, "Output message: %s", om_str); + } + } + } + + return AXIS2_SUCCESS; +} diff --git a/src/modules/mod_log/mod_log.c b/src/modules/mod_log/mod_log.c new file mode 100644 index 0000000..ce68c91 --- /dev/null +++ b/src/modules/mod_log/mod_log.c @@ -0,0 +1,141 @@ +/* + * 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. + */ +#include +#include + +#include "mod_log.h" + +axis2_status_t AXIS2_CALL +axis2_mod_log_shutdown( + axis2_module_t * module, + const axutil_env_t * env); + +axis2_status_t AXIS2_CALL +axis2_mod_log_init( + axis2_module_t * module, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_module_desc_t * module_desc); + +axis2_status_t AXIS2_CALL +axis2_mod_log_fill_handler_create_func_map( + axis2_module_t * module, + const axutil_env_t * env); + +/** + * Module operations struct variable with functions assigned to members + */ +static const axis2_module_ops_t log_module_ops_var = { axis2_mod_log_init, axis2_mod_log_shutdown, + axis2_mod_log_fill_handler_create_func_map }; + +axis2_module_t * +axis2_mod_log_create( + const axutil_env_t * env) +{ + axis2_module_t *module = NULL; + module = AXIS2_MALLOC(env->allocator, sizeof(axis2_module_t)); + + /* initialize operations */ + module->ops = &log_module_ops_var; + + return module; +} + +axis2_status_t AXIS2_CALL +axis2_mod_log_init( + axis2_module_t * module, + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx, + axis2_module_desc_t * module_desc) +{ + /* Any initialization stuff related to this module can be here */ + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_mod_log_shutdown( + axis2_module_t * module, + const axutil_env_t * env) +{ + if(module->handler_create_func_map) + { + axutil_hash_free(module->handler_create_func_map, env); + } + + if(module) + { + AXIS2_FREE(env->allocator, module); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_mod_log_fill_handler_create_func_map( + axis2_module_t * module, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + module->handler_create_func_map = axutil_hash_make(env); + if(!module->handler_create_func_map) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + /* add in handler */ + axutil_hash_set(module->handler_create_func_map, "LoggingInHandler", AXIS2_HASH_KEY_STRING, + axutil_log_in_handler_create); + + /* add out handler */ + axutil_hash_set(module->handler_create_func_map, "LoggingOutHandler", AXIS2_HASH_KEY_STRING, + axutil_log_out_handler_create); + + return AXIS2_SUCCESS; +} + +/** + * Following functions are expected to be there in the module lib + * that helps to create and remove module instances + */ + +AXIS2_EXPORT int +axis2_get_instance( + axis2_module_t ** inst, + const axutil_env_t * env) +{ + *inst = axis2_mod_log_create(env); + if(!(*inst)) + { + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXPORT int +axis2_remove_instance( + axis2_module_t * inst, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + if(inst) + { + status = axis2_mod_log_shutdown(inst, env); + } + return status; +} diff --git a/src/modules/mod_log/mod_log.h b/src/modules/mod_log/mod_log.h new file mode 100644 index 0000000..c399187 --- /dev/null +++ b/src/modules/mod_log/mod_log.h @@ -0,0 +1,50 @@ + +/* + * 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_MOD_LOG_H +#define AXIS2_MOD_LOG_H + +/** + * @file mod_log.h + * @brief Axis2 logging module interface + */ + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axutil_log_in_handler_create( + const axutil_env_t * env, + axutil_string_t * name); + + AXIS2_EXTERN axis2_handler_t *AXIS2_CALL + axutil_log_out_handler_create( + const axutil_env_t * env, + axutil_string_t * name); + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_MOD_LOG_H */ diff --git a/src/modules/mod_log/module.xml b/src/modules/mod_log/module.xml new file mode 100644 index 0000000..8518b20 --- /dev/null +++ b/src/modules/mod_log/module.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + -- cgit v1.1-32-gdbae