Return-Path: Delivered-To: apmail-ws-axis-cvs-archive@www.apache.org Received: (qmail 85248 invoked from network); 5 Apr 2006 08:49:21 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 5 Apr 2006 08:49:20 -0000 Received: (qmail 62380 invoked by uid 500); 5 Apr 2006 08:49:18 -0000 Delivered-To: apmail-ws-axis-cvs-archive@ws.apache.org Received: (qmail 62280 invoked by uid 500); 5 Apr 2006 08:49:17 -0000 Mailing-List: contact axis-cvs-help@ws.apache.org; run by ezmlm Precedence: bulk list-help: list-unsubscribe: List-Post: List-Id: Delivered-To: mailing list axis-cvs@ws.apache.org Received: (qmail 62269 invoked by uid 500); 5 Apr 2006 08:49:17 -0000 Delivered-To: apmail-ws-axis2-cvs@ws.apache.org Received: (qmail 62266 invoked by uid 99); 5 Apr 2006 08:49:17 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 05 Apr 2006 01:49:17 -0700 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME,UPPERCASE_25_50 X-Spam-Check-By: apache.org Received: from [209.237.227.194] (HELO minotaur.apache.org) (209.237.227.194) by apache.org (qpsmtpd/0.29) with SMTP; Wed, 05 Apr 2006 01:49:15 -0700 Received: (qmail 84909 invoked by uid 65534); 5 Apr 2006 08:48:55 -0000 Message-ID: <20060405084855.84908.qmail@minotaur.apache.org> Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r391562 - in /webservices/axis2/trunk/c: include/ modules/core/transport/http/ modules/core/transport/http/sender/ modules/core/transport/http/server/apache2/ Date: Wed, 05 Apr 2006 08:48:53 -0000 To: axis2-cvs@ws.apache.org From: sahan@apache.org X-Mailer: svnmailer-1.0.7 X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Author: sahan Date: Wed Apr 5 01:48:51 2006 New Revision: 391562 URL: http://svn.apache.org/viewcvs?rev=391562&view=rev Log: REST thru POST works on server side. Client side code is in place. Didn't test Added: webservices/axis2/trunk/c/include/axis2_rest_sender.h webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c Modified: webservices/axis2/trunk/c/include/axis2_soap_body.h webservices/axis2/trunk/c/modules/core/transport/http/http_transport_utils.c webservices/axis2/trunk/c/modules/core/transport/http/sender/Makefile.am webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c webservices/axis2/trunk/c/modules/core/transport/http/server/apache2/mod_axis2.c Added: webservices/axis2/trunk/c/include/axis2_rest_sender.h URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/include/axis2_rest_sender.h?rev=391562&view=auto ============================================================================== --- webservices/axis2/trunk/c/include/axis2_rest_sender.h (added) +++ webservices/axis2/trunk/c/include/axis2_rest_sender.h Wed Apr 5 01:48:51 2006 @@ -0,0 +1,126 @@ +/* + * 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 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_REST_SENDER_H +#define AXIS2_REST_SENDER_H + +/** + * @file axis2_rest_sender.h + * @brief axis2 REST sender + */ + +#include +#include +#include +#include +#include +#include +#include + + +#ifdef __cplusplus +extern "C" +{ +#endif +/** + * @ingroup axis2_core_transport_http + * @{ + */ + +typedef struct axis2_rest_sender_ops axis2_rest_sender_ops_t; +typedef struct axis2_rest_sender axis2_rest_sender_t; + + +/** + * @brief REST sender ops struct + * Encapsulator struct for ops of axis2_rest_sender + */ +AXIS2_DECLARE_DATA struct axis2_rest_sender_ops +{ + axis2_status_t (AXIS2_CALL *send) + (axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_om_node_t *out, + axis2_char_t *str_url); + + axis2_status_t (AXIS2_CALL *set_chunked) + (axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_bool_t chunked); + + axis2_status_t (AXIS2_CALL *set_om_output) + (axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_om_output_t *om_output); + + axis2_status_t (AXIS2_CALL *set_http_version) + (axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_char_t *version); + + axis2_status_t (AXIS2_CALL *free) + (axis2_rest_sender_t *sender, + axis2_env_t **env); +}; + + +axis2_status_t AXIS2_CALL +axis2_rest_sender_get_header_info + (axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_http_simple_response_t *response); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_process_response + (axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_http_simple_response_t *response); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_get_timeout_values + (axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx); + +/** + * @brief REST sender struct + * Axis2 REST sender + */ +AXIS2_DECLARE_DATA struct axis2_rest_sender +{ + axis2_rest_sender_ops_t *ops; +}; + + +AXIS2_DECLARE(axis2_rest_sender_t *) +axis2_rest_sender_create(axis2_env_t **env); + +/********************* Start of function macros ***************************/ + +#define AXIS2_REST_SENDER_SEND(sender, env, msg_ctx, output, url)\ + ((sender)->ops->send (sender, env, msg_ctx,output, url)) +#define AXIS2_REST_SENDER_SET_CHUNKED(sender, env, chunked) \ + ((sender)->ops->set_chunked(sender, env, chunked)) +#define AXIS2_REST_SENDER_SET_OM_OUTPUT(sender, env, om_output) \ + ((sender)->ops->set_om_output (sender, env, om_output)) +#define AXIS2_REST_SENDER_SET_HTTP_VERSION(sender, env, version)\ + ((sender)->ops->set_http_version (sender, env, version)) +#define AXIS2_REST_SENDER_FREE(sender, env) \ + ((sender)->ops->free(sender, env)) + +/************************* End of function macros *****************************/ + +/** @} */ +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_REST_SENDER_H */ Modified: webservices/axis2/trunk/c/include/axis2_soap_body.h URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/include/axis2_soap_body.h?rev=391562&r1=391561&r2=391562&view=diff ============================================================================== --- webservices/axis2/trunk/c/include/axis2_soap_body.h (original) +++ webservices/axis2/trunk/c/include/axis2_soap_body.h Wed Apr 5 01:48:51 2006 @@ -184,7 +184,7 @@ ((body)->ops->build( body, env)) #define AXIS2_SOAP_BODY_ADD_CHILD( body, env, child) \ - ((body)->ops->add_child( body, env, child); + ((body)->ops->add_child( body, env, child)); /** @} */ #ifdef __cplusplus } Modified: webservices/axis2/trunk/c/modules/core/transport/http/http_transport_utils.c URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/transport/http/http_transport_utils.c?rev=391562&r1=391561&r2=391562&view=diff ============================================================================== --- webservices/axis2/trunk/c/modules/core/transport/http/http_transport_utils.c (original) +++ webservices/axis2/trunk/c/modules/core/transport/http/http_transport_utils.c Wed Apr 5 01:48:51 2006 @@ -240,8 +240,7 @@ else if(NULL != strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) { is_soap11 = AXIS2_TRUE; - /*if(NULL != soap_action_header && AXIS2_STRLEN(soap_action_header) - > 0)*/ + if(NULL != soap_action_header) { soap_builder = axis2_soap_builder_create(env, om_builder, AXIS2_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI); @@ -265,15 +264,28 @@ return AXIS2_FAILURE; } } - /* REST support - * else - * { - * envelope = AXIS2_SOAP_ENVELOPE_GET_DEFAULT_SOAP_ENVELOPE( - * env); - * AXIS2_SOAP_BODY_ADD_CHILD(AXIS2_SOAP_ENVELOPE_GET_BODY( - * envelope, env), AXIS2_OM_STAX_BUILDER_GET_DOCUMENT( - * om_builder, env)); - */ + else + { + /* REST support */ + axis2_param_t *rest_param = AXIS2_MSG_CTX_GET_PARAMETER(msg_ctx, env + , AXIS2_ENABLE_REST); + if(NULL != rest_param && 0 == AXIS2_STRCMP(AXIS2_VALUE_TRUE, + AXIS2_PARAM_GET_VALUE(rest_param, env))) + { + /* TODO we have to check for NULLs */ + axis2_soap_body_t *def_body = NULL; + axis2_om_document_t *om_doc = NULL; + axis2_om_node_t *root_node = NULL; + soap_envelope = axis2_soap_envelope_create_default_soap_envelope + (env, AXIS2_SOAP11); + def_body = AXIS2_SOAP_ENVELOPE_GET_BODY(soap_envelope, env); + om_doc = AXIS2_OM_STAX_BUILDER_GET_DOCUMENT(om_builder, env); + root_node = AXIS2_OM_DOCUMENT_BUILD_ALL(om_doc, env); + AXIS2_SOAP_BODY_ADD_CHILD(def_body, env, root_node); + AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx, env, AXIS2_TRUE); + } + } + } /* xml_char_set = AXIS2_OM_DOCUMENT_GET_CHARSET_ENC( * AXIS2_OM_STAX_BUILDER_GET_DOCUMENT(env om_builder), Modified: webservices/axis2/trunk/c/modules/core/transport/http/sender/Makefile.am URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/transport/http/sender/Makefile.am?rev=391562&r1=391561&r2=391562&view=diff ============================================================================== --- webservices/axis2/trunk/c/modules/core/transport/http/sender/Makefile.am (original) +++ webservices/axis2/trunk/c/modules/core/transport/http/sender/Makefile.am Wed Apr 5 01:48:51 2006 @@ -2,6 +2,7 @@ lib_LTLIBRARIES = libaxis2_http_sender.la libaxis2_http_sender_la_SOURCES = http_transport_sender.c\ soap_over_http_sender.c\ + rest_sender.c\ http_client.c INCLUDES = -I$(top_builddir)/include \ Modified: webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c?rev=391562&r1=391561&r2=391562&view=diff ============================================================================== --- webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c (original) +++ webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c Wed Apr 5 01:48:51 2006 @@ -24,6 +24,8 @@ #include #include #include +#include +#include #include @@ -159,12 +161,10 @@ axis2_soap_envelope_t *soap_data_out = NULL; axis2_bool_t do_mtom; axis2_property_t *property = NULL; + axis2_om_node_t *data_out = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE); - - xml_writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0); - om_output = axis2_om_output_create(env, xml_writer); property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE); @@ -203,9 +203,9 @@ do_mtom = axis2_http_transport_utils_do_write_mtom(env, msg_ctx); AXIS2_MSG_CTX_SET_DOING_MTOM(msg_ctx, env, do_mtom); - AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx, + /*AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx, env, axis2_http_transport_utils_is_doing_rest(env, - msg_ctx)); + msg_ctx));*/ property = (axis2_property_t*)AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIS2_TRANSPORT_URL, AXIS2_FALSE); if(property) @@ -230,30 +230,29 @@ } } - /*if(AXIS2_TRUE == AXIS2_MSG_CTX_IS_DOING_REST(msg_ctx, env)) - *{ - * data_out = AXIS2_SOAP_BODY_GET_FIRST_ELEMENT(AXIS2_SOAP_ENVELOPE_GET_BODY( - AXIS2_MSG_CTX_GET_ENVELOPE(msg_ctx, env), env),env); - *} - * else - */ - { - soap_data_out = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env); - if(NULL == soap_data_out) - { - char error_msg[1024]; - AXIS2_ERROR_SET((*env)->error, - AXIS2_ERROR_NULL_SOAP_ENVELOPE_IN_MSG_CTX, - AXIS2_FAILURE); - sprintf(error_msg, "%s in %s:%d", AXIS2_ERROR_GET_MESSAGE( - (*env)->error), __FILE__, __LINE__); - AXIS2_LOG(env, error_msg, AXIS2_LOG_LEVEL_CRITICAL); - AXIS2_OM_OUTPUT_FREE(om_output, env); - om_output = NULL; - xml_writer = NULL; - return AXIS2_FAILURE; - } - } + soap_data_out = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env); + if(NULL == soap_data_out) + { + AXIS2_ERROR_SET((*env)->error, + 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_FAILURE; + } + xml_writer = axis2_xml_writer_create_for_memory(env, NULL, + AXIS2_TRUE, 0); + if(NULL == xml_writer) + { + return AXIS2_FAILURE; + } + om_output = axis2_om_output_create(env, xml_writer); + if(NULL == om_output) + { + AXIS2_XML_WRITER_FREE(xml_writer, env); + xml_writer = NULL; + return AXIS2_FAILURE; + } if(NULL != epr) { axis2_http_transport_sender_write_message(transport_sender, env, msg_ctx @@ -292,6 +291,9 @@ { AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE); + AXIS2_OM_OUTPUT_FREE(om_output, env); + om_output = NULL; + xml_writer = NULL; return AXIS2_FAILURE; } is_soap11 = AXIS2_MSG_CTX_GET_IS_SOAP_11(msg_ctx, env); @@ -315,9 +317,50 @@ /* AXIS2_OM_OUTPUT_SET_DO_OPTIMIZE(om_output, env, * AXIS2_MSG_CTX_GET_IS_DOING_MTOM(msg_ctx, env); */ - AXIS2_SOAP_ENVELOPE_SERIALIZE (soap_data_out, env, om_output, - AXIS2_FALSE); - buffer = AXIS2_XML_WRITER_GET_XML(xml_writer, env); + if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_DOING_REST(msg_ctx, env)) + { + axis2_om_node_t *body_node = NULL; + axis2_soap_body_t *soap_body = AXIS2_SOAP_ENVELOPE_GET_BODY( + soap_data_out, env); + + if(NULL == soap_body) + { + AXIS2_ERROR_SET((*env)->error, + AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, + AXIS2_FAILURE); + AXIS2_LOG_ERROR((*env)->log, AXIS2_LOG_SI, "%s", + AXIS2_ERROR_GET_MESSAGE((*env)->error)); + AXIS2_OM_OUTPUT_FREE(om_output, env); + om_output = NULL; + xml_writer = NULL; + return AXIS2_FAILURE; + } + body_node = AXIS2_SOAP_BODY_GET_BASE_NODE(soap_body,env); + if(NULL == body_node) + { + AXIS2_OM_OUTPUT_FREE(om_output, env); + om_output = NULL; + xml_writer = NULL; + return AXIS2_FAILURE; + } + data_out = AXIS2_OM_NODE_GET_FIRST_CHILD(body_node, env); + if(NULL == data_out || AXIS2_OM_NODE_GET_NODE_TYPE(data_out,env) + != AXIS2_OM_ELEMENT) + { + AXIS2_OM_OUTPUT_FREE(om_output, env); + om_output = NULL; + xml_writer = NULL; + return AXIS2_FAILURE; + } + AXIS2_OM_NODE_SERIALIZE(data_out, env, om_output); + buffer = AXIS2_XML_WRITER_GET_XML(xml_writer, env); + } + else + { + AXIS2_SOAP_ENVELOPE_SERIALIZE (soap_data_out, env, om_output, + AXIS2_FALSE); + buffer = AXIS2_XML_WRITER_GET_XML(xml_writer, env); + } AXIS2_STREAM_WRITE(out_stream, env, buffer, AXIS2_STRLEN(buffer)); AXIS2_FREE((*env)->allocator, buffer); @@ -500,35 +543,62 @@ { soap_action = ""; } - /* - * TODO : when REST comes - * if(AXIS2_TRUE == AXIS2_MSG_CTX_IS_DOING_REST(msg_ctx, env) - * { - * axis2_rest_sender_t *sender = axis2_rest_sender_create(env) - * AXIS2_REST_SENDER_SET_FORMAT(sender, env, - * AXIS2_INTF_TO_IMPL(transport_sender)->format); - * AXIS2_REST_SENDER_SEND(sender, env, msg_ctx, data_out, url, - * soap_action); - * } - */ - sender = axis2_soap_over_http_sender_create(env); - - if(NULL == sender) - { - return AXIS2_FAILURE; - } - AXIS2_SOAP_OVER_HTTP_SENDER_SET_CHUNKED(sender, env, - AXIS2_INTF_TO_IMPL(transport_sender)->chunked); - AXIS2_SOAP_OVER_HTTP_SENDER_SET_OM_OUTPUT(sender, env, om_output); - AXIS2_SOAP_OVER_SENDER_SET_HTTP_VERSION(sender, env, - AXIS2_INTF_TO_IMPL(transport_sender)->http_version); - status = AXIS2_SOAP_OVER_HTTP_SENDER_SEND(sender, env, msg_ctx, out, url, - soap_action); - /* - * TODO check for errors - */ - AXIS2_SOAP_OVER_HTTP_SENDER_FREE(sender, env); - sender = NULL; + if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_DOING_REST(msg_ctx, env)) + { + axis2_om_node_t *data_out = NULL; + axis2_om_node_t *body_node = NULL; + axis2_soap_body_t *soap_body = AXIS2_SOAP_ENVELOPE_GET_BODY(out, env); + axis2_rest_sender_t *sender = NULL; + + if(NULL == soap_body) + { + AXIS2_ERROR_SET((*env)->error, + AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, + AXIS2_FAILURE); + AXIS2_LOG_ERROR((*env)->log, AXIS2_LOG_SI, "%s", + AXIS2_ERROR_GET_MESSAGE((*env)->error)); + return AXIS2_FAILURE; + } + body_node = AXIS2_SOAP_BODY_GET_BASE_NODE(soap_body,env); + if(NULL == body_node) + { + return AXIS2_FAILURE; + } + data_out = AXIS2_OM_NODE_GET_FIRST_CHILD(body_node, env); + if(NULL == data_out || AXIS2_OM_NODE_GET_NODE_TYPE(data_out, env) + != AXIS2_OM_ELEMENT) + { + return AXIS2_FAILURE; + } + sender = axis2_rest_sender_create(env); + AXIS2_REST_SENDER_SET_CHUNKED(sender, env, + AXIS2_INTF_TO_IMPL(transport_sender)->chunked); + AXIS2_REST_SENDER_SET_OM_OUTPUT(sender, env, om_output); + AXIS2_REST_SENDER_SET_HTTP_VERSION(sender, env, + AXIS2_INTF_TO_IMPL(transport_sender)->http_version); + status = AXIS2_REST_SENDER_SEND(sender, env, msg_ctx, data_out, url); + } + else + { + sender = axis2_soap_over_http_sender_create(env); + + if(NULL == sender) + { + return AXIS2_FAILURE; + } + AXIS2_SOAP_OVER_HTTP_SENDER_SET_CHUNKED(sender, env, + AXIS2_INTF_TO_IMPL(transport_sender)->chunked); + AXIS2_SOAP_OVER_HTTP_SENDER_SET_OM_OUTPUT(sender, env, om_output); + AXIS2_SOAP_OVER_SENDER_SET_HTTP_VERSION(sender, env, + AXIS2_INTF_TO_IMPL(transport_sender)->http_version); + status = AXIS2_SOAP_OVER_HTTP_SENDER_SEND(sender, env, msg_ctx, out, url + , soap_action); + /* + * TODO check for errors + */ + AXIS2_SOAP_OVER_HTTP_SENDER_FREE(sender, env); + sender = NULL; + } return status; } Added: webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c?rev=391562&view=auto ============================================================================== --- webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c (added) +++ webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c Wed Apr 5 01:48:51 2006 @@ -0,0 +1,528 @@ +/* + * 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 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 + +/** + * @brief REST sender struct impl + * Axis2 REST sender impl + */ +typedef struct axis2_rest_sender_impl + axis2_rest_sender_impl_t; + +struct axis2_rest_sender_impl +{ + axis2_rest_sender_t sender; + axis2_char_t *http_version; + axis2_bool_t chunked; + int so_timeout; + int connection_timeout; + axis2_om_output_t *om_output; + axis2_http_client_t *client; +}; + +#define AXIS2_INTF_TO_IMPL(sender) \ + ((axis2_rest_sender_impl_t *)(sender)) + +/***************************** Function headers *******************************/ +axis2_status_t AXIS2_CALL +axis2_rest_sender_get_header_info(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_http_simple_response_t *response); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_process_response(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_http_simple_response_t *response); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_get_timeout_values(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_send(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_om_node_t *out, axis2_char_t *str_url); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_set_chunked(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_bool_t chunked); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_set_om_output(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_om_output_t *om_output); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_set_http_version(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_char_t *version); + +axis2_status_t AXIS2_CALL +axis2_rest_sender_free(axis2_rest_sender_t *sender, + axis2_env_t **env); +/***************************** End of function headers ************************/ + +axis2_rest_sender_t * AXIS2_CALL +axis2_rest_sender_create(axis2_env_t **env) +{ + axis2_rest_sender_impl_t *sender_impl = NULL; + AXIS2_ENV_CHECK(env, NULL); + + sender_impl = (axis2_rest_sender_impl_t *)AXIS2_MALLOC + ((*env)->allocator, sizeof( + axis2_rest_sender_impl_t)); + + if(NULL == sender_impl) + { + AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + sender_impl->http_version = AXIS2_HTTP_HEADER_PROTOCOL_11; + sender_impl->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT; + sender_impl->connection_timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT; + sender_impl->om_output = NULL; + sender_impl->chunked = AXIS2_FALSE; + sender_impl->client = NULL; + + sender_impl->sender.ops = AXIS2_MALLOC((*env)->allocator, + sizeof(axis2_rest_sender_ops_t)); + if(NULL == sender_impl->sender.ops) + { + axis2_rest_sender_free((axis2_rest_sender_t*) + sender_impl, env); + AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + sender_impl->sender.ops->send = + axis2_rest_sender_send; + sender_impl->sender.ops->set_chunked = + axis2_rest_sender_set_chunked; + sender_impl->sender.ops->set_om_output = + axis2_rest_sender_set_om_output; + sender_impl->sender.ops->set_http_version = + axis2_rest_sender_set_http_version; + sender_impl->sender.ops->free = + axis2_rest_sender_free; + return &(sender_impl->sender); +} + +axis2_status_t AXIS2_CALL +axis2_rest_sender_free (axis2_rest_sender_t *sender, + axis2_env_t **env) +{ + axis2_rest_sender_impl_t *sender_impl = NULL; + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + sender_impl = AXIS2_INTF_TO_IMPL(sender); + if(NULL != sender_impl->http_version) + { + AXIS2_FREE((*env)->allocator, sender_impl->http_version); + sender_impl->http_version= NULL; + } + if(NULL != sender->ops) + AXIS2_FREE((*env)->allocator, sender->ops); + + /* Do not free this here since it will be required in later processing + * of the response soap message + */ + sender_impl->client = NULL; + AXIS2_FREE((*env)->allocator, sender_impl); + return AXIS2_SUCCESS; +} + + +axis2_status_t AXIS2_CALL +axis2_rest_sender_send(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_om_node_t *out, axis2_char_t *str_url) +{ + axis2_http_simple_request_t *request = NULL; + axis2_http_request_line_t *request_line = NULL; + axis2_url_t *url = NULL; + axis2_rest_sender_impl_t *sender_impl = NULL; + axis2_xml_writer_t *xml_writer = NULL; + axis2_char_t *buffer = NULL; + axis2_char_t *char_set_enc = NULL; + int status_code = -1; + axis2_http_header_t *http_header = NULL; + axis2_http_simple_response_t *response = NULL; + axis2_char_t *content_type = NULL; + axis2_property_t *property = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + 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); + + url = axis2_url_parse_string(env, str_url); + sender_impl = AXIS2_INTF_TO_IMPL(sender); + if(NULL == url) + { + return AXIS2_FAILURE; + } + + if (sender_impl->client) + { + AXIS2_HTTP_CLIENT_FREE(sender_impl->client, env); + sender_impl->client = NULL; + } + + sender_impl->client = axis2_http_client_create(env, url); + if(NULL == sender_impl->client) + { + return AXIS2_FAILURE; + } + /* We put the client into msg_ctx so that we can free it once the processing + * is done at client side + */ + property = axis2_property_create(env); + AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); + AXIS2_PROPERTY_SET_FREE_FUNC(property, env, + axis2_http_client_free_void_arg); + AXIS2_PROPERTY_SET_VALUE(property, env, sender_impl->client); + AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, AXIS2_HTTP_CLIENT, + property, AXIS2_TRUE); + + if(NULL == sender_impl->om_output) + { + AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NULL_OM_OUTPUT, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + xml_writer = AXIS2_OM_OUTPUT_GET_XML_WRITER(sender_impl->om_output, env); + + property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, + AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE); + if(property) + { + char_set_enc = AXIS2_PROPERTY_GET_VALUE(property, env); + property = NULL; + } + if(NULL == char_set_enc) + { + char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; + } + /* AXIS2_OM_OUTPUT_SET_DO_OPTIMIZE(om_output, env, + * AXIS2_MSG_CTX_GET_IS_DOING_MTOM(msg_ctx, env); + */ + AXIS2_OM_NODE_SERIALIZE (out, env, sender_impl->om_output); + buffer = AXIS2_XML_WRITER_GET_XML(xml_writer, env); + + if(NULL == buffer) + { + AXIS2_LOG_ERROR((*env)->log, AXIS2_LOG_SI, "NULL xml returned" + "from xml writer"); + return AXIS2_FAILURE; + } + + request_line = axis2_http_request_line_create(env, "POST", + AXIS2_URL_GET_PATH(url, env), + sender_impl->http_version); + request = axis2_http_simple_request_create(env, request_line, NULL, 0, + NULL); + + http_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_USER_AGENT, + "Axis2/C"); + AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header); + if(AXIS2_FALSE == sender_impl->chunked) + { + axis2_char_t tmp_buf[10]; + sprintf(tmp_buf, "%d", strlen(buffer)); + http_header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, tmp_buf); + AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header); + } + else + { + http_header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED); + AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header); + } + /* TODO we need to set the content type with soap action header for soap12*/ + content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML; + http_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE, + content_type); + AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header); + if(0 == AXIS2_STRCMP(sender_impl->http_version, + AXIS2_HTTP_HEADER_PROTOCOL_11)) + { + http_header = axis2_http_header_create(env, + AXIS2_HTTP_HEADER_HOST, + AXIS2_URL_GET_SERVER(url, env)); + AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header); + } + AXIS2_HTTP_SIMPLE_REQUEST_SET_BODY_STRING(request, env, buffer); + axis2_rest_sender_get_timeout_values(sender, env, msg_ctx); + AXIS2_HTTP_CLIENT_SET_TIMEOUT(sender_impl->client, env, + sender_impl->so_timeout); + + status_code = AXIS2_HTTP_CLIENT_SEND(sender_impl->client, env, request); + + AXIS2_FREE((*env)->allocator, buffer); + buffer = NULL; + AXIS2_HTTP_SIMPLE_REQUEST_FREE(request, env); + request = NULL; + + status_code = AXIS2_HTTP_CLIENT_RECIEVE_HEADER(sender_impl->client, env); + + if(status_code < 0) + { + return AXIS2_FAILURE; + } + response = AXIS2_HTTP_CLIENT_GET_RESPONSE(sender_impl->client, env); + if(AXIS2_HTTP_RESPONSE_OK_CODE_VAL == status_code || + AXIS2_HTTP_RESPONSE_ACK_CODE_VAL == status_code) + { + return axis2_rest_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; + tmp_header = AXIS2_HTTP_SIMPLE_RESPONSE_GET_FIRST_HEADER(response, env, + AXIS2_HTTP_HEADER_CONTENT_TYPE); + if(NULL != tmp_header) + { + tmp_header_val = AXIS2_HTTP_HEADER_GET_VALUE(tmp_header, env); + } + if(NULL != tmp_header_val && (AXIS2_STRSTR(tmp_header_val, + AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP) || AXIS2_STRSTR( + tmp_header_val, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML))) + { + return axis2_rest_sender_process_response(sender, env, + msg_ctx, response); + } + } + AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, + AXIS2_FAILURE); + return AXIS2_FAILURE; +} + + +axis2_status_t AXIS2_CALL +axis2_rest_sender_set_chunked(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_bool_t chunked) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_INTF_TO_IMPL(sender)->chunked = chunked; + return AXIS2_SUCCESS; +} + + +axis2_status_t AXIS2_CALL +axis2_rest_sender_set_om_output(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_om_output_t *om_output) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_INTF_TO_IMPL(sender)->om_output = om_output; + return AXIS2_SUCCESS; +} + + +axis2_status_t AXIS2_CALL +axis2_rest_sender_get_header_info(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_http_simple_response_t *response) +{ + axis2_array_list_t *headers = NULL; + axis2_char_t *charset = NULL; + axis2_rest_sender_impl_t *sender_impl = NULL; + int i = 0; + axis2_bool_t response_chunked = AXIS2_FALSE; + int *content_length = NULL; + axis2_property_t *property = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK((*env)->error, msg_ctx, AXIS2_FAILURE); + AXIS2_PARAM_CHECK((*env)->error, response, AXIS2_FAILURE); + + sender_impl = AXIS2_INTF_TO_IMPL(sender); + + /* + * TODO MTOM support (MIME header) + */ + headers = AXIS2_HTTP_SIMPLE_RESPONSE_GET_HEADERS(response, env); + if(headers == NULL) + { + return AXIS2_SUCCESS; + } + for(i = 0; i < AXIS2_ARRAY_LIST_SIZE(headers, env); i++) + { + axis2_http_header_t *header = AXIS2_ARRAY_LIST_GET(headers, env, i); + axis2_char_t *name = AXIS2_HTTP_HEADER_GET_NAME((axis2_http_header_t *) + header, env); + if(NULL != name) + { + if(0 == AXIS2_STRCMP(name, AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && + 0 == AXIS2_STRCMP(AXIS2_HTTP_HEADER_GET_VALUE(header + , env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) + { + axis2_char_t *transfer_encoding = NULL; + + transfer_encoding = + AXIS2_STRDUP(AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED, + env); + property = axis2_property_create(env); + AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); + AXIS2_PROPERTY_SET_VALUE(property, env, transfer_encoding); + AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, + AXIS2_HTTP_HEADER_TRANSFER_ENCODING, + property, + AXIS2_FALSE); + response_chunked = AXIS2_TRUE; + } + if(0 != AXIS2_STRCMP(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(NULL != charset) + { + charset = AXIS2_STRDUP(tmp_charset, env); + break; + } + } + } + } + if(NULL != charset) + { + axis2_ctx_t *axis_ctx = AXIS2_OP_CTX_GET_BASE(AXIS2_MSG_CTX_GET_OP_CTX( + msg_ctx, env), env); + if(NULL != axis_ctx) + { + property = axis2_property_create(env); + AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); + AXIS2_PROPERTY_SET_VALUE(property, env, charset); + AXIS2_CTX_SET_PROPERTY(axis_ctx, env, AXIS2_CHARACTER_SET_ENCODING, + property, AXIS2_FALSE); + } + } + if(AXIS2_FALSE == response_chunked) + { + int tmp_len = 0; + content_length = AXIS2_MALLOC((*env)->allocator, sizeof(int)); + if(NULL == content_length) + { + return AXIS2_FAILURE; + } + tmp_len = AXIS2_HTTP_SIMPLE_RESPONSE_GET_CONTENT_LENGTH(response, env); + memcpy(content_length, &tmp_len, sizeof(int)); + property = axis2_property_create(env); + AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); + AXIS2_PROPERTY_SET_VALUE(property, env, content_length); + AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, + AXIS2_HTTP_HEADER_CONTENT_LENGTH, property, + AXIS2_FALSE); + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_rest_sender_process_response(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx, + axis2_http_simple_response_t *response) +{ + axis2_stream_t *in_stream = NULL; + axis2_property_t *property = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + 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(NULL == in_stream) + { + AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NULL_STREAM_IN_RESPONSE_BODY, + AXIS2_FAILURE); + return AXIS2_FAILURE; + } + + axis2_rest_sender_get_header_info(sender, env, msg_ctx, response); + /*axis_ctx = AXIS2_OP_CTX_GET_BASE(AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env), + env);*/ + property = axis2_property_create(env); + AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); + AXIS2_PROPERTY_SET_FREE_FUNC(property, env, axis2_stream_free_void_arg); + AXIS2_PROPERTY_SET_VALUE(property, env, in_stream); + /*AXIS2_CTX_SET_PROPERTY(axis_ctx, env, AXIS2_TRANSPORT_IN, property, + AXIS2_FALSE);*/ + AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, AXIS2_TRANSPORT_IN, property, + AXIS2_FALSE); + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_rest_sender_get_timeout_values(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_msg_ctx_t *msg_ctx) +{ + axis2_char_t *so_str = NULL; + axis2_char_t *connection_str = NULL; + axis2_param_t *tmp_param = NULL; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + + tmp_param = AXIS2_MSG_CTX_GET_PARAMETER(msg_ctx, + env, AXIS2_HTTP_SO_TIMEOUT); + + if(NULL != tmp_param) + { + so_str = (axis2_char_t*)AXIS2_PARAM_GET_VALUE(tmp_param, env); + if(NULL != so_str) + { + AXIS2_INTF_TO_IMPL(sender)->so_timeout = AXIS2_ATOI(so_str); + } + } + tmp_param = AXIS2_MSG_CTX_GET_PARAMETER(msg_ctx, env, + AXIS2_HTTP_CONNECTION_TIMEOUT); + if(NULL != tmp_param) + { + connection_str = (axis2_char_t*)AXIS2_PARAM_GET_VALUE(tmp_param, env); + if(NULL != connection_str) + { + AXIS2_INTF_TO_IMPL(sender)->connection_timeout = + AXIS2_ATOI(connection_str); + } + } + return AXIS2_SUCCESS; +} + +axis2_status_t AXIS2_CALL +axis2_rest_sender_set_http_version(axis2_rest_sender_t *sender, + axis2_env_t **env, axis2_char_t *version) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_INTF_TO_IMPL(sender)->http_version = AXIS2_STRDUP(version, env); + if(NULL == AXIS2_INTF_TO_IMPL(sender)->http_version) + { + return AXIS2_FAILURE; + } + return AXIS2_SUCCESS; +} Modified: webservices/axis2/trunk/c/modules/core/transport/http/server/apache2/mod_axis2.c URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/transport/http/server/apache2/mod_axis2.c?rev=391562&r1=391561&r2=391562&view=diff ============================================================================== --- webservices/axis2/trunk/c/modules/core/transport/http/server/apache2/mod_axis2.c (original) +++ webservices/axis2/trunk/c/modules/core/transport/http/server/apache2/mod_axis2.c Wed Apr 5 01:48:51 2006 @@ -194,7 +194,6 @@ "log init failed\n"); status = AXIS2_FAILURE; } - axis2_logger->level = conf->log_level; thread_pool = axis2_thread_pool_init(allocator); if(NULL == thread_pool) { @@ -210,8 +209,13 @@ "axis2_environment init failed\n"); status = AXIS2_FAILURE; } - AXIS2_LOG_INFO(axis2_env->log, "Starting log with log level %d", + if(NULL != axis2_logger) + { + + axis2_logger->level = conf->log_level; + AXIS2_LOG_INFO(axis2_env->log, "Starting log with log level %d", conf->log_level); + } axis2_worker = axis2_apache2_worker_create(&axis2_env, conf->axis2_repo_path); if(NULL == axis2_worker)