You are viewing a plain text version of this content. The canonical link for it is here.
Posted to rampart-dev@ws.apache.org by mi...@apache.org on 2008/02/07 04:59:59 UTC
svn commit: r619251 [2/3] - in /webservices/rampart/trunk/c: ./ include/
src/trust/
Added: webservices/rampart/trunk/c/src/trust/entropy.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/trust/entropy.c?rev=619251&view=auto
==============================================================================
--- webservices/rampart/trunk/c/src/trust/entropy.c (added)
+++ webservices/rampart/trunk/c/src/trust/entropy.c Wed Feb 6 19:59:55 2008
@@ -0,0 +1,282 @@
+/*
+ * 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_entropy.h>
+
+struct trust_entropy
+{
+ /* Boolean to specify the type of the entropy. Entropy can be either binary secret
+ * or encrypted key
+ */
+ axis2_bool_t bin_sec;
+
+ axis2_char_t *binary_secret;
+
+ axis2_char_t *encrypted_key;
+
+ trust_bin_sec_type_t binsec_type;
+
+ axiom_node_t *other;
+
+ axis2_char_t *ns_uri;
+
+};
+
+AXIS2_EXTERN trust_entropy_t * AXIS2_CALL
+trust_entropy_create(
+ const axutil_env_t *env)
+{
+ trust_entropy_t *entropy = NULL;
+
+ entropy = (trust_entropy_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_entropy_t));
+
+ entropy->bin_sec = AXIS2_TRUE;
+ entropy->binary_secret = NULL;
+ entropy->binsec_type = SYMMETRIC;
+ entropy->encrypted_key = NULL;
+
+ return entropy;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_entropy_free(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env)
+{
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_entropy_deserialize(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env,
+ axiom_node_t *entropy_node)
+{
+ axutil_qname_t *bin_sec_qname = NULL;
+ axiom_element_t *entropy_ele = NULL;
+ axiom_node_t *bin_sec_node = NULL;
+ axiom_element_t *bin_sec_ele = NULL;
+ axis2_char_t *bin_sec = NULL;
+ axis2_char_t *binsec_type = NULL;
+ axiom_node_t *other_node = NULL;
+ axiom_element_t *other_ele = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ entropy_ele = axiom_node_get_data_element(entropy_node, env);
+
+ if(entropy_ele)
+ {
+ bin_sec_qname = axutil_qname_create(env, TRUST_BINARY_SECRET, entropy->ns_uri, TRUST_WST);
+ if(!bin_sec_qname)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] BinarySecret Qname creation failed.");
+ return AXIS2_FAILURE;
+ }
+
+ bin_sec_ele = axiom_element_get_first_child_with_qname(entropy_ele, env, bin_sec_qname, entropy_node, &bin_sec_node);
+ if(bin_sec_ele)
+ {
+ bin_sec = axiom_element_get_text(bin_sec_ele, env, bin_sec_node);
+ status = trust_entropy_set_binary_secret(entropy, env, bin_sec);
+
+ binsec_type = axiom_element_get_attribute_value_by_name(bin_sec_ele, env, TRUST_BIN_SEC_TYPE_ATTR);
+ if(binsec_type)
+ {
+ entropy->binsec_type = trust_entropy_get_bin_sec_type_from_str(binsec_type, env); /* TODO*/
+ if(status == AXIS2_SUCCESS)
+ {
+ return AXIS2_SUCCESS;
+ }
+ }
+ }
+ else
+ {
+ other_ele = axiom_element_get_first_element(entropy_ele, env, entropy_node, &other_node);
+ if(other_ele)
+ {
+ entropy->bin_sec = AXIS2_FALSE;
+ entropy->other = other_node;
+
+ return AXIS2_SUCCESS;
+ }
+ }
+
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_entropy_serialize(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env,
+ axiom_node_t *parent)
+{
+ axiom_node_t *entropy_node = NULL;
+ axiom_node_t *bin_sec_node = NULL;
+ axis2_char_t *bin_sec_type = NULL;
+
+ entropy_node = (axiom_node_t*)trust_util_create_entropy_element(env, entropy->ns_uri, parent);
+
+ if(entropy_node)
+ {
+ if(entropy->bin_sec == AXIS2_TRUE)
+ {
+ bin_sec_type = trust_entropy_get_str_for_bin_sec_type(entropy->binsec_type, env);
+ bin_sec_node = (axiom_node_t*)trust_util_create_binary_secret_element(env, entropy->ns_uri, entropy_node, entropy->binary_secret, bin_sec_type);
+ if(bin_sec_node)
+ {
+ return entropy_node;
+ }
+ }
+ else
+ {
+ if(AXIS2_SUCCESS == axiom_node_add_child(entropy_node, env, entropy->other))
+ {
+ return entropy_node;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_entropy_get_binary_secret(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env)
+{
+ if(entropy->bin_sec == AXIS2_TRUE)
+ {
+ return entropy->binary_secret;
+ }
+
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_entropy_set_binary_secret(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env,
+ axis2_char_t *bin_sec)
+{
+ if(bin_sec)
+ {
+ entropy->binary_secret = bin_sec;
+ entropy->bin_sec = AXIS2_TRUE;
+
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FALSE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_entropy_get_other(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env)
+{
+ if(entropy->bin_sec == AXIS2_FALSE)
+ {
+ return entropy->other;
+ }
+
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_entropy_set_other(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env,
+ axiom_node_t *other_node)
+{
+ if(other_node)
+ {
+ entropy->bin_sec = AXIS2_FALSE;
+ entropy->other = other_node;
+
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_entropy_get_ns_uri(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env)
+{
+ return entropy->ns_uri;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_entropy_set_ns_uri(
+ trust_entropy_t *entropy,
+ const axutil_env_t *env,
+ axis2_char_t *ns_uri)
+{
+ if(ns_uri)
+ {
+ entropy->ns_uri = ns_uri;
+
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN trust_bin_sec_type_t AXIS2_CALL
+trust_entropy_get_bin_sec_type_from_str(
+ axis2_char_t *str,
+ const axutil_env_t *env)
+{
+ if(!axutil_strcmp(str, BIN_SEC_ASSYM))
+ {
+ return ASYMMETRIC;
+ }
+ else if(!axutil_strcmp(str, BIN_SEC_SYM))
+ {
+ return SYMMETRIC;
+ }
+ else if(!axutil_strcmp(str, BIN_SEC_NONCE))
+ {
+ return NONCE;
+ }
+
+ return BIN_SEC_TYPE_ERROR;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_entropy_get_str_for_bin_sec_type(
+ trust_bin_sec_type_t type,
+ const axutil_env_t *env)
+{
+ if(type == ASYMMETRIC)
+ {
+ return axutil_strdup(env, BIN_SEC_ASSYM);
+ }
+ else if (type == SYMMETRIC)
+ {
+ return axutil_strdup(env, BIN_SEC_SYM);
+ }
+ else if (type == NONCE)
+ {
+ return axutil_strdup(env, BIN_SEC_NONCE);
+ }
+
+ return NULL;
+}
Added: webservices/rampart/trunk/c/src/trust/life_time.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/trust/life_time.c?rev=619251&view=auto
==============================================================================
--- webservices/rampart/trunk/c/src/trust/life_time.c (added)
+++ webservices/rampart/trunk/c/src/trust/life_time.c Wed Feb 6 19:59:55 2008
@@ -0,0 +1,316 @@
+/*
+ * 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_life_time.h>
+
+struct trust_life_time
+{
+ int ttl;
+ axutil_date_time_t *created;
+ axutil_date_time_t *expires;
+ axis2_char_t *wst_ns_uri;
+ axis2_char_t *wsu_ns_uri;
+};
+
+AXIS2_EXTERN trust_life_time_t * AXIS2_CALL
+trust_life_time_create(
+ const axutil_env_t *env)
+{
+ trust_life_time_t *life_time = NULL;
+
+ life_time = (trust_life_time_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_life_time_t));
+
+ life_time->ttl = -1;
+ life_time->created = NULL;
+ life_time->expires = NULL;
+ life_time->wst_ns_uri = NULL;
+ life_time->wsu_ns_uri = NULL;
+
+ return life_time;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+ trust_life_time_free(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env)
+{
+ return AXIS2_SUCCESS;
+}
+
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_life_time_deserialize(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env,
+ axiom_node_t *life_time_node)
+{
+ axiom_element_t *life_time_ele = NULL;
+ axutil_qname_t *created_qname = NULL;
+ axutil_qname_t *expires_qname = NULL;
+ axiom_element_t *created_ele = NULL;
+ axiom_element_t *expires_ele = NULL;
+ axiom_node_t *created_node = NULL;
+ axiom_node_t *expires_node = NULL;
+ axis2_char_t *created_str = NULL;
+ axis2_char_t *expires_str = NULL;
+ axutil_date_time_t *created = NULL;
+ axutil_date_time_t *expires = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ life_time_ele = axiom_node_get_data_element(life_time_node, env);
+
+ if(life_time_ele)
+ {
+ created_qname = axutil_qname_create(env, TRUST_LIFE_TIME_CREATED, TRUST_WSU_XMLNS, TRUST_WSU);
+ if(!created_qname)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Created Qname creation failed.");
+ return AXIS2_FAILURE;
+ }
+
+ created_ele = axiom_element_get_first_child_with_qname(life_time_ele, env, created_qname, life_time_node, &created_node);
+ if(created_ele)
+ {
+ created_str = axiom_element_get_text(created_ele, env, created_node);
+ if(created_str)
+ {
+ created = axutil_date_time_create(env);
+ if(AXIS2_SUCCESS == axutil_date_time_deserialize_date_time(created, env, created_str))
+ {
+ life_time->created = created;
+ status = AXIS2_SUCCESS;
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Deserializing created time failed.");
+ return AXIS2_FAILURE;
+ }
+ }
+ }
+
+ expires_qname = axutil_qname_create(env, TRUST_LIFE_TIME_EXPIRES, TRUST_WSU_XMLNS, TRUST_WSU);
+ if(!created_qname)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Expires Qname creation failed.");
+ return AXIS2_FAILURE;
+ }
+
+ expires_ele = axiom_element_get_first_child_with_qname(life_time_ele, env, expires_qname, life_time_node, &expires_node);
+ if(expires_ele)
+ {
+ expires_str = axiom_element_get_text(expires_ele, env, expires_node);
+ if(created_str)
+ {
+ expires = axutil_date_time_create(env);
+ if(AXIS2_SUCCESS == axutil_date_time_deserialize_date_time(expires, env, expires_str))
+ {
+ life_time->expires = expires;
+ status = AXIS2_SUCCESS;
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Deserializing created time failed.");
+ return AXIS2_FAILURE;
+ }
+ }
+ }
+
+ if(status == AXIS2_SUCCESS)
+ return AXIS2_SUCCESS;
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+trust_life_time_serialize(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env,
+ axiom_node_t *parent)
+{
+ 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;
+ axiom_namespace_t *wsu_ns = NULL;
+ axiom_namespace_t *wst_ns = NULL;
+ axis2_status_t status = AXIS2_SUCCESS;
+ axis2_char_t *created_str = NULL;
+ axis2_char_t *expires_str = NULL;
+
+ if(life_time->ttl != -1 && life_time->ttl > 0)
+ {
+ life_time_node = (axiom_node_t*)trust_util_create_life_time_element(env, parent, life_time->wst_ns_uri, life_time->ttl);
+ if(!life_time_node)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Life time element creation failed for ttl.");
+ return NULL;
+ }
+
+ return life_time_node;
+ }
+ else
+ {
+ if(life_time->created || life_time->expires)
+ {
+ wsu_ns = axiom_namespace_create(env, TRUST_WSU_XMLNS, TRUST_WSU);
+ wst_ns = axiom_namespace_create(env, life_time->wst_ns_uri, TRUST_WST);
+ life_time_ele = axiom_element_create(env, parent, TRUST_LIFE_TIME, wst_ns, &life_time_node);
+ if(life_time_ele)
+ {
+ if(life_time->created)
+ {
+ created_ele = axiom_element_create(env, life_time_node, TRUST_LIFE_TIME_CREATED, wsu_ns, &created_node);
+ if(created_ele)
+ {
+ created_str = axutil_date_time_serialize_date_time(life_time->created, env);
+ status = axiom_element_set_text(created_ele, env, created_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_str);
+ }
+ }
+
+ if(life_time->expires)
+ {
+ expires_ele = axiom_element_create(env, life_time_node, TRUST_LIFE_TIME_EXPIRES, wsu_ns, &expires_node);
+ if(expires_ele)
+ {
+ expires_str = axutil_date_time_serialize_date_time(life_time->expires, env);
+ status = axiom_element_set_text(expires_ele, env, expires_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_str);
+ }
+ }
+
+ return life_time_node;
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime element creation failed.");
+ return NULL;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+trust_life_time_get_ttl(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env)
+{
+ return life_time->ttl;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_life_time_set_ttl(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env,
+ int ttl)
+{
+ if(ttl>0)
+ {
+ life_time->ttl = ttl;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axutil_date_time_t * AXIS2_CALL
+trust_life_time_get_created(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env)
+{
+ return life_time->created;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_life_time_set_created(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env,
+ axutil_date_time_t *created)
+{
+ if(created)
+ {
+ life_time->created = created;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axutil_date_time_t * AXIS2_CALL
+trust_life_time_get_expires(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env)
+{
+ return life_time->expires;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_life_time_set_expires(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env,
+ axutil_date_time_t *expires)
+{
+ if(expires)
+ {
+ life_time->expires = expires;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_life_time_get_ns_uri(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env)
+{
+ return life_time->wst_ns_uri;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_life_time_set_ns_uri(
+ trust_life_time_t *life_time,
+ const axutil_env_t *env,
+ axis2_char_t *ns_uri)
+{
+ if(ns_uri)
+ {
+ life_time->wst_ns_uri = ns_uri;
+
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
Modified: webservices/rampart/trunk/c/src/trust/policy_util.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/trust/policy_util.c?rev=619251&r1=619250&r2=619251&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/trust/policy_util.c (original)
+++ webservices/rampart/trunk/c/src/trust/policy_util.c Wed Feb 6 19:59:55 2008
@@ -15,6 +15,7 @@
* limitations under the License.
*/
#include <trust_policy_util.h>
+#include <trust_constants.h>
AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL
trust_policy_util_get_algorithmsuite(
Added: webservices/rampart/trunk/c/src/trust/rst.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/trust/rst.c?rev=619251&view=auto
==============================================================================
--- webservices/rampart/trunk/c/src/trust/rst.c (added)
+++ webservices/rampart/trunk/c/src/trust/rst.c Wed Feb 6 19:59:55 2008
@@ -0,0 +1,1232 @@
+/*
+ * 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>
+
+
+struct trust_rst
+{
+
+ axis2_char_t *attr_context;
+
+ axis2_char_t *token_type;
+
+ axis2_char_t *request_type;
+
+ 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));
+
+ rst->attr_context = NULL;
+ rst->token_type = NULL;
+ rst->request_type = 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;
+ }
+
+
+ /*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;
+ }
+ }
+
+ /* 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;
+ }
+ }
+
+ /* 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);
+ }
+ }
+ }
+
+
+ /* 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)
+ {
+ if(AXIS2_SUCCESS == trust_claims_deserialize(claims, env, claims_node))
+ {
+ rst->claims = claims;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+
+ /* 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);
+ }
+ }
+
+ /*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;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+
+ /*(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;
+ }
+
+ /*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;
+
+ }
+
+ /*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;
+ }
+
+ /*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;
+ }
+ }
+
+ /*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;
+ }
+ }
+
+ AXIS2_FREE(env->allocator, key_size_qname);
+ AXIS2_FREE(env->allocator, key_type_qname);
+ AXIS2_FREE(env->allocator, lifetime_qname);
+ AXIS2_FREE(env->allocator, entropy_qname);
+ AXIS2_FREE(env->allocator, claims_qname);
+ AXIS2_FREE(env->allocator, applies_to_qname);
+ AXIS2_FREE(env->allocator, applies_to_epr_qname);
+ AXIS2_FREE(env->allocator, applies_to_addr_qname);
+ AXIS2_FREE(env->allocator, req_type_qname);
+ AXIS2_FREE(env->allocator, token_type_qname);
+ AXIS2_FREE(env->allocator, attr_ctx_qname);
+ AXIS2_FREE(env->allocator, authnetication_type_qname);
+ AXIS2_FREE(env->allocator, signature_algo_qname);
+ AXIS2_FREE(env->allocator, encryption_algo_qname);
+ AXIS2_FREE(env->allocator, canonocalization_algo_qname);
+ AXIS2_FREE(env->allocator, computedkey_algo_qname);
+ AXIS2_FREE(env->allocator, proof_encryption_qname);
+ AXIS2_FREE(env->allocator, use_key_qname);
+ AXIS2_FREE(env->allocator, sign_with_qname);
+ AXIS2_FREE(env->allocator, encrypt_with_qname);
+
+ 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 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_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)
+{
+ return;
+}
+
+
Added: webservices/rampart/trunk/c/src/trust/rstr.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/trust/rstr.c?rev=619251&view=auto
==============================================================================
--- webservices/rampart/trunk/c/src/trust/rstr.c (added)
+++ webservices/rampart/trunk/c/src/trust/rstr.c Wed Feb 6 19:59:55 2008
@@ -0,0 +1,631 @@
+/*
+ * 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_rstr.h>
+
+struct trust_rstr{
+
+ axis2_char_t *attr_context; /*Context Attribute of RSTR : same as RST context attribute */
+
+ axis2_char_t *token_type;
+
+ axis2_char_t *request_type;
+
+ axiom_node_t *requested_sec_token;
+
+ axis2_char_t *applies_to;
+
+ axiom_node_t *requested_attached_ref;
+
+ axiom_node_t *requested_unattached_ref;
+
+ axiom_node_t *requested_proof_token;
+
+ trust_entropy_t *entropy;
+
+ trust_life_time_t *life_time;
+
+ int key_size;
+
+ axis2_char_t *wst_ns_uri;
+
+ /*Use state whether response is going inside soap header or soap body*/
+ axis2_bool_t in_header;
+};
+
+AXIS2_EXTERN trust_rstr_t * AXIS2_CALL
+trust_rstr_create(
+ const axutil_env_t *env)
+{
+ trust_rstr_t *rstr = NULL;
+
+ rstr = (trust_rstr_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_rstr_t));
+
+ rstr->token_type = NULL;
+ rstr->attr_context = NULL;
+ rstr->request_type = NULL;
+ rstr->requested_sec_token = NULL;
+ rstr->applies_to = NULL;
+ rstr->requested_attached_ref = NULL;
+ rstr->requested_unattached_ref = NULL;
+ rstr->requested_proof_token = NULL;
+ rstr->entropy = NULL;
+ rstr->life_time = NULL;
+ rstr->key_size = -1;
+ rstr->wst_ns_uri = NULL;
+
+ return rstr;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_free(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return AXIS2_SUCCESS;
+}
+
+
+/*Populating RSTR*/
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_populate_rstr(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axiom_node_t *rstr_node)
+{
+ axiom_element_t *rstr_ele = NULL;
+ axutil_qname_t *attr_ctx_qname = NULL;
+ axis2_char_t *attr_ctx = NULL;
+
+ axiom_node_t *requested_security_token_node = NULL;
+ axiom_element_t *requested_security_token_ele = NULL;
+ axutil_qname_t *requested_security_token_qname = NULL;
+
+ axiom_node_t *proof_token_node = NULL;
+ axiom_element_t *proof_token_ele = NULL;
+ axutil_qname_t *proof_token_qname = 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;
+
+ axutil_qname_t *applies_to_qname = NULL;
+ axiom_node_t *appliesto_node = NULL;
+ axiom_element_t *appliesto_ele = NULL;
+ axiom_node_t *first_node = NULL;
+ axiom_element_t *first_ele = 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_size_node = NULL;
+ axiom_element_t *key_size_ele = NULL;
+ axutil_qname_t *key_size_qname = NULL;
+ axis2_char_t *key_size = NULL;
+
+
+ rstr_ele = (axiom_element_t*)axiom_node_get_data_element(rstr_node, env);
+
+ /*@Context RSTR*/
+ attr_ctx_qname = axutil_qname_create(env, TRUST_RST_CONTEXT, rstr->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(rstr_ele, env, attr_ctx_qname);
+
+ if (attr_ctx)
+ {
+ rstr->attr_context = attr_ctx;
+ }
+
+
+
+ /*TokenType*/
+ token_type_qname = axutil_qname_create(env, TRUST_TOKEN_TYPE, rstr->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(rstr_ele, env, token_type_qname, rstr_node, &token_type_node);
+ if (token_type_ele)
+ {
+ token_type = axiom_element_get_text(token_type_ele, env, token_type_node);
+ if(token_type)
+ {
+ rstr->token_type = token_type;
+ }
+ }
+
+
+ /*RequestedSecurityToken*/
+ requested_security_token_qname = axutil_qname_create(env, TRUST_REQUESTED_SECURITY_TOKEN, rstr->wst_ns_uri, TRUST_WST);
+ if(!requested_security_token_qname)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedSecurityToken Qname creation failed.");
+ return AXIS2_FAILURE;
+ }
+ requested_security_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, requested_security_token_qname,
+ rstr_node, &requested_security_token_node);
+ if(requested_security_token_ele)
+ {
+ axiom_element_get_first_element(requested_security_token_ele, env, requested_security_token_node, &rstr->requested_sec_token);
+ }
+
+
+ /*RequestedProofToken*/
+ proof_token_qname = axutil_qname_create(env, TRUST_REQUESTED_PROOF_TOKEN, rstr->wst_ns_uri, TRUST_WST);
+ if(proof_token_qname)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedProofToken Qname creation failed.");
+ return AXIS2_FAILURE;
+ }
+ proof_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, proof_token_qname, rstr_node, &proof_token_node);
+ if(proof_token_ele)
+ {
+ axiom_element_get_first_element(proof_token_ele, env, proof_token_node, &rstr->requested_proof_token);
+ }
+
+
+
+ /*AppliesTo*/
+ applies_to_qname = axutil_qname_create(env, TRUST_APPLIES_TO, TRUST_WSP_XMLNS, TRUST_WSP);
+ if (!applies_to_qname)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Appliesto Qname creation failed.");
+ return AXIS2_FAILURE;
+ }
+
+ appliesto_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, applies_to_qname, rstr_node, &appliesto_node);
+ if(appliesto_ele)
+ {
+ first_ele = axiom_element_get_first_element(appliesto_ele, env, appliesto_node, &first_node);
+ if(first_ele)
+ {
+ rstr->applies_to = axiom_element_get_text(first_ele, env, first_node);
+ }
+ }
+
+
+ /*Entropy*/
+ entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, rstr->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(rstr_ele, env, entropy_qname, rstr_node, &entropy_node);
+ if(entropy_ele)
+ {
+ if(AXIS2_SUCCESS == trust_entropy_deserialize(entropy, env, entropy_node))
+ {
+ rstr->entropy = entropy;
+ }
+ }
+
+
+ /*LifeTime*/
+ lifetime_qname = axutil_qname_create(env, TRUST_LIFE_TIME, rstr->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(rstr_ele, env, lifetime_qname, rstr_node, &lifetime_node);
+ if(lifetime_ele)
+ {
+ rstr->life_time = trust_life_time_create(env);
+ if(AXIS2_SUCCESS == trust_life_time_deserialize(rstr->life_time, env, lifetime_node))
+ {
+
+ }
+ }
+
+ /* KeySize */
+ key_size_qname = axutil_qname_create(env, TRUST_KEY_SIZE, rstr->wst_ns_uri, TRUST_WST);
+ key_size_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, key_size_qname, rstr_node, &key_size_node);
+ if(key_size_ele)
+ {
+ key_size = axiom_element_get_text(key_size_ele, env, key_size_node);
+ if(key_size)
+ {
+ rstr->key_size = atoi(key_size);
+ }
+ }
+
+ /*FIX :Attached and Unattached References*/
+
+ AXIS2_FREE(env->allocator, lifetime_qname);
+ AXIS2_FREE(env->allocator, entropy_qname);
+ AXIS2_FREE(env->allocator, applies_to_qname);
+ AXIS2_FREE(env->allocator, token_type_qname);
+ AXIS2_FREE(env->allocator, attr_ctx_qname);
+
+
+ return AXIS2_SUCCESS;
+
+}
+
+
+/*Build RSTR */
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_rstr_build_rstr(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axiom_node_t *parent)
+{
+ axiom_node_t *rstr_node = NULL;
+ axis2_char_t *key_size = NULL;
+
+ rstr_node = (axiom_node_t*)trust_util_create_rstr_element(env, rstr->wst_ns_uri, rstr->attr_context);
+
+ if(rstr_node)
+ {
+ if(rstr->token_type)
+ {
+ if(NULL == (axiom_node_t*)trust_util_create_token_type_element(env, rstr->wst_ns_uri, rstr_node, rstr->token_type))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR TokenType element creation failed.");
+ return NULL;
+ }
+ }
+
+ if(rstr->requested_sec_token)
+ {
+ if(NULL == (axiom_node_t*)trust_util_create_requested_security_token_element(env, rstr->wst_ns_uri, rstr_node, rstr->requested_sec_token))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR ReqSecToken element creation failed.");
+ return NULL;
+ }
+
+ }
+
+ if(rstr->requested_proof_token)
+ {
+ /*Appending generic proof token node to RSTR - Here proof token can be just a session key, entropy node with binary secret
+ * Creating the proof token is completely up to the user. Eventhough, there are some default util methods provided by trust_util to create
+ * proof tokens.
+ */
+ axiom_node_add_child(rstr_node, env, rstr->requested_proof_token);
+ }
+
+ if(rstr->applies_to)
+ {
+ if(NULL == (axiom_node_t*)trust_util_create_applies_to_element(env, rstr_node, rstr->applies_to, TRUST_WSA_XMLNS))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR AppliesTo element creation failed.");
+ return NULL;
+ }
+ }
+ if(rstr->requested_attached_ref)
+ {
+ if(NULL == (axiom_node_t*)trust_util_create_req_attached_reference_element(env, rstr->wst_ns_uri, rstr_node));
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR AttachedReference element creation failed.");
+ return NULL;
+ }
+ /* FIX : Attached Ref STR node*/
+
+ }
+ if(rstr->requested_unattached_ref)
+ {
+ if(NULL == (axiom_node_t*)trust_util_create_req_unattached_reference_element(env, rstr->wst_ns_uri, rstr_node))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR UnattachedReference element creation failed.");
+ return NULL;
+ }
+ }
+
+ if(rstr->entropy)
+ {
+ if(NULL == trust_entropy_serialize(rstr->entropy, env, rstr_node))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR Entropy element creation failed.");
+ return NULL;
+ }
+ }
+
+ if(rstr->life_time)
+ {
+ if(NULL == trust_life_time_serialize(rstr->life_time, env, rstr_node))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR LifeTime element creation failed.");
+ return NULL;
+ }
+ }
+
+ if(rstr->key_size > 0)
+ {
+ /*INFO -keysize Malloc Size = 128 */
+ key_size = AXIS2_MALLOC( env->allocator, sizeof(char)*128);
+ sprintf(key_size, "%d", rstr->key_size);
+ if(NULL == (axiom_node_t*)trust_util_create_key_size_element(env, rstr->wst_ns_uri, rstr_node, key_size))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeySize element creation failed.");
+ return NULL;
+ }
+ }
+ return rstr_node;
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_rstr_get_token_type(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->token_type;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_token_type(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axis2_char_t *token_type)
+{
+ if(token_type)
+ {
+ rstr->token_type = token_type;
+
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_rstr_get_request_type(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->request_type;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_request_type(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axis2_char_t *request_type)
+{
+ if(request_type)
+ {
+ rstr->request_type = request_type;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_rstr_get_requested_security_token(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->requested_sec_token;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_requested_security_token(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axiom_node_t *security_token)
+{
+ if (security_token)
+ {
+ rstr->requested_sec_token = security_token;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_rstr_get_applies_to(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->applies_to;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_applies_to(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axis2_char_t *applies_to)
+{
+ if (applies_to)
+ {
+ rstr->applies_to = applies_to;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_rstr_get_requested_attached_reference(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->requested_attached_ref;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_requested_attached_reference(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axiom_node_t *ref_node)
+{
+ if (ref_node)
+ {
+ rstr->requested_attached_ref = ref_node;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_rstr_get_requested_unattached_reference(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->requested_unattached_ref;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_requested_unattached_reference(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axiom_node_t *ref_node)
+{
+ if (ref_node)
+ {
+ rstr->requested_unattached_ref = ref_node;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_rstr_get_requested_proof_token(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->requested_proof_token;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_requested_proof_token(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axiom_node_t *proof_token)
+{
+ if (proof_token)
+ {
+ rstr->requested_proof_token = proof_token;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN trust_entropy_t * AXIS2_CALL
+trust_rstr_get_entropy(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->entropy;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_entropy(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ trust_entropy_t *entropy)
+{
+ if (entropy)
+ {
+ rstr->entropy = entropy;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN trust_life_time_t* AXIS2_CALL
+trust_rstr_get_life_time(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->life_time;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_life_time(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ trust_life_time_t *life_time)
+{
+ if (life_time)
+ {
+ rstr->life_time = life_time;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+trust_rstr_get_in_header(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return rstr->in_header;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_in_header(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axis2_bool_t in_header)
+{
+ rstr->in_header = in_header;
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_rstr_get_wst_ns_uri(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axis2_char_t *wst_ns_uri)
+{
+ return rstr->wst_ns_uri;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_set_wst_ns_uri(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env,
+ axis2_char_t *wst_ns_uri)
+{
+ if(wst_ns_uri)
+ {
+ rstr->wst_ns_uri = wst_ns_uri;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}