| /* |
| * 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_rst.h> |
| #include <trust_constants.h> |
| |
| |
| struct trust_rst |
| { |
| |
| axis2_char_t *attr_context; |
| |
| axis2_char_t *token_type; |
| |
| axis2_char_t *request_type; |
| |
| axis2_char_t *wsa_action; |
| |
| axis2_char_t *applies_to_addr; |
| |
| trust_claims_t *claims; |
| |
| trust_entropy_t *entropy; |
| |
| axis2_bool_t allow_postdating; |
| |
| axis2_bool_t renewing; |
| |
| axis2_bool_t attr_allow; |
| |
| axis2_bool_t attr_ok; |
| |
| axiom_node_t *renew_target; |
| |
| axiom_node_t *cancel_target; |
| |
| axis2_char_t *wst_ns_uri; |
| |
| trust_life_time_t *life_time; |
| |
| |
| |
| |
| axis2_char_t *key_type; |
| int key_size; |
| axis2_char_t *authentication_type; |
| axis2_char_t *signature_algo; |
| axis2_char_t *encryption_algo; |
| axis2_char_t *canonicalization_algo; |
| axis2_char_t *computed_key_algo; |
| |
| axiom_node_t *desired_encryption; |
| axiom_node_t *proof_encryption; |
| axiom_node_t *usekey; |
| axis2_char_t *usekey_sig_attr; |
| axis2_char_t *sign_with; |
| axis2_char_t *encrypt_with; |
| |
| |
| |
| /*ToDo : Federation - Trust Extensions |
| * - Authorization : AdditionalContext and CommonClaim Dialect |
| * - Prefix:auth |
| */ |
| |
| }; |
| |
| AXIS2_EXTERN trust_rst_t * AXIS2_CALL |
| trust_rst_create( |
| const axutil_env_t *env) |
| { |
| trust_rst_t *rst = NULL; |
| rst = (trust_rst_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_rst_t)); |
| |
| if(rst) |
| { |
| rst->attr_context = NULL; |
| rst->token_type = NULL; |
| rst->request_type = NULL; |
| rst->wsa_action = NULL; |
| rst->applies_to_addr = NULL; |
| rst->claims = NULL; |
| rst->entropy = NULL; |
| rst->key_type = NULL; |
| rst->key_size = -1; |
| rst->allow_postdating = AXIS2_FALSE; |
| rst->renewing = AXIS2_FALSE; |
| rst->attr_allow = AXIS2_FALSE; |
| rst->attr_ok = AXIS2_FALSE; |
| rst->renew_target = NULL; |
| rst->cancel_target = NULL; |
| rst->wst_ns_uri = NULL; |
| rst->life_time = NULL; |
| rst->authentication_type = NULL; |
| rst->signature_algo = NULL; |
| rst->encryption_algo = NULL; |
| rst->canonicalization_algo = NULL; |
| rst->computed_key_algo = NULL; |
| rst->desired_encryption = NULL; |
| rst->proof_encryption = NULL; |
| rst->usekey = NULL; |
| rst->usekey_sig_attr = NULL; |
| rst->sign_with = NULL; |
| rst->encrypt_with = NULL; |
| } |
| |
| return rst; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_populate_rst( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axiom_node_t *rst_node) |
| { |
| axiom_element_t *rst_ele = NULL; |
| axutil_qname_t *attr_ctx_qname = NULL; |
| axis2_char_t *attr_ctx = NULL; |
| |
| axiom_node_t *token_type_node = NULL; |
| axiom_element_t *token_type_ele = NULL; |
| axutil_qname_t *token_type_qname = NULL; |
| axis2_char_t *token_type = NULL; |
| |
| axiom_element_t *req_type_ele = NULL; |
| axiom_node_t *req_type_node = NULL; |
| axutil_qname_t *req_type_qname = NULL; |
| axis2_char_t *req_type = NULL; |
| |
| axutil_qname_t *applies_to_qname = NULL; /*AppliesTo*/ |
| axiom_node_t *applies_to_node = NULL; |
| axiom_element_t *applies_to_ele = NULL; |
| axutil_qname_t *applies_to_epr_qname = NULL; /*EPR*/ |
| axiom_node_t *applies_to_epr_node = NULL; |
| axiom_element_t *applies_to_epr_ele = NULL; |
| axutil_qname_t *applies_to_addr_qname = NULL; /*Addr*/ |
| axiom_node_t *applies_to_addr_node = NULL; |
| axiom_element_t *applies_to_addr_ele = NULL; |
| |
| trust_claims_t *claims = NULL; |
| axiom_node_t *claims_node = NULL; |
| axiom_element_t *claims_ele = NULL; |
| axutil_qname_t *claims_qname = NULL; |
| |
| trust_entropy_t *entropy = NULL; |
| axiom_node_t *entropy_node = NULL; |
| axiom_element_t *entropy_ele = NULL; |
| axutil_qname_t *entropy_qname = NULL; |
| |
| axiom_node_t *lifetime_node = NULL; |
| axiom_element_t *lifetime_ele = NULL; |
| axutil_qname_t *lifetime_qname = NULL; |
| |
| axiom_node_t *key_type_node = NULL; |
| axiom_element_t *key_type_ele = NULL; |
| axutil_qname_t *key_type_qname = NULL; |
| axis2_char_t *key_type = NULL; |
| |
| axiom_node_t *key_size_node = NULL; |
| axiom_element_t *key_size_ele = NULL; |
| axutil_qname_t *key_size_qname = NULL; |
| axis2_char_t *key_size = NULL; |
| |
| axiom_node_t *authnetication_type_node = NULL; |
| axiom_element_t *authnetication_type_ele = NULL; |
| axutil_qname_t *authnetication_type_qname = NULL; |
| axis2_char_t *authnetication_type = NULL; |
| |
| axiom_node_t *signature_algo_node = NULL; |
| axiom_element_t *signature_algo_ele = NULL; |
| axutil_qname_t *signature_algo_qname = NULL; |
| axis2_char_t *signature_algo = NULL; |
| |
| axiom_node_t *encryption_algo_node = NULL; |
| axiom_element_t *encryption_algo_ele = NULL; |
| axutil_qname_t *encryption_algo_qname = NULL; |
| axis2_char_t *encryption_algo = NULL; |
| |
| axiom_node_t *canonocalization_algo_node = NULL; |
| axiom_element_t *canonocalization_algo_ele = NULL; |
| axutil_qname_t *canonocalization_algo_qname = NULL; |
| axis2_char_t *canonocalization_algo = NULL; |
| |
| axiom_node_t *computedkey_algo_node = NULL; |
| axiom_element_t *computedkey_algo_ele = NULL; |
| axutil_qname_t *computedkey_algo_qname = NULL; |
| axis2_char_t *computedkey_algo = NULL; |
| |
| axiom_node_t *desired_encryption_node = NULL; |
| axiom_element_t *desired_encryption_ele = NULL; |
| axutil_qname_t *desired_encryption_qname = NULL; |
| axiom_node_t *desired_encryption_key_node = NULL; /*This can be either Key or STR*/ |
| axiom_element_t *desired_encryption_key_ele = NULL; |
| |
| axiom_node_t *proof_encryption_node = NULL; |
| axiom_element_t *proof_encryption_ele = NULL; |
| axutil_qname_t *proof_encryption_qname = NULL; |
| axiom_node_t *proof_encryption_key_node = NULL; /*This can be either Key or STR*/ |
| axiom_element_t *proof_encryption_key_ele = NULL; |
| |
| axiom_node_t *use_key_node = NULL; |
| axiom_element_t *use_key_ele = NULL; |
| axutil_qname_t *use_key_qname = NULL; |
| axiom_node_t *usekey_key_node = NULL; /*This can be either Key or STR*/ |
| axiom_element_t *usekey_key_ele = NULL; |
| |
| axiom_node_t *sign_with_node = NULL; |
| axiom_element_t *sign_with_ele = NULL; |
| axutil_qname_t *sign_with_qname = NULL; |
| axis2_char_t *sign_with = NULL; |
| |
| axiom_node_t *encrypt_with_node = NULL; |
| axiom_element_t *encrypt_with_ele = NULL; |
| axutil_qname_t *encrypt_with_qname = NULL; |
| axis2_char_t *encrypt_with = NULL; |
| |
| |
| if(NULL == rst_node || NULL == rst) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| rst_ele = (axiom_element_t*)axiom_node_get_data_element(rst_node, env); |
| |
| if(NULL == rst_ele) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| /*@Context*/ |
| attr_ctx_qname = axutil_qname_create(env, TRUST_RST_CONTEXT, rst->wst_ns_uri, TRUST_WST); |
| if (!attr_ctx_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Context Attribute Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| attr_ctx = axiom_element_get_attribute_value(rst_ele, env, attr_ctx_qname); |
| if (attr_ctx) |
| { |
| rst->attr_context = attr_ctx; |
| } |
| axutil_qname_free(attr_ctx_qname, env); |
| |
| |
| /*TokenType*/ |
| token_type_qname = axutil_qname_create(env, TRUST_TOKEN_TYPE, rst->wst_ns_uri, TRUST_WST); |
| if (!token_type_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| |
| token_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, token_type_qname, rst_node, &token_type_node); |
| if (token_type_ele) |
| { |
| token_type = axiom_element_get_text(token_type_ele, env, token_type_node); |
| if(token_type) |
| { |
| rst->token_type = token_type; |
| } |
| } |
| axutil_qname_free(token_type_qname, env); |
| |
| /* RequestType */ |
| req_type_qname = axutil_qname_create(env, TRUST_REQUEST_TYPE, rst->wst_ns_uri, TRUST_WST); |
| if (!req_type_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestType Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| |
| req_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, req_type_qname, rst_node, &req_type_node); |
| if(req_type_ele) |
| { |
| req_type = axiom_element_get_text(req_type_ele, env, req_type_node); |
| if(req_type) |
| { |
| rst->request_type = req_type; |
| } |
| } |
| axutil_qname_free(req_type_qname, env); |
| |
| /* AppliesTo */ |
| applies_to_qname = axutil_qname_create(env, TRUST_APPLIES_TO, TRUST_WSP_XMLNS, TRUST_WSP); |
| applies_to_epr_qname = axutil_qname_create(env, TRUST_EPR, TRUST_WSA_XMLNS, TRUST_WSA); |
| applies_to_addr_qname = axutil_qname_create(env, TRUST_EPR_ADDRESS, TRUST_WSA_XMLNS, TRUST_WSA); |
| if (!applies_to_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Appliesto Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| |
| applies_to_ele = axiom_element_get_first_child_with_qname(rst_ele, env, applies_to_qname, rst_node, &applies_to_node); |
| if(applies_to_ele) |
| { |
| applies_to_epr_ele = axiom_element_get_first_child_with_qname(applies_to_ele, env, applies_to_epr_qname, |
| applies_to_node, &applies_to_epr_node); |
| |
| if(applies_to_epr_ele) |
| { |
| applies_to_addr_ele = axiom_element_get_first_child_with_qname(applies_to_epr_ele, env, applies_to_addr_qname, |
| applies_to_epr_node, &applies_to_addr_node); |
| |
| if(applies_to_addr_ele) |
| { |
| rst->applies_to_addr = axiom_element_get_text(applies_to_addr_ele, env, applies_to_addr_node); |
| } |
| } |
| } |
| axutil_qname_free(applies_to_qname, env); |
| axutil_qname_free(applies_to_epr_qname, env); |
| axutil_qname_free(applies_to_addr_qname, env); |
| |
| |
| /* Claims */ |
| claims_qname = axutil_qname_create(env, TRUST_CLAIMS, rst->wst_ns_uri, TRUST_WST); |
| if (!claims_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| |
| claims_ele = axiom_element_get_first_child_with_qname(rst_ele, env, claims_qname, rst_node, &claims_node); |
| if (claims_ele) |
| { |
| claims = trust_claims_create(env); |
| if(AXIS2_SUCCESS == trust_claims_deserialize(claims, env, claims_node)) |
| { |
| rst->claims = claims; |
| } |
| } |
| axutil_qname_free(claims_qname, env); |
| |
| /*Entropy */ |
| entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, rst->wst_ns_uri, TRUST_WST); |
| if (!entropy_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| entropy_ele = axiom_element_get_first_child_with_qname(rst_ele, env, entropy_qname, rst_node, &entropy_node); |
| if(entropy_ele) |
| { |
| entropy = trust_entropy_create(env); |
| trust_entropy_set_ns_uri(entropy, env, rst->wst_ns_uri); |
| |
| if(AXIS2_SUCCESS == trust_entropy_deserialize(entropy, env, entropy_node)) |
| { |
| rst->entropy = entropy; |
| } |
| } |
| axutil_qname_free(entropy_qname, env); |
| |
| /*LifeTime*/ |
| lifetime_qname = axutil_qname_create(env, TRUST_LIFE_TIME, rst->wst_ns_uri, TRUST_WST); |
| if(!lifetime_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| lifetime_ele = axiom_element_get_first_child_with_qname(rst_ele, env, lifetime_qname, rst_node, &lifetime_node); |
| if(lifetime_ele) |
| { |
| if(AXIS2_SUCCESS == trust_life_time_deserialize(rst->life_time, env, lifetime_node)) |
| { |
| rst->life_time = NULL; |
| } |
| } |
| axutil_qname_free(lifetime_qname, env); |
| |
| /*Key and Encryption Requirements*/ |
| |
| /* KeyType */ |
| key_type_qname = axutil_qname_create(env, TRUST_KEY_TYPE, rst->wst_ns_uri, TRUST_WST); |
| if(!key_type_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeyType Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| key_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, key_type_qname, rst_node, &key_type_node); |
| if(key_type_ele) |
| { |
| key_type = axiom_element_get_text(key_type_ele, env, key_type_node); |
| if(key_type) |
| { |
| rst->key_type = key_type; |
| } |
| } |
| axutil_qname_free(key_type_qname, env); |
| |
| |
| /* KeySize */ |
| key_size_qname = axutil_qname_create(env, TRUST_KEY_SIZE, rst->wst_ns_uri, TRUST_WST); |
| key_size_ele = axiom_element_get_first_child_with_qname(rst_ele, env, key_size_qname, rst_node, &key_size_node); |
| if(key_size_ele) |
| { |
| key_size = axiom_element_get_text(key_size_ele, env, key_size_node); |
| if(key_size) |
| { |
| rst->key_size = atoi(key_size); |
| } |
| } |
| axutil_qname_free(key_size_qname, env); |
| |
| /*AuthenticationType*/ |
| authnetication_type_qname = axutil_qname_create(env, TRUST_AUTHENTICATION_TYPE, rst->wst_ns_uri, TRUST_WST); |
| authnetication_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, authnetication_type_qname, rst_node, &authnetication_type_node); |
| if(authnetication_type_ele) |
| { |
| authnetication_type = axiom_element_get_text(authnetication_type_ele, env, authnetication_type_node); |
| if(authnetication_type) |
| { |
| rst->authentication_type = authnetication_type; |
| } |
| } |
| axutil_qname_free(authnetication_type_qname, env); |
| |
| /*SignatureAlgorithm*/ |
| signature_algo_qname = axutil_qname_create(env, TRUST_SIGNATURE_ALGO, rst->wst_ns_uri, TRUST_WST); |
| signature_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, signature_algo_qname, rst_node, &signature_algo_node); |
| if(signature_algo_ele) |
| { |
| signature_algo = axiom_element_get_text(signature_algo_ele, env, signature_algo_node); |
| if(signature_algo) |
| { |
| rst->signature_algo = signature_algo; |
| } |
| } |
| axutil_qname_free(signature_algo_qname, env); |
| |
| /*EncryptionAlgorithm*/ |
| encryption_algo_qname = axutil_qname_create(env, TRUST_ENCRYPTION_ALGO, rst->wst_ns_uri, TRUST_WST); |
| encryption_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, encryption_algo_qname, rst_node, &encryption_algo_node); |
| if(encryption_algo_ele) |
| { |
| encryption_algo = axiom_element_get_text(encryption_algo_ele, env, encryption_algo_node); |
| if(encryption_algo) |
| { |
| rst->encryption_algo = encryption_algo; |
| } |
| } |
| axutil_qname_free(encryption_algo_qname, env); |
| |
| /*CanonicalizationAlgorithm*/ |
| canonocalization_algo_qname = axutil_qname_create(env, TRUST_CANONICAL_ALGO, rst->wst_ns_uri, TRUST_WST); |
| canonocalization_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, canonocalization_algo_qname, rst_node, &canonocalization_algo_node); |
| if(canonocalization_algo_ele) |
| { |
| canonocalization_algo = axiom_element_get_text(canonocalization_algo_ele, env, canonocalization_algo_node); |
| if(canonocalization_algo) |
| { |
| rst->canonicalization_algo = canonocalization_algo; |
| } |
| } |
| axutil_qname_free(canonocalization_algo_qname, env); |
| |
| /*ComputedKeyAlgorithm*/ |
| computedkey_algo_qname = axutil_qname_create(env, TRUST_COMPUTED_KEY_ALGO, rst->wst_ns_uri, TRUST_WST); |
| computedkey_algo_ele = axiom_element_get_first_child_with_qname(rst_ele, env, computedkey_algo_qname, rst_node, &computedkey_algo_node); |
| if(computedkey_algo_ele) |
| { |
| computedkey_algo = axiom_element_get_text(computedkey_algo_ele, env, computedkey_algo_node); |
| if(computedkey_algo) |
| { |
| rst->computed_key_algo = computedkey_algo; |
| } |
| } |
| axutil_qname_free(computedkey_algo_qname, env); |
| |
| |
| /*(Desired)Encryption */ |
| desired_encryption_qname = axutil_qname_create(env, TRUST_DESIRED_ENCRYPTION, rst->wst_ns_uri, TRUST_WST); |
| if (!desired_encryption_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Encryption Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| desired_encryption_ele = axiom_element_get_first_child_with_qname(rst_ele, env, desired_encryption_qname, rst_node, &desired_encryption_node); |
| if(desired_encryption_ele) |
| { |
| desired_encryption_key_ele = axiom_element_get_first_element(desired_encryption_ele, env, desired_encryption_node, &desired_encryption_key_node); |
| rst->desired_encryption = desired_encryption_key_node; |
| } |
| axutil_qname_free(desired_encryption_qname, env); |
| |
| /*ProofEncryption*/ |
| proof_encryption_qname = axutil_qname_create(env, TRUST_PROOF_ENCRYPTION, rst->wst_ns_uri, TRUST_WST); |
| if (!proof_encryption_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] ProofEncryption Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| proof_encryption_ele = axiom_element_get_first_child_with_qname(rst_ele, env, proof_encryption_qname, rst_node, &proof_encryption_node); |
| if(proof_encryption_ele) |
| { |
| proof_encryption_key_ele = axiom_element_get_first_element(proof_encryption_ele, env, proof_encryption_node, &proof_encryption_key_node); |
| rst->proof_encryption = proof_encryption_key_node; |
| |
| } |
| axutil_qname_free(proof_encryption_qname, env); |
| |
| /*UseKey*/ |
| use_key_qname = axutil_qname_create(env, TRUST_USE_KEY, rst->wst_ns_uri, TRUST_WST); |
| if(!use_key_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] UseKey Qname creation failed."); |
| return AXIS2_FAILURE; |
| |
| } |
| use_key_ele = axiom_element_get_first_child_with_qname(rst_ele, env, use_key_qname, rst_node, &use_key_node); |
| if(use_key_ele) |
| { |
| usekey_key_ele = axiom_element_get_first_element(use_key_ele, env, use_key_node, &usekey_key_node); |
| rst->usekey = usekey_key_node; |
| } |
| axutil_qname_free(use_key_qname, env); |
| |
| /*SignWith*/ |
| sign_with_qname = axutil_qname_create(env, TRUST_SIGN_WITH, rst->wst_ns_uri, TRUST_WST); |
| sign_with_ele = axiom_element_get_first_child_with_qname(rst_ele, env, sign_with_qname, rst_node, &sign_with_node); |
| if(sign_with_ele) |
| { |
| sign_with = axiom_element_get_text(sign_with_ele, env, sign_with_node); |
| if(sign_with) |
| { |
| rst->sign_with = sign_with; |
| } |
| } |
| axutil_qname_free(sign_with_qname, env); |
| |
| /*EncryptWith*/ |
| encrypt_with_qname = axutil_qname_create(env, TRUST_ENCRYPT_WITH, rst->wst_ns_uri, TRUST_WST); |
| if(!encrypt_with_qname) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] EncryptWith Qname creation failed."); |
| return AXIS2_FAILURE; |
| } |
| encrypt_with_ele = axiom_element_get_first_child_with_qname(rst_ele, env, encrypt_with_qname, rst_node, &encrypt_with_node); |
| if(encrypt_with_ele) |
| { |
| encrypt_with = axiom_element_get_text(encrypt_with_ele, env, encrypt_with_node); |
| if(encrypt_with) |
| { |
| rst->encrypt_with = encrypt_with; |
| } |
| } |
| axutil_qname_free(encrypt_with_qname, env); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| |
| AXIS2_EXTERN axiom_node_t * AXIS2_CALL |
| trust_rst_build_rst( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axiom_node_t *parent) |
| { |
| axiom_node_t *rst_node = NULL; |
| axis2_char_t *key_size = NULL; |
| |
| rst_node = (axiom_node_t*)trust_util_create_rst_element(env, rst->wst_ns_uri, rst->attr_context); |
| |
| if(rst_node) |
| { |
| if(rst->token_type || rst->applies_to_addr) |
| { |
| if(rst->token_type) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_token_type_element(env, rst->wst_ns_uri, rst_node, rst->token_type)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->applies_to_addr) |
| { |
| /*AppliesTo in WSP - No Need to pass the trust version*/ |
| if(NULL == (axiom_node_t*)trust_util_create_applies_to_element(env, rst_node, rst->applies_to_addr, TRUST_WSA_XMLNS)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] AppliesTo element creation failed."); |
| return NULL; |
| } |
| } |
| } |
| else |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] You must at least give token type or applies to address."); |
| return NULL; |
| } |
| |
| if(rst->request_type) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_request_type_element(env, rst->wst_ns_uri, rst_node, rst->request_type)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestType element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->claims) |
| { |
| if(NULL == trust_claims_serialize(rst->claims, env, rst_node)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->entropy) |
| { |
| if(NULL == trust_entropy_serialize(rst->entropy, env, rst_node)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->life_time) |
| { |
| if(NULL == trust_life_time_serialize(rst->life_time, env, rst_node)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->key_type) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_key_type_element(env, rst->wst_ns_uri, rst_node, rst->key_type)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeyType element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->key_size > 0) |
| { |
| /*INFO -keysize Malloc Size = 128 */ |
| key_size = AXIS2_MALLOC( env->allocator, sizeof(char)*128); |
| sprintf(key_size, "%d", rst->key_size); |
| if(NULL == (axiom_node_t*)trust_util_create_key_size_element(env, rst->wst_ns_uri, rst_node, key_size)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeySize element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->authentication_type) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_authentication_type_element(env, rst->wst_ns_uri, rst_node, rst->authentication_type)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] AuthenticationType element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->signature_algo) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_signature_algo_element(env, rst->wst_ns_uri, rst_node, rst->signature_algo)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] SignatureAlgo element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->encryption_algo) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_encryption_algo_element(env, rst->wst_ns_uri, rst_node, rst->encryption_algo)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] EncryptionAlgo element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->canonicalization_algo) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_canonicalization_algo_element(env, rst->wst_ns_uri, rst_node, rst->canonicalization_algo)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] CanonicalizationAlgo element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->computed_key_algo) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_computedkey_algo_element(env, rst->wst_ns_uri, rst_node, rst->computed_key_algo)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] ComputedKeyAlgo element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->desired_encryption) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_desired_encryption_element(env, rst->wst_ns_uri, rst_node, rst->desired_encryption)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] DesiredEncryption element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->proof_encryption) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_proof_encryption_element(env, rst->wst_ns_uri, rst_node, rst->proof_encryption)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] ProofEncryption element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->usekey) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_usekey_element(env, rst->wst_ns_uri, rst_node, rst->usekey)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] UseKey element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->sign_with) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_signwith_element(env, rst->wst_ns_uri, rst_node, rst->sign_with)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] SignWith element creation failed."); |
| return NULL; |
| } |
| } |
| |
| if(rst->encrypt_with) |
| { |
| if(NULL == (axiom_node_t*)trust_util_create_encryptwith_element(env, rst->wst_ns_uri, rst_node, rst->encrypt_with)) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] EncryptWith element creation failed."); |
| return NULL; |
| } |
| } |
| |
| |
| return rst_node; |
| } |
| |
| return NULL; |
| } |
| |
| |
| AXIS2_EXTERN axiom_node_t * AXIS2_CALL |
| trust_rst_build_rst_with_issued_token_assertion( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| rp_issued_token_t *issued_token) |
| { |
| axiom_node_t *rst_node = NULL; |
| axiom_node_t *rst_template_node = NULL; |
| axiom_element_t * rst_template_element = NULL; |
| axiom_children_iterator_t *rst_template_children_iter = NULL; |
| axiom_node_t *rst_template_child = NULL; |
| |
| |
| /*Attr Context is NULL -?*/ |
| rst_node = (axiom_node_t*)trust_util_create_rst_element(env, rst->wst_ns_uri, rst->attr_context); |
| rst_template_node = rp_issued_token_get_requested_sec_token_template(issued_token, env); |
| rst_template_node = axiom_node_detach(rst_template_node, env); /*Detaching RSTTemplate from the original location- FIX - Detaching problem with NS'*/ |
| rst_template_element = axiom_node_get_data_element(rst_template_node, env); |
| |
| rst_template_children_iter = axiom_element_get_children(rst_template_element, env, rst_template_node); |
| |
| |
| while(axiom_children_iterator_has_next(rst_template_children_iter, env)) |
| { |
| rst_template_child = axiom_children_iterator_next(rst_template_children_iter, env); |
| if(rst_template_node) |
| axiom_node_add_child(rst_node, env, rst_template_child); |
| } |
| |
| if(rst_node) |
| return rst_node; |
| |
| |
| return NULL; |
| } |
| |
| |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_attr_context( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->attr_context; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_attr_context( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *attr_context) |
| { |
| if(attr_context) |
| { |
| rst->attr_context = attr_context; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_token_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->token_type; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_token_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *token_type) |
| { |
| if(token_type) |
| { |
| rst->token_type = token_type; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_request_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->request_type; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_request_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *request_type) |
| { |
| if(request_type) |
| { |
| rst->request_type = request_type; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_wsa_action( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->wsa_action; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_wsa_action( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *wsa_action) |
| { |
| if(wsa_action) |
| { |
| rst->wsa_action = wsa_action; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_applies_to_addr( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->applies_to_addr; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_appliesto( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *applies_to_addr) |
| { |
| if(applies_to_addr) |
| { |
| rst->applies_to_addr = applies_to_addr; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN trust_claims_t * AXIS2_CALL |
| trust_rst_get_claims( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->claims; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_claims( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| trust_claims_t *claims) |
| { |
| if(claims) |
| { |
| rst->claims = claims; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN trust_entropy_t * AXIS2_CALL |
| trust_rst_get_entropy( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->entropy; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_entropy( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| trust_entropy_t *entropy) |
| { |
| if(entropy) |
| { |
| rst->entropy = entropy; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN trust_life_time_t * AXIS2_CALL |
| trust_rst_get_life_time( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->life_time; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_life_time( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| trust_life_time_t *life_time) |
| { |
| if(life_time) |
| { |
| rst->life_time = life_time; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_key_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *key_type) |
| { |
| if(key_type) |
| { |
| rst->key_type = key_type; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_key_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->key_type; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_key_size( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| int key_size) |
| { |
| if(key_size > 0) |
| { |
| rst->key_size = key_size; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| trust_rst_get_key_size( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->key_size; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_authentication_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *authentication_type) |
| { |
| if(authentication_type) |
| { |
| rst->authentication_type = authentication_type; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_authentication_type( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->authentication_type; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_signature_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *signature_algorithm) |
| { |
| if(signature_algorithm) |
| { |
| rst->signature_algo = signature_algorithm; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_signature_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->signature_algo; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_encryption_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *encryption_algorithm) |
| { |
| if(encryption_algorithm) |
| { |
| rst->encryption_algo = encryption_algorithm; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_encryption_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->encryption_algo; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_canonicalization_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *canonicalization_algorithm) |
| { |
| if(canonicalization_algorithm) |
| { |
| rst->canonicalization_algo = canonicalization_algorithm; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_canonicalization_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->canonicalization_algo; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_computedkey_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *computedkey_algorithm) |
| { |
| if(computedkey_algorithm) |
| { |
| rst->computed_key_algo = computedkey_algorithm; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_computedkey_algorithm( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->computed_key_algo; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_desired_encryption( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axiom_node_t *desired_encryption_key) |
| { |
| if(desired_encryption_key) |
| { |
| rst->desired_encryption = desired_encryption_key; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| |
| |
| AXIS2_EXTERN axiom_node_t * AXIS2_CALL |
| trust_rst_get_desired_encryption( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->desired_encryption; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_proof_encryption( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axiom_node_t *proof_encryption_key) |
| { |
| if(proof_encryption_key) |
| { |
| rst->proof_encryption = proof_encryption_key; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axiom_node_t * AXIS2_CALL |
| trust_rst_get_proof_encryption( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->proof_encryption; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_usekey( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axiom_node_t *usekey_key) |
| { |
| if(usekey_key) |
| { |
| rst->usekey = usekey_key; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axiom_node_t * AXIS2_CALL |
| trust_rst_get_usekey( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->usekey; |
| } |
| /*FIX Usekey attr @Sig*/ |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_signwith( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *signwith) |
| { |
| if(signwith) |
| { |
| rst->sign_with = signwith; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_signwith( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->sign_with; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_encryptwith( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *encryptwith) |
| { |
| if(encryptwith) |
| { |
| rst->encrypt_with = encryptwith; |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_encryptwith( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->encrypt_with; |
| } |
| |
| AXIS2_EXTERN axis2_char_t * AXIS2_CALL |
| trust_rst_get_wst_ns_uri( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| return rst->wst_ns_uri; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| trust_rst_set_wst_ns_uri( |
| trust_rst_t *rst, |
| const axutil_env_t *env, |
| axis2_char_t *wst_ns_uri) |
| { |
| if(wst_ns_uri) |
| { |
| rst->wst_ns_uri = wst_ns_uri; |
| return AXIS2_SUCCESS; |
| } |
| |
| return AXIS2_FAILURE; |
| } |
| |
| |
| AXIS2_EXTERN void AXIS2_CALL |
| trust_rst_free( |
| trust_rst_t *rst, |
| const axutil_env_t *env) |
| { |
| AXIS2_FREE(env->allocator, rst); |
| } |
| |
| |
| |
