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; }
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; }
axis2_status_t AXIS2_CALL adb_data_type0_deserialize_obj( adb_data_type0_t* _data_type0, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; void *element = NULL; const axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; status = AXIS2_FAILURE; if(parent) { axis2_char_t *attrib_text = NULL; attrib_text = axiom_element_get_attribute_value_by_name(axiom_node_get_data_element(parent, env), env, "nil"); if (attrib_text != NULL && !axutil_strcasecmp(attrib_text, "true")) { /* but the wsdl says that, this is non nillable */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element data_type0"); status = AXIS2_FAILURE; } else { axiom_node_t *text_node = NULL; axiom_text_t *text_element = NULL; text_node = axiom_node_get_first_child(parent, env); if (text_node && axiom_node_get_node_type(text_node, env) == AXIOM_TEXT) text_element = (axiom_text_t*)axiom_node_get_data_element(text_node, env); text_value = ""; if(text_element && axiom_text_get_value(text_element, env)) { text_value = (axis2_char_t*)axiom_text_get_value(text_element, env); } status = adb_data_type0_deserialize_from_string(_data_type0, env, text_value, parent); } } return status; }
/** * 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_EXTERN axutil_url_t *AXIS2_CALL axutil_url_parse_string( const axutil_env_t *env, const axis2_char_t *str_url) { /** * Only accepted format is : * protocol://host:port/path * Added file:///path * port is optional and the default port is assumed * if path is not present / (root) is assumed */ axis2_char_t *tmp_url_str = NULL; axutil_url_t *ret = NULL; const axis2_char_t *protocol = NULL; axis2_char_t *path = NULL; axis2_char_t *port_str = NULL; axis2_char_t *host = NULL; int port = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, str_url, NULL); tmp_url_str = axutil_strdup(env, str_url); if(!tmp_url_str) { return NULL; } protocol = tmp_url_str; host = strstr(tmp_url_str, "://"); if(!host) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_ADDRESS, AXIS2_FAILURE); AXIS2_FREE(env->allocator, tmp_url_str); return NULL; } if(axutil_strlen(host) < 3 * sizeof(axis2_char_t)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_ADDRESS, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid IP or hostname"); AXIS2_FREE(env->allocator, tmp_url_str); return NULL; } *host = '\0'; host += 3 * sizeof(axis2_char_t); /* skip "://" part */ if(axutil_strlen(host) <= 0) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_ADDRESS, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid IP or hostname"); AXIS2_FREE(env->allocator, tmp_url_str); return NULL; } /* if the url is file:// thing we need the protocol and * path only */ if(0 == axutil_strcasecmp(protocol, (const axis2_char_t *)"file")) { ret = axutil_url_create(env, protocol, NULL, 0, host); AXIS2_FREE(env->allocator, tmp_url_str); return ret; } port_str = strchr(host, ':'); if(!port_str) { path = strchr(host, '/'); if(!path) { path = strchr(host, '?'); } else { *path++ = '\0'; } if(!path) { path = strchr(host, '#'); } if(!path) { /* No path - assume def path ('/') */ /* here we have protocol + host + def port + def path */ ret = axutil_url_create(env, protocol, host, port, "/"); AXIS2_FREE(env->allocator, tmp_url_str); return ret; } else { axis2_char_t *path_temp = NULL; path_temp = axutil_strdup(env, path); *path = '\0'; /* here we have protocol + host + def port + path */ ret = axutil_url_create(env, protocol, host, port, path_temp); AXIS2_FREE(env->allocator, tmp_url_str); AXIS2_FREE(env->allocator, path_temp); return ret; } } else { *port_str++ = '\0'; path = strchr(port_str, '/'); if(!path) { path = strchr(port_str, '?'); if(path) { *path = '\0'; port = AXIS2_ATOI(port_str); *path = '?'; } } else { *path++ = '\0'; port = AXIS2_ATOI(port_str); } if(!path) { path = strchr(port_str, '#'); if(path) { *path = '\0'; port = AXIS2_ATOI(port_str); *path = '#'; } } if(!path) { port = AXIS2_ATOI(port_str); /* here we have protocol + host + port + def path */ ret = axutil_url_create(env, protocol, host, port, "/"); AXIS2_FREE(env->allocator, tmp_url_str); return ret; } else { if(axutil_strlen(path) > 0) { axis2_char_t *path_temp = NULL; path_temp = axutil_strdup(env, path); *path = '\0'; /* here we have protocol + host + port + path */ ret = axutil_url_create(env, protocol, host, port, path_temp); AXIS2_FREE(env->allocator, tmp_url_str); AXIS2_FREE(env->allocator, path_temp); return ret; } else { /* here we have protocol + host + port + def path */ ret = axutil_url_create(env, protocol, host, port, "/"); AXIS2_FREE(env->allocator, tmp_url_str); return ret; } } } }
axis2_status_t AXIS2_CALL prf_logOnResponseType_deserialize_obj( prf_logOnResponseType_t* _logOnResponseType, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; const axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _logOnResponseType, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for logOnResponseType : " "NULL element can not be passed to deserialize"); return AXIS2_FAILURE; } first_node = axiom_node_get_first_child(parent, env); /* * building logOnResult element */ current_node = first_node; is_early_node_valid = AXIS2_FALSE; while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } element_qname = axutil_qname_create(env, "logOnResult", "http://www.pratsam.org/ns/profile/", NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { if (!axutil_strcasecmp(text_value , "true")) { status = prf_logOnResponseType_set_logOnResult(_logOnResponseType, env, AXIS2_TRUE); } else { status = prf_logOnResponseType_set_logOnResult(_logOnResponseType, env, AXIS2_FALSE); } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element logOnResult"); status = AXIS2_FAILURE; } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for logOnResult "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } else if(!dont_care_minoccurs) { if(element_qname) { axutil_qname_free(element_qname, env); } /* this is not a nillable element*/ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element logOnResult missing"); return AXIS2_FAILURE; } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
axis2_status_t AXIS2_CALL adb_UAKType_deserialize_obj( adb_UAKType_t* _UAKType, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; axiom_attribute_t *parent_attri = NULL; axiom_element_t *parent_element = NULL; axis2_char_t *attrib_text = NULL; axutil_hash_t *attribute_hash = NULL; void *element = NULL; const axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; status = AXIS2_FAILURE; if(parent) { axis2_char_t *attrib_text = NULL; attrib_text = axiom_element_get_attribute_value_by_name(axiom_node_get_data_element(parent, env), env, "nil"); if (attrib_text != NULL && !axutil_strcasecmp(attrib_text, "true")) { /* but the wsdl says that, this is non nillable */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element UAKType"); status = AXIS2_FAILURE; } else { axiom_node_t *text_node = NULL; axiom_text_t *text_element = NULL; text_node = axiom_node_get_first_child(parent, env); if (text_node && axiom_node_get_node_type(text_node, env) == AXIOM_TEXT) text_element = (axiom_text_t*)axiom_node_get_data_element(text_node, env); text_value = ""; if(text_element && axiom_text_get_value(text_element, env)) { text_value = (axis2_char_t*)axiom_text_get_value(text_element, env); } status = adb_UAKType_deserialize_from_string(_UAKType, env, text_value, parent); } } parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env); attribute_hash = axiom_element_get_all_attributes(parent_element, env); parent_attri = NULL; attrib_text = NULL; if(attribute_hash) { axutil_hash_index_t *hi; void *val; const void *key; for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, &val); if(!strcmp((axis2_char_t*)key, "issuerID")) { parent_attri = (axiom_attribute_t*)val; AXIS2_FREE(env->allocator, hi); break; } } } if(parent_attri) { attrib_text = axiom_attribute_get_value(parent_attri, env); } else { /* this is hoping that attribute is stored in "issuerID", this happnes when name is in default namespace */ attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "issuerID"); } if(attrib_text != NULL) { adb_UAKType_set_issuerID(_UAKType, env, attrib_text); } else if(!dont_care_minoccurs) { /* if(element_qname) { axutil_qname_free(element_qname, env); } */ /* this is not a nillable element*/ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute issuerID missing"); return AXIS2_FAILURE; } parent_attri = NULL; attrib_text = NULL; if(attribute_hash) { axutil_hash_index_t *hi; void *val; const void *key; for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, &val); if(!strcmp((axis2_char_t*)key, "collectionID")) { parent_attri = (axiom_attribute_t*)val; AXIS2_FREE(env->allocator, hi); break; } } } if(parent_attri) { attrib_text = axiom_attribute_get_value(parent_attri, env); } else { /* this is hoping that attribute is stored in "collectionID", this happnes when name is in default namespace */ attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "collectionID"); } if(attrib_text != NULL) { adb_UAKType_set_collectionID(_UAKType, env, attrib_text); } else if(!dont_care_minoccurs) { /* if(element_qname) { axutil_qname_free(element_qname, env); } */ /* this is not a nillable element*/ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute collectionID missing"); return AXIS2_FAILURE; } return status; }
static int AXIS2_CALL Axis2Service_init_with_conf( axis2_svc_skeleton_t * /*pSvcSkeleton*/, const axutil_env_t * pEnv, axis2_conf* pConf) { staff::CrashHandler::Enable(); #if defined WIN32 // installing handler to process Staff deinitialization before dlls are unloaded SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE); #endif const axis2_char_t* szServiceName = "StaffService"; m_pAxis2Svc = axis2_conf_get_svc(pConf, pEnv, szServiceName); // check for staff module is engaged axutil_qname_t* pQName = axutil_qname_create(pEnv, "staff", NULL, NULL); axis2_bool_t bEngaged = axis2_svc_is_module_engaged(m_pAxis2Svc, pEnv, pQName); axutil_qname_free(pQName, pEnv); if (!bEngaged) { staff::LogError() << "staff module is not engaged. Unable to continue."; exit(1); } #ifndef WITHOUT_SECURITY // check for staff_security is engaged pQName = axutil_qname_create(pEnv, "staff_security", NULL, NULL); bEngaged = axis2_svc_is_module_engaged(m_pAxis2Svc, pEnv, pQName); axutil_qname_free(pQName, pEnv); if (!bEngaged) { staff::LogError() << "staff_security module is not engaged. Unable to continue."; exit(1); } // initialize security if (!staff_security_init()) { staff::LogError() << "Failed to initialize staff::security."; exit(1); } #endif axutil_param_t* pParam = axis2_svc_get_param(m_pAxis2Svc, pEnv, "Http200OnFault"); if (pParam != NULL) { const axis2_char_t* szValue = reinterpret_cast<const axis2_char_t*>(axutil_param_get_value(pParam, pEnv)); if (szValue != NULL) { m_bHttp200OnFault = !axutil_strcasecmp(szValue, "true"); } } m_pEnv = pEnv; m_pConf = pConf; try { staff::ServiceDispatcher::Inst().Init(staff::ServiceDispatcher::Events(StaffService::OnConnect, StaffService::OnDisconnect)); std::cout << "StaffService started (version " VERSION_FULL ")" << std::endl; return AXIS2_SUCCESS; } STAFF_CATCH_ALL_DESCR("Failed to start StaffService dispatcher") return AXIS2_FAILURE; }
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 = axutil_strdup(env,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; { /* * Curl calculates the content-length automatically. * This commented section is not only unnecessary, * it interferes with authentication. * * NTLM, for example, will send an empty request * first (no body) to get the auth challenge * before resending with actual content. */ /*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; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_options_set_ntlm_http_auth_info( axis2_options_t * options, const axutil_env_t * env, const axis2_char_t * username, const axis2_char_t * password, const int flags, const axis2_char_t * domain, const axis2_char_t * workstation, const axis2_char_t * auth_type) { axis2_bool_t force_http_auth = AXIS2_FALSE; axis2_char_t temp_str[4]; axutil_property_t *prop_un = NULL; axutil_property_t *prop_pw = NULL; axutil_property_t *prop_fg = NULL; axutil_property_t *prop_do = NULL; axutil_property_t *prop_wo = 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); sprintf(temp_str, "%d", flags); prop_fg = axutil_property_create(env); axutil_property_set_value(prop_fg, env, axutil_strdup(env, temp_str)); axis2_options_set_property(options, env, AXIS2_NTLM_AUTH_FLAGS, prop_fg); if(domain) { prop_do = axutil_property_create(env); axutil_property_set_value(prop_do, env, axutil_strdup(env, domain)); axis2_options_set_property(options, env, AXIS2_NTLM_AUTH_DOMAIN, prop_do); } if(workstation) { prop_wo = axutil_property_create(env); axutil_property_set_value(prop_wo, env, axutil_strdup(env, workstation)); axis2_options_set_property(options, env, AXIS2_NTLM_AUTH_WORKSTATION, prop_wo); } if(auth_type) { if(axutil_strcasecmp(auth_type, AXIS2_HTTP_AUTH_TYPE_NTLM) == 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; }
axis2_status_t AXIS2_CALL adb_addUserPermissionResponse_deserialize_obj( adb_addUserPermissionResponse_t* _addUserPermissionResponse, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; const axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _addUserPermissionResponse, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for addUserPermissionResponse : " "NULL element can not be passed to deserialize"); return AXIS2_FAILURE; } current_element = (axiom_element_t *)axiom_node_get_data_element(parent, env); qname = axiom_element_get_qname(current_element, env, parent); if (axutil_qname_equals(qname, env, _addUserPermissionResponse-> qname)) { first_node = axiom_node_get_first_child(parent, env); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for addUserPermissionResponse : " "Expected %s but returned %s", axutil_qname_to_string(_addUserPermissionResponse-> qname, env), axutil_qname_to_string(qname, env)); return AXIS2_FAILURE; } /* * building return element */ current_node = first_node; is_early_node_valid = AXIS2_FALSE; while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } element_qname = axutil_qname_create(env, "return", "http://services.resource.ui.mgt.registry.carbon.wso2.org", NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { if (!axutil_strcasecmp(text_value , "true")) { status = adb_addUserPermissionResponse_set_return(_addUserPermissionResponse, env, AXIS2_TRUE); } else { status = adb_addUserPermissionResponse_set_return(_addUserPermissionResponse, env, AXIS2_FALSE); } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return"); status = AXIS2_FAILURE; } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
axis2_status_t AXIS2_CALL adb_updateSystemLog_deserialize_obj( adb_updateSystemLog_t* _updateSystemLog, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; const axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _updateSystemLog, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for updateSystemLog : " "NULL element can not be passed to deserialize"); return AXIS2_FAILURE; } current_element = (axiom_element_t *)axiom_node_get_data_element(parent, env); qname = axiom_element_get_qname(current_element, env, parent); if (axutil_qname_equals(qname, env, _updateSystemLog-> qname)) { first_node = axiom_node_get_first_child(parent, env); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for updateSystemLog : " "Expected %s but returned %s", axutil_qname_to_string(_updateSystemLog-> qname, env), axutil_qname_to_string(qname, env)); return AXIS2_FAILURE; } /* * building logLevel element */ current_node = first_node; is_early_node_valid = AXIS2_FALSE; while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } element_qname = axutil_qname_create(env, "logLevel", "http://org.apache.axis2/xsd", NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { status = adb_updateSystemLog_set_logLevel(_updateSystemLog, env, text_value); } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for logLevel "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } /* * building logPattern element */ /* * because elements are ordered this works fine */ if(current_node != NULL && is_early_node_valid) { current_node = axiom_node_get_next_sibling(current_node, env); while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } } is_early_node_valid = AXIS2_FALSE; element_qname = axutil_qname_create(env, "logPattern", "http://org.apache.axis2/xsd", NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { status = adb_updateSystemLog_set_logPattern(_updateSystemLog, env, text_value); } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for logPattern "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } /* * building persist element */ /* * because elements are ordered this works fine */ if(current_node != NULL && is_early_node_valid) { current_node = axiom_node_get_next_sibling(current_node, env); while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } } is_early_node_valid = AXIS2_FALSE; element_qname = axutil_qname_create(env, "persist", "http://org.apache.axis2/xsd", NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { if (!axutil_strcasecmp(text_value , "true")) { status = adb_updateSystemLog_set_persist(_updateSystemLog, env, AXIS2_TRUE); } else { status = adb_updateSystemLog_set_persist(_updateSystemLog, env, AXIS2_FALSE); } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element persist"); status = AXIS2_FAILURE; } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for persist "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
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; } } if(!client->data_stream) { 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); client->owns_stream = AXIS2_TRUE; } #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 { if(!client->data_stream) { client->data_stream = axutil_stream_create_socket(env, client->sockfd); client->owns_stream = AXIS2_TRUE; } } 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; }
void wsdl_util_manage_client_options( const axutil_env_t* env, axis2_svc_client_t* svc_client, axutil_hash_t* svc_client_user_options, axis2_options_t* client_options, const axis2_char_t* operation_name, axiom_node_t* wsdl_axiom, axis2_bool_t is_version1_wsdl, axiom_node_t* sig_axiom, axis2_char_t* service_name, axis2_char_t* port_name, axiom_node_t** operation_axiom, int* soap_version) { axis2_char_t* endpoint_address = NULL; axis2_char_t* classmap = NULL; axis2_char_t* proxy_host = NULL; axis2_char_t* proxy_port = NULL; axis2_bool_t option_supported = AXIS2_TRUE; /* ;-) */ int string_malloc_length = -1; axis2_bool_t is_multiple_interfaces = AXIS2_FALSE; axis2_bool_t multiple_ep = AXIS2_FALSE; axis2_endpoint_ref_t *to_epr = NULL; axis2_char_t *soap_action = NULL; axis2_char_t *wsa_action = NULL; axis2_bool_t is_http_method_post = AXIS2_TRUE; axiom_node_t* binding_node = NULL; axis2_char_t *ssl_server_key_filename = NULL; axis2_char_t *ssl_client_key_filename = NULL; axis2_char_t *passphrase = NULL; axutil_hash_t* wsdl_policy_hash = NULL; /* allocations */ string_malloc_length = sizeof(axis2_char_t) * 256; endpoint_address = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length); classmap = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length); soap_action = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length); wsa_action = (axis2_char_t *)AXIS2_MALLOC(env->allocator, string_malloc_length); strcpy(soap_action, ""); strcpy(wsa_action, ""); if (svc_client_user_options) { if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_ENDPOINT)) { strcpy(endpoint_address, (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_ENDPOINT, AXIS2_HASH_KEY_STRING)); } else { strcpy(endpoint_address, ""); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_CLASSMAP)) { strcpy(classmap, (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_CLASSMAP, AXIS2_HASH_KEY_STRING)); } else { strcpy(classmap, ""); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_USE_SOAP)) { axis2_char_t* use_soap = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_USE_SOAP, AXIS2_HASH_KEY_STRING); if (axutil_strcmp(use_soap, WSF_WSDL_SOAP_1_2) == 0) { *soap_version = 2; AXIS2_LOG_DEBUG_MSG(env->log, "soap version SOAP12"); } else if (axutil_strcmp(use_soap, WSF_WSDL_SOAP_1_1) == 0) { *soap_version = 1; AXIS2_LOG_DEBUG_MSG(env->log, "soap version SOAP11"); } else { /* TODO: support REST */ } } else { /* default to soap version 1.2 */ *soap_version = 2; AXIS2_LOG_DEBUG_MSG(env->log, "default to soap version 1.2"); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_PROXY_HOST)) { proxy_host = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_PROXY_HOST, AXIS2_HASH_KEY_STRING); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_PROXY_PORT)) { proxy_port = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_PROXY_PORT, AXIS2_HASH_KEY_STRING); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_CLIENT_CERT)) { ssl_server_key_filename = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_CLIENT_CERT, AXIS2_HASH_KEY_STRING); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_PASSPHRASE)) { ssl_client_key_filename = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_PASSPHRASE, AXIS2_HASH_KEY_STRING); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_SERVER_CERT)) { passphrase = (axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_SERVER_CERT, AXIS2_HASH_KEY_STRING); } if (axutil_hash_contains_key(svc_client_user_options, env, WSF_WSDL_HTTP_METHOD)) { if (axutil_strcasecmp((axis2_char_t*)axutil_hash_get(svc_client_user_options, WSF_WSDL_HTTP_METHOD, AXIS2_HASH_KEY_STRING), AXIS2_HTTP_GET) == 0) { is_http_method_post = AXIS2_FALSE; } } } else { strcpy(endpoint_address, ""); } is_multiple_interfaces = AXIS2_FALSE; /* TODO: add support for multiple port/interface types */ if (axutil_strcmp(endpoint_address, "") == 0) { axis2_char_t* sig_endpoint_address = NULL; if (wsdl_util_get_endpoint_address(sig_axiom, env, &sig_endpoint_address) == AXIS2_SUCCESS) { strcpy(endpoint_address, (char *)sig_endpoint_address); } } else { multiple_ep = 1; /* TODO: add suppor for multiple endpoints */ } if (option_supported) /* get binding details */ { axiom_node_t* op_axiom = NULL; int soap_ver = 2; axis2_char_t* wsa_action_binding_details = NULL; axis2_char_t* soap_action_binding_details = NULL; if (wsdl_util_find_operation(env, operation_name, endpoint_address, AXIS2_TRUE /* is_multiple */, sig_axiom, &op_axiom, &soap_ver) == AXIS2_SUCCESS) { *operation_axiom = op_axiom; *soap_version = soap_ver; if (wsdl_util_get_binding_details(env, op_axiom, &wsa_action, &soap_action) == AXIS2_SUCCESS) { if (wsa_action_binding_details) strcpy (wsa_action, wsa_action_binding_details); if (soap_action_binding_details) strcpy (soap_action, soap_action_binding_details); /*TODO: check this condition */ //if (wsa_action_binding_details || soap_action_binding_details) //{ // soap_version = soap_version_binding_details; //} } } } if (wsf_wsdl_util_get_binding_node(env, wsdl_axiom, is_version1_wsdl, service_name, port_name, &binding_node)) { if (wsf_wsdl_util_get_all_policies_from_wsdl(env, wsdl_axiom, is_version1_wsdl, binding_node, operation_name, &wsdl_policy_hash)) { wsf_wsdl_util_configure_security_for_svc_client(env, svc_client_user_options, wsdl_policy_hash, svc_client); } } to_epr = axis2_endpoint_ref_create (env, endpoint_address); axis2_options_set_to (client_options, env, to_epr); /** enable ssl **/ if (option_supported) /* wsf_client_enable_ssl */ { axutil_property_t *ssl_server_key_prop = NULL; axutil_property_t *ssl_client_key_prop = NULL; axutil_property_t *passphrase_prop = NULL; ssl_server_key_prop = axutil_property_create_with_args (env, 0, AXIS2_TRUE, 0, axutil_strdup (env, ssl_server_key_filename)); axis2_options_set_property (client_options, env, WSF_WSDL_SERVER_CERT, ssl_server_key_prop); ssl_client_key_prop = axutil_property_create_with_args (env, 0, AXIS2_TRUE, 0, axutil_strdup (env, ssl_client_key_filename)); axis2_options_set_property (client_options, env, WSF_WSDL_KEY_FILE, ssl_client_key_prop); passphrase_prop = axutil_property_create_with_args (env, 0, AXIS2_TRUE, 0, axutil_strdup (env, passphrase)); axis2_options_set_property (client_options, env, WSF_WSDL_SSL_PASSPHRASE, passphrase_prop); AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf-client] setting ssh options %s -- %s -- %s ", ssl_server_key_filename, ssl_client_key_filename, passphrase); } if (axutil_strcmp(soap_action, "") != 0){ axutil_string_t *action_string = axutil_string_create (env, soap_action); axis2_options_set_soap_action (client_options, env, action_string); AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "soap action present :- %s", soap_action); } if (axutil_strcmp(wsa_action, "") != 0){ axis2_options_set_action(client_options, env, wsa_action); AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "addressing action present :- %s", wsa_action); axis2_svc_client_engage_module (svc_client, env, WSF_WSDL_MODULE_ADDRESSING); } if (*soap_version) { axis2_options_set_soap_version (client_options, env, *soap_version); AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf_wsdl]soap version in wsdl mode is %d", *soap_version); } /* Add proxy options */ if (proxy_host && proxy_port) { axis2_svc_client_set_proxy (svc_client, env, proxy_host, proxy_port); AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf_wsdl_client] setting proxy options %s -- %s -- ", proxy_host, proxy_port); } /* Default header type is POST, so only setting the HTTP_METHOD if GET */ if (is_http_method_post == AXIS2_FALSE) { axutil_property_t *property = axutil_property_create (env); axutil_property_set_value (property, env, axutil_strdup (env, AXIS2_HTTP_GET)); axis2_options_set_property (client_options, env, AXIS2_HTTP_METHOD, property); AXIS2_LOG_DEBUG_MSG(env->log, "[wsf_client] setting http method get property"); } }
axis2_status_t AXIS2_CALL adb_createReservation_deserialize( adb_createReservation_t* _createReservation, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; void *element = NULL; axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _createReservation, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for createReservation : " "NULL elemenet can not be passed to deserialize"); return AXIS2_FAILURE; } first_node = axiom_node_get_first_child(parent, env); /* * building sessionId element */ current_node = first_node; is_early_node_valid = AXIS2_FALSE; while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } element_qname = axutil_qname_create(env, "sessionId", NULL, NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("sessionId", axiom_element_get_localname(current_element, env))))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("sessionId", axiom_element_get_localname(current_element, env)))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { status = adb_createReservation_set_sessionId(_createReservation, env, text_value); } else { /* * axis2_qname_t *qname = NULL; * axiom_attribute_t *the_attri = NULL; * * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi"); * the_attri = axiom_element_get_attribute(current_element, env, qname); */ /* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */ axiom_attribute_t *the_attri = NULL; axis2_char_t *attrib_text = NULL; axutil_hash_t *attribute_hash = NULL; attribute_hash = axiom_element_get_all_attributes(current_element, env); attrib_text = NULL; if(attribute_hash) { axutil_hash_index_t *hi; void *val; const void *key; for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, &val); if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance")) { the_attri = (axiom_attribute_t*)val; break; } } } if(the_attri) { attrib_text = axiom_attribute_get_value(the_attri, env); } else { /* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */ attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil"); } if(attrib_text && 0 == axutil_strcmp(attrib_text, "1")) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element sessionId"); status = AXIS2_FAILURE; } else { /* after all, we found this is a empty string */ status = adb_createReservation_set_sessionId(_createReservation, env, ""); } } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for sessionId "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } /* * building bandwidthRequest element */ /* * because elements are ordered this works fine */ if(current_node != NULL && is_early_node_valid) { current_node = axiom_node_get_next_sibling(current_node, env); while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } } is_early_node_valid = AXIS2_FALSE; element_qname = axutil_qname_create(env, "bandwidthRequest", NULL, NULL); if (adb_bandwidthRequest_is_particle() || (current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bandwidthRequest", axiom_element_get_localname(current_element, env))))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bandwidthRequest", axiom_element_get_localname(current_element, env)))) { is_early_node_valid = AXIS2_TRUE; } element = (void*)adb_bandwidthRequest_create(env); status = adb_bandwidthRequest_deserialize((adb_bandwidthRequest_t*)element, env, ¤t_node, &is_early_node_valid, AXIS2_FALSE); if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element bandwidthRequest"); } else { status = adb_createReservation_set_bandwidthRequest(_createReservation, env, (adb_bandwidthRequest_t*)element); } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for bandwidthRequest "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } /* * building bidirectional element */ /* * because elements are ordered this works fine */ if(current_node != NULL && is_early_node_valid) { current_node = axiom_node_get_next_sibling(current_node, env); while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } } is_early_node_valid = AXIS2_FALSE; element_qname = axutil_qname_create(env, "bidirectional", NULL, NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bidirectional", axiom_element_get_localname(current_element, env))))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("bidirectional", axiom_element_get_localname(current_element, env)))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { if (!axutil_strcasecmp(text_value , "true")) { status = adb_createReservation_set_bidirectional(_createReservation, env, AXIS2_TRUE); } else { status = adb_createReservation_set_bidirectional(_createReservation, env, AXIS2_FALSE); } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element bidirectional"); status = AXIS2_FAILURE; } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for bidirectional "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } else if(!dont_care_minoccurs) { if(element_qname) { axutil_qname_free(element_qname, env); } /* this is not a nillable element*/ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element bidirectional missing"); return AXIS2_FAILURE; } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
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); } }