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 2007/12/16 15:48:08 UTC
svn commit: r604629 [1/2] - in
/webservices/rampart/scratch/c/trust/c/src/trust: Makefile.am claims.c
context.c entropy.c life_time.c rst.c rstr.c sts_client.c util.c
Author: milinda
Date: Sun Dec 16 06:48:07 2007
New Revision: 604629
URL: http://svn.apache.org/viewvc?rev=604629&view=rev
Log:
modified the trust implementation to increase the flexibility.
Added:
webservices/rampart/scratch/c/trust/c/src/trust/claims.c
webservices/rampart/scratch/c/trust/c/src/trust/entropy.c
webservices/rampart/scratch/c/trust/c/src/trust/life_time.c
webservices/rampart/scratch/c/trust/c/src/trust/rst.c
webservices/rampart/scratch/c/trust/c/src/trust/rstr.c
Modified:
webservices/rampart/scratch/c/trust/c/src/trust/Makefile.am
webservices/rampart/scratch/c/trust/c/src/trust/context.c
webservices/rampart/scratch/c/trust/c/src/trust/sts_client.c
webservices/rampart/scratch/c/trust/c/src/trust/util.c
Modified: webservices/rampart/scratch/c/trust/c/src/trust/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/c/src/trust/Makefile.am?rev=604629&r1=604628&r2=604629&view=diff
==============================================================================
--- webservices/rampart/scratch/c/trust/c/src/trust/Makefile.am (original)
+++ webservices/rampart/scratch/c/trust/c/src/trust/Makefile.am Sun Dec 16 06:48:07 2007
@@ -1,10 +1,15 @@
lib_LTLIBRARIES = libtrust.la
libtrust_la_SOURCES = context.c \
- util.c \
- sts_client.c \
- policy_util.c \
- token.c
+ claims.c \
+ entropy.c \
+ life_time.c \
+ rst.c \
+ rstr.c \
+ util.c \
+ sts_client.c \
+ policy_util.c \
+ token.c
INCLUDES = -I$(top_builddir)/include \
-I ../../../../util/include \
Added: webservices/rampart/scratch/c/trust/c/src/trust/claims.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/c/src/trust/claims.c?rev=604629&view=auto
==============================================================================
--- webservices/rampart/scratch/c/trust/c/src/trust/claims.c (added)
+++ webservices/rampart/scratch/c/trust/c/src/trust/claims.c Sun Dec 16 06:48:07 2007
@@ -0,0 +1,186 @@
+/*
+ * 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_claims.h>
+
+struct trust_claims
+{
+ axiom_children_iterator_t *children;
+ axis2_char_t *attr_dialect;
+ axis2_char_t *wst_ns_uri;
+
+};
+
+AXIS2_EXTERN trust_claims_t * AXIS2_CALL
+trust_claims_create(
+ const axutil_env_t *env)
+{
+ trust_claims_t *claims = NULL;
+
+ claims = (trust_claims_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_claims_t));
+ claims->attr_dialect = NULL;
+ claims->wst_ns_uri = NULL;
+
+ return claims;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_claims_free(
+ trust_claims_t *claims,
+ const axutil_env_t *env)
+{
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_claims_deserialize(
+ trust_claims_t *claims,
+ const axutil_env_t *env,
+ axiom_node_t *claims_node)
+{
+ axiom_element_t *claims_ele = NULL;
+ axiom_children_iterator_t *children = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+ axis2_char_t *dialect_attr = NULL;
+
+ claims_ele = axiom_node_get_data_element(claims_node, env);
+
+ if(claims_ele)
+ {
+ children = axiom_element_get_children(claims_ele, env, claims_node);
+ if(children)
+ {
+ if(trust_claims_set_children(claims, env, children))
+ status = AXIS2_SUCCESS;
+ }
+
+ dialect_attr = axiom_element_get_attribute_value_by_name(claims_ele, env, TRUST_CLAIMS_DIALECT);
+ if(dialect_attr)
+ {
+ if(status && trust_claims_set_attr_dialect(claims, env, dialect_attr))
+ {
+ return AXIS2_SUCCESS;
+ }
+ }
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+trust_claims_serialize(
+ trust_claims_t *claims,
+ const axutil_env_t *env,
+ axiom_node_t *parent)
+{
+ axiom_node_t *claims_node = NULL;
+ axiom_node_t *child = NULL;
+
+ claims_node = (axiom_node_t*)trust_util_create_claims_element(env, claims->wst_ns_uri, parent, claims->attr_dialect);
+ if(!claims_node)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims Element creation failed!");
+ return NULL;
+ }
+
+ while(axiom_children_iterator_has_next(claims->children, env))
+ {
+ child = axiom_children_iterator_next(claims->children, env);
+ if(child)
+ {
+ if(!axiom_node_add_child(claims_node, env, child))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims node adding child failed!");
+ return NULL;
+ }
+ }
+
+ }
+
+ return claims_node;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_claims_set_children(
+ trust_claims_t *claims,
+ const axutil_env_t *env,
+ axiom_children_iterator_t *children)
+{
+ if(children)
+ {
+ claims->children = children;
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_children_iterator_t * AXIS2_CALL
+trust_claims_get_children(
+ trust_claims_t *claims,
+ const axutil_env_t *env)
+{
+ return claims->children;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_claims_set_attr_dialect(
+ trust_claims_t *claims,
+ const axutil_env_t *env,
+ axis2_char_t *dialect_attr)
+{
+ if(dialect_attr)
+ {
+ claims->attr_dialect = dialect_attr;
+
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+trust_claims_get_attr_dialect(
+ trust_claims_t *claims,
+ const axutil_env_t *env)
+{
+ return claims->attr_dialect;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_claims_set_wst_ns_uri(
+ trust_claims_t *claims,
+ const axutil_env_t *env,
+ axis2_char_t *wst_ns_uri)
+{
+ if(wst_ns_uri)
+ {
+ claims->wst_ns_uri = wst_ns_uri;
+
+ return AXIS2_SUCCESS;
+ }
+
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+trust_claims_get_wst_ns_uri(
+ trust_claims_t *claims,
+ const axutil_env_t *env)
+{
+ return claims->wst_ns_uri;
+}
Modified: webservices/rampart/scratch/c/trust/c/src/trust/context.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/c/src/trust/context.c?rev=604629&r1=604628&r2=604629&view=diff
==============================================================================
--- webservices/rampart/scratch/c/trust/c/src/trust/context.c (original)
+++ webservices/rampart/scratch/c/trust/c/src/trust/context.c Sun Dec 16 06:48:07 2007
@@ -18,586 +18,261 @@
struct trust_context
{
- /* in message context of STS */
- axis2_msg_ctx_t *in_msg_ctx;
+ axis2_char_t *wst_namespace;
+ axis2_char_t *soap_namespace;
+
+ /*RST Context*/
+ trust_rst_t *rst;
- /* Axiom node which holds payload of RST message */
+ /*RSTR Context*/
+ trust_rstr_t *rstr;
+
+
+ /*To store the built RST node*/
axiom_node_t *rst_node;
+
+ /*To store the built RSTR node*/
+ axiom_node_t *rstr_node;
+
+ /*Extensible - Other Contexts Related to Trust */
+
+
+};
- /** Request Type
- * e.g. wsse:ReqIssue/Validate/Renew etc
- */
- axis2_char_t *request_type;
-
- /** Required Token Type
- * e.g. wsse:X509v3
- */
- axis2_char_t *token_type;
-
- /*optional element specifies the scope for which this security token is desired */
- axiom_node_t *applies_to_epr_node;
-
- axis2_char_t *applies_to_address;
-
- /** RST Context attribute
- * This optional URI specifies an identifier/context for this request
- */
- axis2_char_t *rst_context_attr;
-
- /* KeyType element of the RST */
- axis2_char_t *key_type;
-
- int key_size;
-
- axis2_char_t *request_entropy;
-
- axis2_char_t *response_entropy;
-
- /*optional element for specific set of requested claims */
- axiom_node_t *claims_node;
-
- /**wst:RequestSecurityToken/wst:Claims@Dialect
- *Attribute specifies a URI to indicate the syntax of the claims
- */
- axis2_char_t *claims_dialect;
- /* SOAP Namespace */
- axis2_char_t *soap_namespace;
+AXIS2_EXTERN trust_context_t *AXIS2_CALL
+trust_context_create(
+ const axutil_env_t * env)
+{
+ trust_context_t *trust_context = NULL;
+
+ trust_context = (trust_context_t *) AXIS2_MALLOC(env->allocator, sizeof(trust_context_t));
+
+ trust_context->rst = NULL;
+ trust_context->rstr = NULL;
+ trust_context->rst_node = NULL;
+ trust_context->rstr_node = NULL;
+
+ return trust_context;
+}
- /* WS-Trust Namespace */
- axis2_char_t *wst_namespace;
+/*Free Contexts*/
+AXIS2_EXTERN void AXIS2_CALL
+trust_context_free(
+ const axutil_env_t * env,
+ trust_context_t *trust_context)
+{
+ if (trust_context)
+ {
+ /*Free Other Contexts*/
+ AXIS2_FREE(env->allocator, trust_context);
+ }
+}
- /*Addressing NS */
- axis2_char_t *addressing_namespace;
-};
-AXIS2_EXTERN trust_context_t *AXIS2_CALL
-trust_context_create(
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_context_process_rst(
const axutil_env_t * env,
+ trust_context_t *trust_context,
axis2_msg_ctx_t * in_msg_ctx)
-{
+{
axiom_soap_envelope_t *soap_env = NULL;
axiom_soap_body_t *soap_body = NULL;
axiom_namespace_t *soap_ns = NULL;
axiom_namespace_t *wst_ns = NULL;
axiom_node_t *body_base_node = NULL;
axiom_element_t *rst_ele = NULL;
-
- trust_context_t *trust_context = NULL;
- trust_context = (trust_context_t *) AXIS2_MALLOC(env->allocator, sizeof(trust_context_t));
-
+ int trust_version = -1;
+
/* Processing Message Context*/
soap_env = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env);
soap_body = axiom_soap_envelope_get_body(soap_env, env);
body_base_node = axiom_soap_body_get_base_node(soap_body, env);
trust_context->rst_node = axiom_node_get_first_child(body_base_node, env);
-
- /* rocessing SOAP Namespace */
+
+ /* Processing SOAP Namespace */
soap_ns = axiom_soap_envelope_get_namespace(soap_env, env);
trust_context->soap_namespace = axiom_namespace_get_uri(soap_ns, env);
-
- /* Processing WS-Trust namespace*/
+
+ /* Processing WS-Trust namespace*/
rst_ele = (axiom_element_t *) axiom_node_get_data_element(trust_context->rst_node, env);
wst_ns = axiom_element_get_namespace(rst_ele, env, trust_context->rst_node);
trust_context->wst_namespace = axiom_namespace_get_uri(wst_ns, env);
- trust_context_process_request_context(trust_context, env);
- trust_context_process_request_type(trust_context, env);
- trust_context_process_token_type(trust_context, env);
- trust_context_process_applies_to(trust_context, env);
- trust_context_process_claims(trust_context, env);
- trust_context_process_entropy(trust_context, env);
- trust_context_process_key_type(trust_context, env);
- trust_context_process_key_size(trust_context, env);
-
- return trust_context;
-}
-
-AXIS2_EXTERN void AXIS2_CALL
-trust_context_free(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- if (trust_context)
- {
- AXIS2_FREE(env->allocator, trust_context);
- }
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_applies_to(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- axutil_qname_t *applies_to_qname = NULL;
- axutil_qname_t *addr_qname = NULL;
- axiom_node_t *appliesto_node = NULL;
- axiom_node_t *rst_node = NULL;
- axiom_node_t *epr_node = NULL;
- axiom_node_t *addr_node = NULL;
- axiom_element_t *appliesto_ele = NULL;
- axiom_element_t *rst_ele = NULL;
- axiom_element_t *epr_ele = NULL;
- axiom_element_t *addr_ele = NULL;
- axiom_namespace_t *addr_namespace = NULL;
-
-
- rst_node = trust_context->rst_node;
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(rst_node, env));
-
- applies_to_qname = axutil_qname_create(env, TRUST_APPLIES_TO, TRUST_WSP_XMLNS, TRUST_WSP);
-
- appliesto_ele =
- axiom_element_get_first_child_with_qname(rst_ele, env, applies_to_qname, rst_node,
- &appliesto_node);
- if (appliesto_ele)
+ if(0 == axutil_strcmp(trust_context->wst_namespace, TRUST_WST_XMLNS_05_02))
{
- epr_ele = axiom_element_get_first_element(appliesto_ele, env, appliesto_node, &epr_node);
-
- trust_context->applies_to_epr_node = epr_node;
-
- if (!trust_context->addressing_namespace)
- {
- addr_namespace = axiom_element_find_namespace(epr_ele, env, epr_node, "http://schemas.xmlsoap.org/ws/2004/08/addressing", NULL);
- if(!addr_namespace)
- {
- addr_namespace = axiom_element_find_namespace(epr_ele, env, epr_node, "http://www.w3.org/2005/08/addressing", NULL);
- }
- if(addr_namespace)
- {
- trust_context->addressing_namespace = axiom_namespace_get_uri(addr_namespace, env);
- }
- }
-
- if (epr_ele && addr_namespace)
- {
- addr_qname =
- axutil_qname_create(env, EPR_ADDRESS, trust_context->addressing_namespace, NULL);
- addr_ele =
- axiom_element_get_first_child_with_qname(epr_ele, env, addr_qname, epr_node,
- &addr_node);
- if (addr_ele && axiom_element_get_text(addr_ele, env, addr_node))
- {
- trust_context->applies_to_address = axiom_element_get_text(addr_ele, env, addr_node);
- }
- }
- else
- {
- AXIS2_FREE(env->allocator, applies_to_qname);
- return AXIS2_FAILURE;
- }
-
+ trust_version = 1;
}
- else
+ if(0 == axutil_strcmp(trust_context->wst_namespace, TRUST_WST_XMLNS_05_12))
{
- AXIS2_FREE(env->allocator, applies_to_qname);
- return AXIS2_FAILURE;
+ trust_version = 2;
}
- AXIS2_FREE(env->allocator, applies_to_qname);
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_request_context(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- axiom_element_t *rst_ele = NULL;
- axutil_qname_t *attr_ctx_qname = NULL;
- axis2_char_t *context = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- attr_ctx_qname = axutil_qname_create(env, TRUST_RST_CONTEXT, TRUST_WST_XMLNS, TRUST_WST);
- if (!attr_ctx_qname)
- return AXIS2_FAILURE;
-
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(trust_context->rst_node, env));
- context = axiom_element_get_attribute_value(rst_ele, env, attr_ctx_qname);
-
- if (context)
- {
- trust_context->rst_context_attr = context;
- AXIS2_FREE(env->allocator, attr_ctx_qname);
- return AXIS2_SUCCESS;
- }
- AXIS2_FREE(env->allocator, attr_ctx_qname);
- return AXIS2_FAILURE;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_request_type(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- axiom_element_t *req_type_ele = NULL;
- axiom_element_t *rst_ele = NULL;
- axiom_node_t *rst_node = NULL;
- axiom_node_t *req_type_node = NULL;
- axutil_qname_t *req_type_qname = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- rst_node = trust_context->rst_node;
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(rst_node, env));
-
- req_type_qname =
- axutil_qname_create(env, TRUST_REQUEST_TYPE, trust_context->wst_namespace, TRUST_WST);
-
- 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)
- {
- AXIS2_FREE(env->allocator, req_type_qname);
- return AXIS2_FAILURE;
- }
-
- trust_context->request_type = axiom_element_get_text(req_type_ele, env, req_type_node);
-
- AXIS2_FREE(env->allocator, req_type_qname);
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_token_type(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- axiom_node_t *token_type_node = NULL;
- axiom_element_t *token_type_ele = NULL;
- axiom_element_t *rst_ele = NULL;
- axutil_qname_t *token_type_qname = NULL;
-
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(trust_context->rst_node, env));
-
- token_type_qname =
- axutil_qname_create(env, TRUST_TOKEN_TYPE, trust_context->wst_namespace, TRUST_WST);
-
- token_type_ele =
- axiom_element_get_first_child_with_qname(rst_ele, env, token_type_qname,
- trust_context->rst_node, &token_type_node);
- if (!token_type_ele)
+
+ if(trust_version != -1)
{
- AXIS2_FREE(env->allocator, token_type_qname);
- return AXIS2_FAILURE;
+ trust_context->rst = trust_rst_create(trust_version, env);
+ if(AXIS2_SUCCESS == trust_rst_populate_rst(trust_context->rst, env, trust_context->rst_node))
+ {
+ return AXIS2_SUCCESS;
+ }
}
-
- trust_context->token_type = axiom_element_get_text(token_type_ele, env, token_type_node);
-
- AXIS2_FREE(env->allocator, token_type_qname);
- return AXIS2_SUCCESS;
+
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Invalid WST Version in RST message");
+ return AXIS2_FAILURE;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_claims(
- trust_context_t * trust_context,
- const axutil_env_t * env)
+trust_context_process_rstr(
+ const axutil_env_t * env,
+ trust_context_t *trust_context,
+ axis2_msg_ctx_t * in_msg_ctx)
{
- axiom_node_t *claims_node = NULL;
- axiom_element_t *claims_ele = NULL;
- axiom_element_t *rst_ele = NULL;
- axutil_qname_t *claims_qname = NULL;
- axutil_qname_t *attr_dialect_qname = NULL;
- axis2_char_t *dialect = NULL;
+ axiom_soap_envelope_t *soap_env = NULL;
+ axiom_soap_body_t *soap_body = NULL;
+ axiom_namespace_t *soap_ns = NULL;
+ axiom_namespace_t *wst_ns = NULL;
+ axiom_node_t *body_base_node = NULL;
+ axiom_element_t *rstr_ele = NULL;
+ int trust_version = -1;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ /* Processing Message Context*/
+ soap_env = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env);
+ soap_body = axiom_soap_envelope_get_body(soap_env, env);
+ body_base_node = axiom_soap_body_get_base_node(soap_body, env);
+ trust_context->rst_node = axiom_node_get_first_child(body_base_node, env);
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(trust_context->rst_node, env));
+ /* Processing SOAP Namespace */
+ soap_ns = axiom_soap_envelope_get_namespace(soap_env, env);
+ trust_context->soap_namespace = axiom_namespace_get_uri(soap_ns, env);
- claims_qname = axutil_qname_create(env, TRUST_CLAIMS, trust_context->wst_namespace, TRUST_WST);
+ rstr_ele = (axiom_element_t *) axiom_node_get_data_element(trust_context->rstr_node, env);
+ wst_ns = axiom_element_get_namespace(rstr_ele, env, trust_context->rstr_node);
+ trust_context->wst_namespace = axiom_namespace_get_uri(wst_ns, env);
- claims_ele =
- axiom_element_get_first_child_with_qname(rst_ele, env, claims_qname, trust_context->rst_node,
- &claims_node);
- if (!claims_ele)
+ if(0 == axutil_strcmp(trust_context->wst_namespace, TRUST_WST_XMLNS_05_02))
{
- AXIS2_FREE(env->allocator, claims_qname);
- return AXIS2_FAILURE;
+ trust_version = 1;
}
-
- trust_context->claims_node = claims_node;
-
- attr_dialect_qname =
- axutil_qname_create(env, TRUST_CLAIMS_DIALECT, trust_context->wst_namespace, TRUST_WST);
- if (!attr_dialect_qname)
+ if(0 == axutil_strcmp(trust_context->wst_namespace, TRUST_WST_XMLNS_05_12))
{
- AXIS2_FREE(env->allocator, claims_qname);
- return AXIS2_FAILURE;
+ trust_version = 2;
}
-
- dialect = axiom_element_get_attribute_value(claims_ele, env, attr_dialect_qname);
-
- if (!dialect)
+
+ if(trust_version != -1)
{
- AXIS2_FREE(env->allocator, claims_qname);
- AXIS2_FREE(env->allocator, attr_dialect_qname);
- return AXIS2_FAILURE;
+ trust_context->rstr = trust_rstr_create(trust_version, env);
+ if(AXIS2_SUCCESS == trust_rstr_populate_rstr(trust_context->rstr, env, trust_context->rstr_node))
+ {
+ return AXIS2_SUCCESS;
+ }
}
- trust_context->claims_dialect = dialect;
+
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Invalid WST Version in RSTR message");
+ return AXIS2_FAILURE;
- AXIS2_FREE(env->allocator, claims_qname);
- AXIS2_FREE(env->allocator, attr_dialect_qname);
- return AXIS2_SUCCESS;
}
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_entropy(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- /* TO DO: Complete the entropy processing */
- axiom_node_t *entropy_node = NULL;
- axiom_node_t *binary_secret_node = NULL;
- axiom_element_t *entropy_ele = NULL;
- axiom_element_t *rst_ele = NULL;
- axiom_element_t *binary_secret_ele = NULL;
- axutil_qname_t *entropy_qname = NULL;
- axis2_char_t *bin_sec_str = NULL;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(trust_context->rst_node, env));
-
- entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, trust_context->wst_namespace, TRUST_WST);
-
- entropy_ele =
- axiom_element_get_first_child_with_qname(rst_ele, env, entropy_qname, trust_context->rst_node,
- &entropy_node);
- if (!entropy_ele)
- {
- AXIS2_FREE(env->allocator, entropy_qname);
- return AXIS2_FAILURE;
- }
-
- binary_secret_ele =
- axiom_element_get_first_element(entropy_ele, env, entropy_node, &binary_secret_node);
- bin_sec_str = axiom_element_get_text(binary_secret_ele, env, binary_secret_node);
-
- if (binary_secret_ele && bin_sec_str && (axutil_strcmp("", bin_sec_str) != 0))
- {
- /*axutil_base64_decode(trust_context->request_entropy, bin_sec_str);*/
- trust_context->request_entropy = bin_sec_str;
- }
- else
- {
- AXIS2_FREE(env->allocator, entropy_qname);
- return AXIS2_FAILURE;
- }
-
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_key_type(
- trust_context_t * data,
- const axutil_env_t * env)
+/*Build RST Node from created RST_CONTEXT */
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
+trust_context_build_rst_node(
+ const axutil_env_t * env,
+ trust_context_t *trust_context)
{
- axiom_node_t *key_type_node = NULL;
- axiom_element_t *key_type_ele = NULL;
- axiom_element_t *rst_ele = NULL;
- axutil_qname_t *key_type_qname = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ if(trust_context->rst)
+ {
+ trust_context->rst_node = trust_rst_build_rst(trust_context->rst, env, NULL);
+ if(trust_context->rst_node)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Node Not NULL");
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Node -- NULL");
+ }
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(data->rst_node, env));
-
- key_type_qname = axutil_qname_create(env, TRUST_KEY_TYPE, data->wst_namespace, TRUST_WST);
-
- key_type_ele =
- axiom_element_get_first_child_with_qname(rst_ele, env, key_type_qname, data->rst_node,
- &key_type_node);
- if (!key_type_ele)
- {
- AXIS2_FREE(env->allocator, key_type_qname);
- return AXIS2_FAILURE;
+ return trust_context->rst_node;
}
-
- data->key_type = axiom_element_get_text(key_type_ele, env, key_type_node);
-
- AXIS2_FREE(env->allocator, key_type_qname);
- return AXIS2_SUCCESS;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RST_OM -> RST node FAILED:RST_OM NULL");
+ return NULL;
}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_process_key_size(
- trust_context_t * data,
- const axutil_env_t * env)
+
+/*Build RSTR Node from created RSTR_CONTEXT */
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
+trust_context_build_rstr_node(
+ const axutil_env_t * env,
+ trust_context_t *trust_context)
{
- axiom_node_t *key_size_node = NULL;
- axiom_element_t *key_size_ele = NULL;
- axiom_element_t *rst_ele = NULL;
- axutil_qname_t *key_size_qname = NULL;
- axis2_char_t *size_str = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- rst_ele = (axiom_element_t *) (axiom_node_get_data_element(data->rst_node, env));
-
- key_size_qname = axutil_qname_create(env, TRUST_KEY_SIZE, data->wst_namespace, TRUST_WST);
-
- key_size_ele =
- axiom_element_get_first_child_with_qname(rst_ele, env, key_size_qname, data->rst_node,
- &key_size_node);
- if (!key_size_ele)
+ if(trust_context->rstr)
{
- AXIS2_FREE(env->allocator, key_size_qname);
- return AXIS2_FAILURE;
+ trust_context->rstr_node = trust_rstr_build_rstr(trust_context->rstr, env, NULL);
+ return trust_context->rstr_node;
}
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR_OM -> RSTR node FAILED:RSTR_OM NULL");
+ return NULL;
- size_str = axiom_element_get_text(key_size_ele, env, key_size_node);
-
- if (!size_str)
- {
- AXIS2_FREE(env->allocator, key_size_qname);
- return AXIS2_FAILURE;
- }
-
- data->key_size = atoi(size_str);
- AXIS2_FREE(env->allocator, key_size_qname);
- return AXIS2_SUCCESS;
}
-
-AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-trust_context_get_request_type(
- trust_context_t * trust_context,
- const axutil_env_t * env)
+
+
+/*Get Populated RST_CONTEXT */
+AXIS2_EXTERN trust_rst_t* AXIS2_CALL
+trust_context_get_rst(
+ const axutil_env_t * env,
+ trust_context_t *trust_context)
{
- return trust_context->request_type;
+ if(trust_context)
+ return trust_context->rst;
+ return NULL;
}
-
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_set_request_type(
- trust_context_t * trust_context,
- const axutil_env_t * env,
- axis2_char_t *request_type)
+
+/*Get Populated RSTR_CONTEXT */
+AXIS2_EXTERN trust_rstr_t* AXIS2_CALL
+ trust_context_get_rstr(
+ const axutil_env_t * env,
+ trust_context_t *trust_context)
{
- if(request_type)
+ if(trust_context)
{
- trust_context->request_type = request_type;
- return AXIS2_SUCCESS;
+ return trust_context->rstr;
}
-
- return AXIS2_FAILURE;
-}
-
-AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-trust_context_get_token_type(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- return trust_context->token_type;
+ return NULL;
}
-
+
+/*Set RST_CONTEXT */
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_set_token_type(
- trust_context_t * trust_context,
+trust_context_set_rst(
const axutil_env_t * env,
- axis2_char_t *token_type)
+ trust_context_t *trust_context,
+ trust_rst_t *rst)
{
- if(token_type)
+ if(trust_context)
{
- trust_context->token_type = token_type;
+ trust_context->rst = rst;
return AXIS2_SUCCESS;
}
return AXIS2_FAILURE;
-}
-AXIS2_EXTERN axiom_node_t * AXIS2_CALL
-trust_context_get_rst_node(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- return trust_context->rst_node;
}
-
+
+/*Set RSTR_CONTEXT */
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-trust_context_set_rst_node(
- trust_context_t * trust_context,
- const axutil_env_t * env,
- axiom_node_t *rst_node)
+trust_context_set_rstr(
+ const axutil_env_t * env,
+ trust_context_t *trust_context,
+ trust_rstr_t *rstr)
{
- if(rst_node)
+ if(trust_context)
{
- trust_context->rst_node = rst_node;
+ trust_context->rstr = rstr;
return AXIS2_SUCCESS;
}
-
return AXIS2_FAILURE;
}
-AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-trust_context_get_wst_ns(
- trust_context_t * trust_context,
- const axutil_env_t * env)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- return trust_context->wst_namespace;
-}
-
-AXIS2_EXTERN axis2_char_t * AXIS2_CALL
-trust_context_get_appliesto_address(
- trust_context_t *trust_context,
- const axutil_env_t *env)
-{
- return trust_context->applies_to_address;
-}
-
-AXIS2_EXTERN axiom_node_t * AXIS2_CALL
-trust_context_get_appliesto_epr_node(
- trust_context_t *trust_context,
- const axutil_env_t *env)
-{
- return trust_context->applies_to_epr_node;
-}
-
-AXIS2_EXTERN axis2_char_t * AXIS2_CALL
-trust_context_get_rst_context_attr(
- trust_context_t *trust_context,
- const axutil_env_t *env)
-{
- return trust_context->rst_context_attr;
-}
-AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-trust_context_get_key_type(
- trust_context_t *trust_context,
- const axutil_env_t *env)
-{
- return trust_context->key_type;
-}
-AXIS2_EXTERN int AXIS2_CALL
-trust_context_get_key_size(
- trust_context_t *trust_context,
- const axutil_env_t *env)
-{
- return trust_context->key_size;
-}
-AXIS2_EXTERN axis2_char_t * AXIS2_CALL
-trust_context_get_request_entropy(
- trust_context_t *trust_context,
- const axutil_env_t *env)
-{
- return trust_context->request_entropy;
-}
-AXIS2_EXTERN axiom_node_t * AXIS2_CALL
-trust_context_get_claims_node(
- trust_context_t *trust_context,
- const axutil_env_t *env)
-{
- return trust_context->claims_node;
-}
-
-AXIS2_EXTERN axis2_char_t * AXIS2_CALL
-trust_context_get_claims_dialect(
- trust_context_t * trust_context,
- const axutil_env_t *env)
-{
- return trust_context->claims_dialect;
-}
Added: webservices/rampart/scratch/c/trust/c/src/trust/entropy.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/c/src/trust/entropy.c?rev=604629&view=auto
==============================================================================
--- webservices/rampart/scratch/c/trust/c/src/trust/entropy.c (added)
+++ webservices/rampart/scratch/c/trust/c/src/trust/entropy.c Sun Dec 16 06:48:07 2007
@@ -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/scratch/c/trust/c/src/trust/life_time.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/c/src/trust/life_time.c?rev=604629&view=auto
==============================================================================
--- webservices/rampart/scratch/c/trust/c/src/trust/life_time.c (added)
+++ webservices/rampart/scratch/c/trust/c/src/trust/life_time.c Sun Dec 16 06:48:07 2007
@@ -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;
+}
Added: webservices/rampart/scratch/c/trust/c/src/trust/rst.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/c/src/trust/rst.c?rev=604629&view=auto
==============================================================================
--- webservices/rampart/scratch/c/trust/c/src/trust/rst.c (added)
+++ webservices/rampart/scratch/c/trust/c/src/trust/rst.c Sun Dec 16 06:48:07 2007
@@ -0,0 +1,712 @@
+/*
+ * 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_char_t *key_type;
+
+ int key_size;
+
+ 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;
+
+ int trust_version;
+
+ trust_life_time_t *life_time;
+
+ /*ToDo : Federation - Trust Extensions
+ * - Authorization : AdditionalContext and CommonClaim Dialect
+ * - Prefix:auth
+ */
+
+};
+
+AXIS2_EXTERN trust_rst_t * AXIS2_CALL
+trust_rst_create(
+ int trust_version,
+ 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->trust_version = trust_version;
+ switch (trust_version)
+ {
+ case TRUST_VERSION_05_02:
+ rst->wst_ns_uri = axutil_strdup(env, TRUST_WST_XMLNS_05_02);
+ case TRUST_VERSION_05_12:
+ rst->wst_ns_uri = axutil_strdup(env, TRUST_WST_XMLNS_05_12);
+ default:
+ {
+ /*If anything goes wrong the default wst namespace is set : WST_05_02 */
+ rst->trust_version = 1;
+ rst->wst_ns_uri = axutil_strdup(env, TRUST_WST_XMLNS_05_02);
+ }
+
+ }
+
+ rst->life_time = 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_node_t *rst_node = NULL;*/
+ 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;
+
+
+ /*ToBe Fixed with the use of in_message_context ----------*/
+ /*soap_env = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env);
+ soap_body = axiom_soap_envelope_get_body(soap_env, env);
+ body_base_node = axiom_soap_body_get_base_node(soap_body, env);
+
+ rst_node = axiom_node_get_first_child(body_base_node, env);*/
+
+ 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;
+ }
+ }
+
+
+ /* 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);
+ }
+ }
+
+ 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);
+
+ /*Free Intermediate Objects.. */
+
+ 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->trust_version, parent, 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->trust_version, 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->trust_version, 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->trust_version, rst_node, key_size))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeySize 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_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/scratch/c/trust/c/src/trust/rstr.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/c/src/trust/rstr.c?rev=604629&view=auto
==============================================================================
--- webservices/rampart/scratch/c/trust/c/src/trust/rstr.c (added)
+++ webservices/rampart/scratch/c/trust/c/src/trust/rstr.c Sun Dec 16 06:48:07 2007
@@ -0,0 +1,589 @@
+/*
+ * 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;
+
+ /*Trsut Version */
+ int trust_version;
+
+ 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(
+ int trust_version,
+ 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->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->trust_version = trust_version;
+ switch (trust_version)
+ {
+ case TRUST_VERSION_05_02:
+ rstr->wst_ns_uri = axutil_strdup(env, TRUST_WST_XMLNS_05_02);
+ case TRUST_VERSION_05_12:
+ rstr->wst_ns_uri = axutil_strdup(env, TRUST_WST_XMLNS_05_12);
+ default:
+ { /*If anything goes wrong the default wst namespace is set : WST_05_02 */
+ rstr->trust_version = 1;
+ rstr->wst_ns_uri = axutil_strdup(env, TRUST_WST_XMLNS_05_02);
+ }
+ }
+
+ return rstr;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+trust_rstr_free(
+ trust_rstr_t *rstr,
+ const axutil_env_t *env)
+{
+ return AXIS2_SUCCESS;
+}
+
+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 *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);
+ }
+
+ /*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;
+
+}
+
+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->trust_version, rstr->attr_context);
+
+ if(rstr_node)
+ {
+ if(rstr->token_type)
+ {
+ if(NULL == (axiom_node_t*)trust_util_create_token_type_element(env, rstr->trust_version, 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->trust_version, rstr_node, rstr->requested_sec_token))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR ReqSecToken element creation failed.");
+ return NULL;
+ }
+
+ }
+ 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->trust_version, 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->trust_version, 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->trust_version, 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;
+}
+
+