| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <trust_util.h> |
| #include <oxs_key.h> |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_rst_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axis2_char_t * context) |
| { |
| axiom_node_t *rst_node = NULL; |
| axiom_element_t *rst_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_attribute_t *context_attr = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| rst_ele = axiom_element_create(env, NULL, TRUST_REQUEST_SECURITY_TOKEN, wst_ns, &rst_node); |
| |
| if (!rst_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RST Element creation failed."); |
| return NULL; |
| } |
| |
| if (context) |
| { |
| context_attr = axiom_attribute_create(env, TRUST_RST_CONTEXT, context, wst_ns); |
| status = axiom_element_add_attribute(rst_ele, env, context_attr, rst_node); |
| |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RST Element add attribute function failed."); |
| return NULL; |
| } |
| } |
| |
| return rst_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_rstr_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axis2_char_t * context) |
| { |
| axiom_node_t *rstr_node = NULL; |
| axiom_element_t *rstr_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_attribute_t *context_attr = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| rstr_ele = |
| axiom_element_create(env, NULL, TRUST_REQUEST_SECURITY_TOKEN_RESPONSE, wst_ns, &rstr_node); |
| |
| if (!rstr_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR Element creation failed."); |
| return NULL; |
| } |
| |
| if (context) |
| { |
| context_attr = axiom_attribute_create(env, TRUST_RST_CONTEXT, context, wst_ns); |
| status = axiom_element_add_attribute(rstr_ele, env, context_attr, rstr_node); |
| |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RSTR Element add attribute function failed."); |
| return NULL; |
| } |
| } |
| |
| return rstr_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_rstr_collection_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri) |
| { |
| axiom_node_t *rstrc_node = NULL; |
| axiom_element_t *rstrc_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| rstrc_ele = |
| axiom_element_create(env, NULL, TRUST_REQUEST_SECURITY_TOKEN_RESPONSE_COLLECTION, wst_ns, |
| &rstrc_node); |
| |
| if (!rstrc_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTRC Element creation failed."); |
| return NULL; |
| } |
| |
| return rstrc_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_request_type_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * request_type) |
| { |
| axis2_char_t *req_type_str = NULL; |
| axiom_node_t *request_type_node = NULL; |
| axiom_element_t *request_type_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| request_type_ele = |
| axiom_element_create(env, parent_node, TRUST_REQUEST_TYPE, wst_ns, &request_type_node); |
| |
| if (!request_type_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestType Element creation failed."); |
| return NULL; |
| } |
| |
| if (0 == axutil_strcmp(request_type, TRUST_REQ_TYPE_ISSUE) || |
| 0 == axutil_strcmp(request_type, TRUST_REQ_TYPE_CANCEL) || |
| 0 == axutil_strcmp(request_type, TRUST_REQ_TYPE_RENEW) || |
| 0 == axutil_strcmp(request_type, TRUST_REQ_TYPE_VALIDATE)) |
| { |
| req_type_str = axutil_stracat(env, wst_ns_uri, request_type); |
| status = axiom_element_set_text(request_type_ele, env, req_type_str, request_type_node); |
| AXIS2_FREE(env->allocator, req_type_str); |
| } |
| else |
| { |
| status = axiom_element_set_text(request_type_ele, env, request_type, request_type_node); |
| } |
| |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RequestType Element's setting text function failed."); |
| return NULL; |
| } |
| |
| return request_type_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_token_type_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * token_type) |
| { |
| axiom_node_t *token_type_node = NULL; |
| axiom_element_t *token_type_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| token_type_ele = |
| axiom_element_create(env, parent_node, TRUST_TOKEN_TYPE, wst_ns, &token_type_node); |
| |
| if (!token_type_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Element creation failed."); |
| return NULL; |
| } |
| |
| status = axiom_element_set_text(token_type_ele, env, token_type, token_type_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] TokenType Element's setting text function failed."); |
| return NULL; |
| } |
| |
| return token_type_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_applies_to_element( |
| const axutil_env_t * env, |
| axiom_node_t * parent_node, |
| const axis2_char_t * address, |
| const axis2_char_t * addressing_ns) |
| { |
| axiom_node_t *applies_to_node = NULL; |
| axiom_node_t *epr_node = NULL; |
| axiom_node_t *addr_node = NULL; |
| axiom_element_t *applies_to_ele = NULL; |
| axiom_element_t *epr_ele = NULL; |
| axiom_element_t *addr_ele = NULL; |
| axiom_namespace_t *wsp_ns = NULL; |
| axiom_namespace_t *wsa_ns = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wsp_ns = axiom_namespace_create(env, TRUST_WSP_XMLNS, TRUST_WSP); |
| wsa_ns = axiom_namespace_create(env, addressing_ns, TRUST_WSA); |
| |
| applies_to_ele = |
| axiom_element_create(env, parent_node, TRUST_APPLIES_TO, wsp_ns, &applies_to_node); |
| if (!applies_to_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] AppliesTo Element creation failed!"); |
| return NULL; |
| } |
| |
| epr_ele = axiom_element_create(env, applies_to_node, TRUST_EPR, wsa_ns, &epr_node); |
| if (!epr_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] EndpointReference Element creation failed!"); |
| return NULL; |
| } |
| |
| addr_ele = axiom_element_create(env, epr_node, TRUST_EPR_ADDRESS, wsa_ns, &addr_node); |
| if (!addr_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Address Element creation failed!"); |
| return NULL; |
| } |
| |
| status = axiom_element_set_text(addr_ele, env, address, addr_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Address Element's setting text function failed."); |
| return NULL; |
| } |
| |
| return applies_to_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_claims_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * dialect_uri) |
| { |
| axiom_node_t *claims_node = NULL; |
| axiom_element_t *claims_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_attribute_t *dialect_attr = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| claims_ele = axiom_element_create(env, parent_node, TRUST_CLAIMS, wst_ns, &claims_node); |
| if (!claims_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims Element creation failed!"); |
| return NULL; |
| } |
| |
| if (dialect_uri) |
| { |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| dialect_attr = axiom_attribute_create(env, TRUST_CLAIMS_DIALECT, dialect_uri, NULL); |
| if (dialect_attr) |
| { |
| status = axiom_element_add_attribute(claims_ele, env, dialect_attr, claims_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Claims element adding attribute failed."); |
| return NULL; |
| } |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Dialect attribute creation failed."); |
| return NULL; |
| } |
| |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Dialect uri null."); |
| return NULL; |
| } |
| |
| return claims_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_requested_security_token_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axiom_node_t * sec_token_node) |
| { |
| axiom_node_t *requested_token_node = NULL; |
| axiom_element_t *requested_token_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| requested_token_ele = |
| axiom_element_create(env, parent_node, TRUST_REQUESTED_SECURITY_TOKEN, wst_ns, |
| &requested_token_node); |
| |
| if (!requested_token_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RequestedSecurityToken Element creation failed!"); |
| return NULL; |
| } |
| |
| if(sec_token_node) |
| { |
| axiom_node_add_child(requested_token_node, env, sec_token_node); |
| } |
| |
| return requested_token_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_requsted_proof_token_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axiom_node_t *req_proof_token) |
| { |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_node_t *requested_prooft_node = NULL; |
| axiom_element_t *requested_prooft_ele = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| requested_prooft_ele = |
| axiom_element_create(env, parent_node, TRUST_REQUESTED_PROOF_TOKEN, wst_ns, |
| &requested_prooft_node); |
| if (!requested_prooft_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RequestedProofToken Element creation failed!"); |
| return NULL; |
| } |
| if(req_proof_token) |
| { |
| if(AXIS2_FAILURE == axiom_node_add_child(requested_prooft_node, env, req_proof_token)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedProofToken child setting failed!"); |
| return NULL; |
| } |
| } |
| |
| return requested_prooft_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_entropy_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node) |
| { |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_node_t *entropy_node = NULL; |
| axiom_element_t *entropy_ele = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| entropy_ele = axiom_element_create(env, parent_node, TRUST_ENTROPY, wst_ns, &entropy_node); |
| if (!entropy_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy Element creation failed!"); |
| return NULL; |
| } |
| |
| return entropy_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_computed_key_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node) |
| { |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_node_t *computed_key_node = NULL; |
| axiom_element_t *computed_key_ele = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| computed_key_ele = |
| axiom_element_create(env, parent_node, TRUST_COMPUTED_KEY, wst_ns, &computed_key_node); |
| if (!computed_key_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] ComputedKey Element creation failed!"); |
| return NULL; |
| } |
| |
| return computed_key_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_binary_secret_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * enc_secret, |
| axis2_char_t * bin_sec_type) |
| { |
| axiom_node_t *bin_sec_node = NULL; |
| axiom_element_t *bin_sec_ele = NULL; |
| axiom_attribute_t *bin_sec_type_attr = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_char_t *type_str = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| bin_sec_ele = |
| axiom_element_create(env, parent_node, TRUST_BINARY_SECRET, wst_ns, &bin_sec_node); |
| if (!bin_sec_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] BinarySecret Element creation failed!"); |
| return NULL; |
| } |
| |
| if (enc_secret) |
| { |
| /* Setting up the encoeded secret */ |
| status = axiom_element_set_text(bin_sec_ele, env, enc_secret, bin_sec_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] BinarySecret Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| if (bin_sec_type) |
| { |
| /* Setting up BS-Type attribute */ |
| type_str = axutil_stracat(env, wst_ns_uri, bin_sec_type); |
| bin_sec_type_attr = axiom_attribute_create(env, ATTR_TYPE, type_str, NULL); |
| if (!bin_sec_type_attr) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] BinarySecret Element's Type attribute creation failed."); |
| return NULL; |
| } |
| |
| status = axiom_element_add_attribute(bin_sec_ele, env, bin_sec_type_attr, bin_sec_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] BinarySecret Element's attribute adding failed."); |
| return NULL; |
| } |
| } |
| |
| return bin_sec_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_computed_key_algo_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * algo_id) |
| { |
| axiom_node_t *comp_key_algo_node = NULL; |
| axiom_element_t *comp_key_algo_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| /*axis2_char_t *algo = NULL;*/ |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| if (algo_id) |
| { |
| comp_key_algo_ele = |
| axiom_element_create(env, parent_node, TRUST_COMPUTED_KEY_ALGO, wst_ns, |
| &comp_key_algo_node); |
| if (!comp_key_algo_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] ComputedKeyAlgorithm element creation failed."); |
| return NULL; |
| } |
| |
| /*algo = axutil_strcat(env, wst_ns_uri, "/" ,algo_id);*/ |
| status = axiom_element_set_text(comp_key_algo_ele, env, algo_id, comp_key_algo_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] ComputedKeyAlgorithm Element's setting text failed."); |
| return NULL; |
| } |
| |
| } |
| |
| return comp_key_algo_node; |
| } |
| |
| /* KEY SIZE Element*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_key_size_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * key_size) |
| { |
| axiom_node_t *key_size_node = NULL; |
| axiom_element_t *key_size_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| key_size_ele = axiom_element_create(env, parent_node, TRUST_KEY_SIZE, wst_ns, &key_size_node); |
| if (!key_size_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeySize element creation failed."); |
| return NULL; |
| } |
| |
| if (key_size) |
| { |
| status = axiom_element_set_text(key_size_ele, env, key_size, key_size_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] KeySize Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return key_size_node; |
| } |
| |
| /* KEY TYPE Element*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_key_type_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * key_type) |
| { |
| axiom_node_t *key_type_node = NULL; |
| axiom_element_t *key_type_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_char_t *type = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| key_type_ele = axiom_element_create(env, parent_node, TRUST_KEY_TYPE, wst_ns, &key_type_node); |
| if (!key_type_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeyType element creation failed."); |
| return NULL; |
| } |
| |
| if (key_type) |
| { |
| if (0 == axutil_strcmp(key_type, TRUST_KEY_TYPE_SYMM_KEY) || |
| 0 == axutil_strcmp(key_type, TRUST_KEY_TYPE_PUBLIC_KEY) || |
| 0 == axutil_strcmp(key_type, TRUST_KEY_TYPE_BEARER)) |
| { |
| type = axutil_stracat(env, wst_ns_uri, key_type); |
| status = axiom_element_set_text(key_type_ele, env, type, key_type_node); |
| |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] KeyType Element's setting text failed."); |
| return NULL; |
| } |
| } |
| } |
| |
| return key_type_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_life_time_element( |
| const axutil_env_t * env, |
| axiom_node_t * parent_node, |
| axis2_char_t *wst_ns_uri, |
| int ttl) |
| { |
| axiom_node_t *life_time_node = NULL; |
| axiom_node_t *created_node = NULL; |
| axiom_node_t *expires_node = NULL; |
| axiom_element_t *life_time_ele = NULL; |
| axiom_element_t *created_ele = NULL; |
| axiom_element_t *expires_ele = NULL; |
| axis2_char_t *created_val_str = NULL; |
| axis2_char_t *expires_val_str = NULL; |
| axiom_namespace_t *wsu_ns = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axutil_date_time_t *dt = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| wsu_ns = axiom_namespace_create(env, TRUST_WSU_XMLNS, TRUST_WSU); |
| |
| life_time_ele = |
| axiom_element_create(env, parent_node, TRUST_LIFE_TIME, wst_ns, &life_time_node); |
| |
| if (life_time_ele) |
| { |
| created_ele = |
| axiom_element_create(env, life_time_node, TRUST_LIFE_TIME_CREATED, wsu_ns, |
| &created_node); |
| if (created_ele) |
| { |
| dt = axutil_date_time_create_with_offset(env, 0); |
| created_val_str = axutil_date_time_serialize_date_time(dt, env); |
| status = axiom_element_set_text(created_ele, env, created_val_str, created_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Created Element's setting text failed."); |
| return NULL; |
| } |
| |
| AXIS2_FREE(env->allocator, created_val_str); |
| axutil_date_time_free(dt, env); |
| created_val_str = NULL; |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Created element creation failed."); |
| return NULL; |
| } |
| |
| /*if ttl <0 we dont build the expires element */ |
| if (ttl < 0) |
| { |
| return life_time_node; |
| } |
| |
| expires_ele = |
| axiom_element_create(env, life_time_node, TRUST_LIFE_TIME_EXPIRES, wsu_ns, |
| &expires_node); |
| if (expires_ele) |
| { |
| dt = axutil_date_time_create_with_offset(env, ttl); |
| expires_val_str = axutil_date_time_serialize_date_time(dt, env); |
| axiom_element_set_text(expires_ele, env, expires_val_str, expires_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Expires Element's setting text failed."); |
| return NULL; |
| } |
| |
| AXIS2_FREE(env->allocator, expires_val_str); |
| axutil_date_time_free(dt, env); |
| expires_val_str = NULL; |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Expires element creation failed."); |
| return NULL; |
| } |
| |
| return life_time_node; |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime element creation failed."); |
| return NULL; |
| } |
| |
| return NULL; |
| } |
| |
| /* RequstedAttachedReference */ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_req_attached_reference_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node) |
| { |
| axiom_node_t *attached_ref_node = NULL; |
| axiom_element_t *attached_ref_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| attached_ref_ele = |
| axiom_element_create(env, parent_node, TRUST_REQUESTED_ATTACHED_REFERENCE, wst_ns, |
| &attached_ref_node); |
| if (!attached_ref_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RequestedAttachedReference element creation failed."); |
| return NULL; |
| } |
| |
| return attached_ref_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_req_unattached_reference_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node) |
| { |
| axiom_node_t *unattached_ref_node = NULL; |
| axiom_element_t *unattached_ref_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| unattached_ref_ele = |
| axiom_element_create(env, parent_node, TRUST_REQUESTED_UNATTACHED_REFERENCE, wst_ns, |
| &unattached_ref_node); |
| if (!unattached_ref_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RequestedUnAttachedReference element creation failed."); |
| return NULL; |
| } |
| |
| return unattached_ref_node; |
| } |
| |
| /*AuthenticationType*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_authentication_type_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * authentication_type) |
| { |
| axiom_node_t *authentication_type_node = NULL; |
| axiom_element_t *authentication_type_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| authentication_type_ele = |
| axiom_element_create(env, parent_node, TRUST_AUTHENTICATION_TYPE, wst_ns, |
| &authentication_type_node); |
| if (!authentication_type_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] AuthenticationType element creation failed."); |
| return NULL; |
| } |
| |
| if (authentication_type) |
| { |
| status = axiom_element_set_text(authentication_type_ele, env, authentication_type, authentication_type_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Authenticationtype Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return authentication_type_node; |
| |
| } |
| |
| /*SignatureAlgorithm*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_signature_algo_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * signature_algo) |
| { |
| axiom_node_t *signature_algo_node = NULL; |
| axiom_element_t *signature_algo_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| signature_algo_ele = |
| axiom_element_create(env, parent_node, TRUST_SIGNATURE_ALGO, wst_ns, |
| &signature_algo_node); |
| if (!signature_algo_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] SignatureAlgo element creation failed."); |
| return NULL; |
| } |
| |
| if (signature_algo) |
| { |
| status = axiom_element_set_text(signature_algo_ele, env, signature_algo, signature_algo_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] SignatureAlgo Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return signature_algo_node; |
| } |
| |
| /*EncryptionAlgorithm*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_encryption_algo_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * encryption_algo) |
| { |
| axiom_node_t *encryption_algo_node = NULL; |
| axiom_element_t *encryption_algo_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| encryption_algo_ele = |
| axiom_element_create(env, parent_node, TRUST_ENCRYPTION_ALGO, wst_ns, |
| &encryption_algo_node); |
| if (!encryption_algo_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] EncryptionAlgo element creation failed."); |
| return NULL; |
| } |
| |
| if (encryption_algo) |
| { |
| status = axiom_element_set_text(encryption_algo_ele, env, encryption_algo, encryption_algo_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] EncryptionAlgo Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return encryption_algo_node; |
| } |
| |
| /*CanonicalizationAlgorithm*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_canonicalization_algo_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * canonicalization_algo) |
| { |
| axiom_node_t *canonicalization_algo_node = NULL; |
| axiom_element_t *canonicalization_algo_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| canonicalization_algo_ele = |
| axiom_element_create(env, parent_node, TRUST_CANONICAL_ALGO, wst_ns, |
| &canonicalization_algo_node); |
| if (!canonicalization_algo_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] CanonicalizationAlgo element creation failed."); |
| return NULL; |
| } |
| |
| if (canonicalization_algo) |
| { |
| status = axiom_element_set_text(canonicalization_algo_ele, env, canonicalization_algo, canonicalization_algo_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] CanonicalizationAlgo Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return canonicalization_algo_node; |
| } |
| |
| /*ComputedKeyAlgorithm*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_computedkey_algo_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * computedkey_algo) |
| { |
| axiom_node_t *computedkey_algo_node = NULL; |
| axiom_element_t *computedkey_algo_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| computedkey_algo_ele = |
| axiom_element_create(env, parent_node, TRUST_COMPUTED_KEY_ALGO, wst_ns, |
| &computedkey_algo_node); |
| if (!computedkey_algo_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] ComputedKeyAlgo element creation failed."); |
| return NULL; |
| } |
| |
| if (computedkey_algo) |
| { |
| status = axiom_element_set_text(computedkey_algo_ele, env, computedkey_algo, computedkey_algo_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] ComputedKey Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| |
| return computedkey_algo_node; |
| } |
| |
| /*(Desired)Encryption*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_desired_encryption_element( |
| const axutil_env_t * env, |
| axis2_char_t * wst_ns_uri, |
| axiom_node_t * parent_node, |
| axiom_node_t * encryption_key) /*@param encryption_key - This can be either a key or a STR*/ |
| { |
| axiom_node_t *desired_encryption_node = NULL; |
| axiom_element_t *desired_encryption_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| desired_encryption_ele = |
| axiom_element_create(env, parent_node, TRUST_DESIRED_ENCRYPTION, wst_ns, |
| &desired_encryption_node); |
| |
| if (!desired_encryption_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Encryption Element creation failed!"); |
| return NULL; |
| } |
| |
| if(encryption_key) |
| { |
| /*This node can be a key or a STR*/ |
| axiom_node_add_child(desired_encryption_node, env, encryption_key); |
| } |
| |
| return desired_encryption_node; |
| } |
| |
| /*ProofEncryption*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_proof_encryption_element( |
| const axutil_env_t * env, |
| axis2_char_t * wst_ns_uri, |
| axiom_node_t * parent_node, |
| axiom_node_t * proof_encryption_key) /*@param encryption_key - This can be either a key or a STR*/ |
| { |
| axiom_node_t *proof_encryption_node = NULL; |
| axiom_element_t *proof_encryption_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| proof_encryption_ele = |
| axiom_element_create(env, parent_node, TRUST_PROOF_ENCRYPTION, wst_ns, |
| &proof_encryption_node); |
| |
| if (!proof_encryption_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] ProofEncryption Element creation failed!"); |
| return NULL; |
| } |
| |
| if(proof_encryption_key) |
| { |
| /*This node can be a key or a STR*/ |
| axiom_node_add_child(proof_encryption_node, env, proof_encryption_key); |
| } |
| |
| return proof_encryption_node; |
| } |
| |
| /*UseKey*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_usekey_element( |
| const axutil_env_t * env, |
| axis2_char_t * wst_ns_uri, |
| axiom_node_t * parent_node, |
| axiom_node_t * usekey_key) /*@param encryption_key - This can be either a key or a STR*/ |
| { |
| axiom_node_t *usekey_node = NULL; |
| axiom_element_t *usekey_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| usekey_ele = |
| axiom_element_create(env, parent_node, TRUST_USE_KEY, wst_ns, |
| &usekey_node); |
| |
| if (!usekey_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] UseKey Element creation failed!"); |
| return NULL; |
| } |
| |
| if(usekey_key) |
| { |
| /*This node can be a key or a STR*/ |
| axiom_node_add_child(usekey_node, env, usekey_key); |
| } |
| |
| return usekey_node; |
| |
| |
| } |
| |
| /*SignWith*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_signwith_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * signwith) |
| { |
| axiom_node_t *signwith_node = NULL; |
| axiom_element_t *signwith_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| signwith_ele = |
| axiom_element_create(env, parent_node, TRUST_SIGN_WITH, wst_ns, |
| &signwith_node); |
| if (!signwith_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] SignWith element creation failed."); |
| return NULL; |
| } |
| |
| if (signwith) |
| { |
| status = axiom_element_set_text(signwith_ele, env, signwith, signwith_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] SignWith Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return signwith_node; |
| } |
| |
| /*EncryptWith*/ |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_encryptwith_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axis2_char_t * encryptwith) |
| { |
| axiom_node_t *encryptwith_node = NULL; |
| axiom_element_t *encryptwith_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| encryptwith_ele = |
| axiom_element_create(env, parent_node, TRUST_ENCRYPT_WITH, wst_ns, |
| &encryptwith_node); |
| if (!encryptwith_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] EncryptWith element creation failed."); |
| return NULL; |
| } |
| |
| if (encryptwith) |
| { |
| status = axiom_element_set_text(encryptwith_ele, env, encryptwith, encryptwith_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] EncryptWith Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return encryptwith_node; |
| |
| |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_encrypted_data_element( |
| const axutil_env_t * env, |
| axiom_node_t * parent_node, |
| axis2_char_t * enc_data) |
| { |
| axiom_node_t *encrypted_node = NULL; |
| axiom_element_t *encrypted_ele = NULL; |
| axiom_namespace_t *xenc_ns = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| xenc_ns = axiom_namespace_create(env, TRUST_XENC_XMLNS, TRUST_XENC); |
| encrypted_ele = |
| axiom_element_create(env, parent_node, TRUST_ENCRYPTED_DATA, xenc_ns, &encrypted_node); |
| if (!encrypted_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] EncryptedData element creation failed."); |
| return NULL; |
| } |
| if (enc_data) |
| { |
| status = axiom_element_set_text(encrypted_ele, env, enc_data, encrypted_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Encrypted Data Element's setting text failed."); |
| return NULL; |
| } |
| } |
| |
| return encrypted_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_renew_traget_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axiom_node_t * renew_pending_node) |
| { |
| axiom_node_t *renew_target_node = NULL; |
| axiom_element_t *renew_target_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| renew_target_ele = |
| axiom_element_create(env, parent_node, TRUST_RENEW_TARGET, wst_ns, &renew_target_node); |
| if (!renew_target_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RenewTarget element creation failed."); |
| return NULL; |
| } |
| if (renew_pending_node) |
| { |
| /* Set up token as it is for the request */ |
| status = axiom_node_add_child(renew_target_node, env, renew_pending_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] token renew pending node adding as a child failed."); |
| } |
| } |
| |
| /** Otherwise user has to create a STR as a child ot RenewTarget element and |
| * add the token reference to it. |
| **/ |
| return renew_target_node; |
| |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_allow_postdating_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node) |
| { |
| axiom_node_t *allow_postdating_node = NULL; |
| axiom_element_t *allow_postdating_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| allow_postdating_ele = |
| axiom_element_create(env, parent_node, TRUST_REQUESTED_UNATTACHED_REFERENCE, wst_ns, |
| &allow_postdating_node); |
| if (!allow_postdating_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] AllowPostdating element creation failed."); |
| return NULL; |
| } |
| |
| return allow_postdating_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_renewing_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| trust_allow_t allow_flag, |
| trust_ok_t ok_flag) |
| { |
| axiom_node_t *renewing_node = NULL; |
| axiom_element_t *renewing_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_attribute_t *allow_attr = NULL; |
| axiom_attribute_t *ok_attr = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| axis2_char_t *allow = NULL; |
| axis2_char_t *ok = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| renewing_ele = axiom_element_create(env, parent_node, TRUST_RENEWING, wst_ns, &renewing_node); |
| |
| sprintf(allow, "%d", allow_flag); |
| sprintf(ok, "%d", ok_flag); |
| |
| allow_attr = axiom_attribute_create(env, TRUST_RENEW_ALLOW_ATTR, allow, wst_ns); |
| ok_attr = axiom_attribute_create(env, TRUST_RENEW_OK_ATTR, ok, wst_ns); |
| |
| status = axiom_element_add_attribute(renewing_ele, env, allow_attr, renewing_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Allow attribute setting failed."); |
| } |
| status = axiom_element_add_attribute(renewing_ele, env, ok_attr, renewing_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Ok attribute setting failed."); |
| } |
| |
| return renewing_node; |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_cancel_target_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri, |
| axiom_node_t * parent_node, |
| axiom_node_t * token_cancel_pending_node) |
| { |
| axiom_node_t *cancel_target_node = NULL; |
| axiom_element_t *cancel_target_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| cancel_target_ele = |
| axiom_element_create(env, parent_node, TRUST_CANCEL_TARGET, wst_ns, &cancel_target_node); |
| if (!cancel_target_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] CancelTarget element creation failed."); |
| return NULL; |
| } |
| |
| if (token_cancel_pending_node) |
| { |
| /* Set up token as it is for the request */ |
| axiom_node_add_child(cancel_target_node, env, token_cancel_pending_node); |
| } |
| |
| /** Otherwise user has to create a STR as a child ot CancelTarget element and |
| * add the token reference to it. |
| **/ |
| return cancel_target_node; |
| |
| } |
| |
| AXIS2_EXTERN axiom_node_t *AXIS2_CALL |
| trust_util_create_validation_response_element( |
| const axutil_env_t * env, |
| axiom_node_t * parent_node, |
| axis2_char_t *wst_ns_uri, |
| axis2_char_t * code, |
| axis2_char_t * reason) |
| { |
| axiom_node_t *status_node = NULL; |
| axiom_node_t *code_node = NULL; |
| axiom_node_t *reason_node = NULL; |
| axiom_element_t *status_ele = NULL; |
| axiom_element_t *code_ele = NULL; |
| axiom_element_t *reason_ele = NULL; |
| axiom_namespace_t *wst_ns = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| status_ele = |
| axiom_element_create(env, parent_node, TRUST_VALIDATION_STATUS, wst_ns, &status_node); |
| if (status_ele) |
| { |
| if (code) |
| { |
| code_ele = |
| axiom_element_create(env, status_node, TRUST_VALIDATION_CODE, wst_ns, &code_node); |
| if (!code_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Code element creation failed."); |
| return NULL; |
| } |
| status = axiom_element_set_text(code_ele, env, code, code_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Code element text setting failed."); |
| return NULL; |
| } |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Code string null."); |
| return NULL; |
| } |
| |
| if (reason) |
| { |
| reason_ele = |
| axiom_element_create(env, status_node, TRUST_VALIDATION_REASON, wst_ns, |
| &reason_node); |
| if (!reason_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Reason element creation failed."); |
| return NULL; |
| } |
| status = axiom_element_set_text(reason_ele, env, reason, reason_node); |
| if (status == AXIS2_FAILURE) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] Reason element text setting failed."); |
| return status_node; |
| } |
| } |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Status element creation failed."); |
| return NULL; |
| } |
| |
| return status_node; |
| } |
| |
| |
| /*Generating Random Session Key*/ |
| AXIS2_EXTERN axiom_node_t * AXIS2_CALL |
| trust_util_create_random_session_key_proof_token_element( |
| const axutil_env_t * env, |
| axis2_char_t *wst_ns_uri) |
| { |
| axiom_namespace_t *wst_ns = NULL; |
| axiom_node_t *requested_prooft_node = NULL; |
| axiom_element_t *requested_prooft_ele = NULL; |
| |
| axiom_node_t *binary_secret_node = NULL; |
| int encodedlen = 0; |
| |
| oxs_key_t *session_key = NULL; |
| axis2_char_t * base64_encoded_key = NULL; |
| |
| wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST); |
| |
| requested_prooft_ele = axiom_element_create(env, NULL, TRUST_REQUESTED_PROOF_TOKEN, wst_ns, &requested_prooft_node); |
| |
| if (!requested_prooft_ele) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "[trust] RequestedProofToken-Session Key Proof- Element creation failed!"); |
| return NULL; |
| } |
| |
| |
| /*Generating Session key*/ |
| session_key = oxs_key_create(env); |
| oxs_key_for_algo(session_key, env, NULL); |
| |
| if(oxs_key_get_data(session_key, env)) |
| { |
| /*Encoding the binary key to base 64 encoded value*/ |
| |
| /*FIX : Encoded length is hardcoded :64 */ |
| |
| encodedlen = axutil_base64_encode_len(strlen((const char *)oxs_key_get_data(session_key, env))); |
| base64_encoded_key = AXIS2_MALLOC(env->allocator, encodedlen); |
| |
| axutil_base64_encode(base64_encoded_key, (const char *)oxs_key_get_data(session_key, env), strlen((const char *)oxs_key_get_data(session_key, env))); |
| |
| /*Inside <binarysecret> element*/ |
| binary_secret_node = trust_util_create_binary_secret_element(env, wst_ns_uri, requested_prooft_node, base64_encoded_key, TRUST_KEY_TYPE_SYMM_KEY); |
| |
| return requested_prooft_node; |
| } |
| |
| return NULL; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| trust_util_get_wst_ns( |
| const axutil_env_t * env, |
| int wst_version) |
| { |
| switch (wst_version) |
| { |
| case TRUST_VERSION_05_02: |
| return axutil_strdup(env, TRUST_WST_XMLNS_05_02); |
| case TRUST_VERSION_05_12: |
| return axutil_strdup(env, TRUST_WST_XMLNS_05_12); |
| default: |
| return NULL; |
| } |
| } |
