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/10/27 07:57:25 UTC
svn commit: r589051 - in /webservices/rampart/scratch/c/trust/src: data.c
sts/sts.c sts_client.c util.c
Author: milinda
Date: Fri Oct 26 22:57:24 2007
New Revision: 589051
URL: http://svn.apache.org/viewvc?rev=589051&view=rev
Log:
Add new features and complete most parts of sts client.
Modified:
webservices/rampart/scratch/c/trust/src/data.c
webservices/rampart/scratch/c/trust/src/sts/sts.c
webservices/rampart/scratch/c/trust/src/sts_client.c
webservices/rampart/scratch/c/trust/src/util.c
Modified: webservices/rampart/scratch/c/trust/src/data.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/src/data.c?rev=589051&r1=589050&r2=589051&view=diff
==============================================================================
--- webservices/rampart/scratch/c/trust/src/data.c (original)
+++ webservices/rampart/scratch/c/trust/src/data.c Fri Oct 26 22:57:24 2007
@@ -16,7 +16,8 @@
*/
#include <trust_data.h>
-struct trust_data {
+struct trust_data
+{
/* in message context of STS */
axis2_msg_ctx_t *in_msg_ctx;
@@ -26,14 +27,14 @@
/** Request Type
* e.g. wsse:ReqIssue/Validate/Renew etc
*/
- axis2_char_t *request_type;
+ 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*/
+ /*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;
@@ -41,14 +42,18 @@
/** RST Context attribute
* This optional URI specifies an identifier/context for this request
*/
- axis2_char_t *rst_context_attr;
+ axis2_char_t *rst_context_attr;
/* KeyType element of the RST */
- axis2_char_t *key_type;
+ axis2_char_t *key_type;
int key_size;
- /*optional element for specific set of requested claims*/
+ 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
@@ -56,57 +61,74 @@
*/
axis2_char_t *claims_dialect;
+ /* SOAP Namespace */
+ axis2_char_t *soap_namespace;
+
/* WS-Trust Namespace */
axis2_char_t *wst_namespace;
/*Addressing NS */
- axis2_char_t *addressing_namespace;
+ axis2_char_t *addressing_namespace;
};
-AXIS2_EXPORT trust_data_t* AXIS2_CALL trust_data_create(
- const axutil_env_t *env,
- axiom_node_t *payload)
-{
+AXIS2_EXPORT trust_data_t *AXIS2_CALL
+trust_data_create(
+ const axutil_env_t * env,
+ 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_element_t *rst_ele = NULL;
+ trust_data_t *trust_data = NULL;
+ trust_data = (trust_data_t *) AXIS2_MALLOC(env->allocator, sizeof(trust_data_t));
+ // 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);
+ trust_data->rst_node = axiom_soap_body_get_base_node(soap_body, env);
+
+ // Processing SOAP Namespace
+ soap_ns = axiom_soap_envelope_get_namespace(soap_env, env);
+ trust_data->soap_namespace = axiom_namespace_get_uri(soap_ns, env);
- trust_data_t *trust_data = (trust_data_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_data_t));
-
- trust_data->rst_node = payload;
-
-
-
- /* Processing WS-Trust namespace */
- rst_ele = (axiom_element_t *)axiom_node_get_data_element(trust_data->rst_node, env);
+ // Processing WS-Trust namespace
+ rst_ele = (axiom_element_t *) axiom_node_get_data_element(trust_data->rst_node, env);
wst_ns = axiom_element_get_namespace(rst_ele, env, trust_data->rst_node);
- trust_data->wst_namespace = axiom_namespace_get_uri(wst_ns, env);
+ trust_data->wst_namespace = axiom_namespace_get_uri(wst_ns, env);
+ trust_data_process_request_context(trust_data, env);
trust_data_process_request_type(trust_data, env);
trust_data_process_token_type(trust_data, env);
+ trust_data_process_applies_to(trust_data, env);
+ trust_data_process_claims(trust_data, env);
+ trust_data_process_entorpy(trust_data, env);
+ trust_data_process_key_type(trust_data, env);
+ trust_data_process_key_size(trust_data, env);
- /* TODO: Process other fields */
- /* TODO: Addressing namespace processing */
return trust_data;
}
-AXIS2_EXPORT void AXIS2_CALL trust_data_free(
- trust_data_t *trust_data,
- const axutil_env_t *env)
+AXIS2_EXPORT void AXIS2_CALL
+trust_data_free(
+ trust_data_t * trust_data,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- if(trust_data)
+ if (trust_data)
{
AXIS2_FREE(env->allocator, trust_data);
}
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_applies_to(
- trust_data_t *trust_data,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_applies_to(
+ trust_data_t * trust_data,
+ const axutil_env_t * env)
{
axutil_qname_t *applies_to_qname = NULL;
axutil_qname_t *addr_qname = NULL;
@@ -123,222 +145,266 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
rst_node = trust_data->rst_node;
- rst_ele = (axiom_element_t *)(axiom_node_get_data_element(rst_node, env));
+ 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)
- {
- epr_ele = axiom_element_get_first_element(appliesto_ele, env, appliesto_node, &epr_node);
- trust_data->applies_to_epr_node = epr_node;
-
- if(!trust_data->addressing_namespace)
- {
- addr_namespace = axiom_element_get_default_namespace(epr_ele, env, epr_node);
- trust_data->addressing_namespace = axiom_namespace_get_uri(addr_namespace, env);
- }
-
- if(epr_ele)
- {
- addr_qname = axutil_qname_create(env, EPR_ADDRESS, trust_data->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_data->applies_to_address = axiom_element_get_text(addr_ele, env, addr_node);
- }
- }else
- {
+ appliesto_ele =
+ axiom_element_get_first_child_with_qname(rst_ele, env, applies_to_qname, rst_node,
+ &appliesto_node);
+ if (appliesto_ele)
+ {
+ epr_ele = axiom_element_get_first_element(appliesto_ele, env, appliesto_node, &epr_node);
+ trust_data->applies_to_epr_node = epr_node;
+
+ if (!trust_data->addressing_namespace)
+ {
+ addr_namespace = axiom_element_get_default_namespace(epr_ele, env, epr_node);
+ trust_data->addressing_namespace = axiom_namespace_get_uri(addr_namespace, env);
+ }
+
+ if (epr_ele)
+ {
+ addr_qname =
+ axutil_qname_create(env, EPR_ADDRESS, trust_data->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_data->applies_to_address = axiom_element_get_text(addr_ele, env, addr_node);
+ }
+ }
+ else
+ {
AXIS2_FREE(env->allocator, applies_to_qname);
- return AXIS2_FAILURE;
- }
+ return AXIS2_FAILURE;
+ }
- }else{
+ }
+ else
+ {
AXIS2_FREE(env->allocator, applies_to_qname);
- return AXIS2_FAILURE;
- }
+ return AXIS2_FAILURE;
+ }
AXIS2_FREE(env->allocator, applies_to_qname);
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_request_context(
- trust_data_t *trust_data,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_request_context(
+ trust_data_t * trust_data,
+ const axutil_env_t * env)
{
- axiom_element_t *rst_ele = NULL;
- axutil_qname_t *attr_ctx_qname = NULL;
- axis2_char_t *context = NULL;
+ axiom_element_t *rst_ele = NULL;
+ axutil_qname_t *attr_ctx_qname = NULL;
+ axis2_char_t *context = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- 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;
+ 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_data->rst_node, env));
- context = axiom_element_get_attribute_value(rst_ele, env, attr_ctx_qname);
+ rst_ele = (axiom_element_t *) (axiom_node_get_data_element(trust_data->rst_node, env));
+ context = axiom_element_get_attribute_value(rst_ele, env, attr_ctx_qname);
- if(context)
- {
- trust_data->rst_context_attr = context;
+ if (context)
+ {
+ trust_data->rst_context_attr = context;
AXIS2_FREE(env->allocator, attr_ctx_qname);
- return AXIS2_SUCCESS;
- }
+ return AXIS2_SUCCESS;
+ }
AXIS2_FREE(env->allocator, attr_ctx_qname);
- return AXIS2_FAILURE;
+ return AXIS2_FAILURE;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_request_type(
- trust_data_t *trust_data,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_request_type(
+ trust_data_t * trust_data,
+ 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;
+ 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);
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- rst_node = trust_data->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_data->wst_namespace, TRUST_WST);
+ rst_node = trust_data->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_data->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)
+ 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;
+ return AXIS2_FAILURE;
+ }
- trust_data->request_type = axiom_element_get_text( req_type_ele, env, req_type_node);
+ trust_data->request_type = axiom_element_get_text(req_type_ele, env, req_type_node);
AXIS2_FREE(env->allocator, req_type_qname);
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_token_type(
- trust_data_t *trust_data,
- 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_data->rst_node, env));
-
- token_type_qname = axutil_qname_create(env, TRUST_TOKEN_TYPE, trust_data->wst_namespace, TRUST_WST);
-
- token_type_ele = axiom_element_get_first_child_with_qname(rst_ele, env, token_type_qname,
- trust_data->rst_node, &token_type_node);
- if(!token_type_ele)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_token_type(
+ trust_data_t * trust_data,
+ 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_data->rst_node, env));
+
+ token_type_qname =
+ axutil_qname_create(env, TRUST_TOKEN_TYPE, trust_data->wst_namespace, TRUST_WST);
+
+ token_type_ele =
+ axiom_element_get_first_child_with_qname(rst_ele, env, token_type_qname,
+ trust_data->rst_node, &token_type_node);
+ if (!token_type_ele)
+ {
AXIS2_FREE(env->allocator, token_type_qname);
- return AXIS2_FAILURE;
+ return AXIS2_FAILURE;
+ }
+
+ trust_data->token_type = axiom_element_get_text(token_type_ele, env, token_type_node);
- trust_data->token_type = axiom_element_get_text( token_type_ele, env, token_type_node);
-
AXIS2_FREE(env->allocator, token_type_qname);
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_claims(
- trust_data_t *trust_data,
- axutil_env_t *env)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_claims(
+ trust_data_t * trust_data,
+ const axutil_env_t * env)
{
- axiom_node_t* claims_node = NULL;
- axiom_element_t * claims_ele = NULL;
- axiom_element_t * rst_ele = NULL;
- axutil_qname_t* claims_qname = NULL;
+ 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;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- rst_ele = (axiom_element_t *)(axiom_node_get_data_element(trust_data->rst_node, env));
+ rst_ele = (axiom_element_t *) (axiom_node_get_data_element(trust_data->rst_node, env));
claims_qname = axutil_qname_create(env, TRUST_CLAIMS, trust_data->wst_namespace, TRUST_WST);
- claims_ele = axiom_element_get_first_child_with_qname(rst_ele, env, claims_qname,
- trust_data->rst_node, &claims_node);
- if(!claims_ele)
+ claims_ele =
+ axiom_element_get_first_child_with_qname(rst_ele, env, claims_qname, trust_data->rst_node,
+ &claims_node);
+ if (!claims_ele)
+ {
AXIS2_FREE(env->allocator, claims_qname);
return AXIS2_FAILURE;
+ }
trust_data->claims_node = claims_node;
- attr_dialect_qname = axutil_qname_create(env, TRUST_CLAIMS_DIALECT, trust_data->wst_namespace, TRUST_WST);
- if(!attr_dialect_qname)
- {
+ attr_dialect_qname =
+ axutil_qname_create(env, TRUST_CLAIMS_DIALECT, trust_data->wst_namespace, TRUST_WST);
+ if (!attr_dialect_qname)
+ {
AXIS2_FREE(env->allocator, claims_qname);
return AXIS2_FAILURE;
- }
+ }
dialect = axiom_element_get_attribute_value(claims_ele, env, attr_dialect_qname);
- if(!dialect)
+ if (!dialect)
{
AXIS2_FREE(env->allocator, claims_qname);
AXIS2_FREE(env->allocator, attr_dialect_qname);
return AXIS2_FAILURE;
}
- trust_data->claims_dialect = dialect;
+ trust_data->claims_dialect = dialect;
AXIS2_FREE(env->allocator, claims_qname);
AXIS2_FREE(env->allocator, attr_dialect_qname);
return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_entropy(
- trust_data_t *trust_data,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_entropy(
+ trust_data_t * trust_data,
+ const axutil_env_t * env)
{
- /* TO DO: Complete the entropy processing*/
+ /* 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_data->rst_node, env));
+ rst_ele = (axiom_element_t *) (axiom_node_get_data_element(trust_data->rst_node, env));
entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, trust_data->wst_namespace, TRUST_WST);
- entropy_ele = axiom_element_get_first_child_with_qname(rst_ele, env, entropy_qname, trust_data->rst_node, &entropy_node);
- if(!entropy_ele)
+ entropy_ele =
+ axiom_element_get_first_child_with_qname(rst_ele, env, entropy_qname, trust_data->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);
- if(binary_secret_ele && axiom_element_get_text(binary_secret_ele, env, binary_secret_node))
- {
+ }
+
+ 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))
+ {
+ axis2_base64_decode(trust_data->request_entropy, bin_sec_str);
+ }
+ else
+ {
+ AXIS2_FREE(env->allocator, entropy_qname);
+ return AXIS2_FAILURE;
}
-
+
+ return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_key_type(
- trust_data_t *data,
- axutil_env_t *env)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_key_type(
+ trust_data_t * data,
+ axutil_env_t * env)
{
- 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;
+ 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);
-
- rst_ele = (axiom_element_t *)(axiom_node_get_data_element(data->rst_node, env));
-
+
+ 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)
+
+ 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;
+ }
data->key_type = axiom_element_get_text(key_type_ele, env, key_type_node);
@@ -346,9 +412,10 @@
return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_data_process_key_size(
- trust_data_t *data,
- axutil_env_t *env)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_data_process_key_size(
+ trust_data_t * data,
+ axutil_env_t * env)
{
axiom_node_t *key_size_node = NULL;
axiom_element_t *key_size_ele = NULL;
@@ -358,19 +425,22 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- rst_ele = (axiom_element_t *)(axiom_node_get_data_element(data->rst_node, env));
+ 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)
+ 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)
+ {
AXIS2_FREE(env->allocator, key_size_qname);
return AXIS2_FAILURE;
+ }
size_str = axiom_element_get_text(key_size_ele, env, key_size_node);
- if(!size_str)
+ if (!size_str)
{
AXIS2_FREE(env->allocator, key_size_qname);
return AXIS2_FAILURE;
@@ -381,51 +451,22 @@
return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_data_get_request_type(
- trust_data_t *trust_data,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_data_get_request_type(
+ trust_data_t * trust_data,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
return trust_data->request_type;
}
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_data_get_wst_ns(
- trust_data_t *trust_data,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_data_get_wst_ns(
+ trust_data_t * trust_data,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
return trust_data->wst_namespace;
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Modified: webservices/rampart/scratch/c/trust/src/sts/sts.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/src/sts/sts.c?rev=589051&r1=589050&r2=589051&view=diff
==============================================================================
--- webservices/rampart/scratch/c/trust/src/sts/sts.c (original)
+++ webservices/rampart/scratch/c/trust/src/sts/sts.c Fri Oct 26 22:57:24 2007
@@ -14,55 +14,41 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#include <axis2_svc_skeleton.h>
-#include <axutil_log_default.h>
-#include <axutil_error_default.h>
-#include <axiom_text.h>
-#include <axiom_node.h>
-#include <axiom_element.h>
-#include <axutil_dll_desc.h>
-#include <axutil_array_list.h>
-#include <axutil_class_loader.h>
-
#include <trust_sts.h>
-const char *service_dll_def[] = {"issuer", "validator", "renewer", "cancelor"};
+const char *service_dll_def[] = { "issuer", "validator", "renewer", "cancelor" };
typedef struct
{
- trust_svc_type_t type;
+ trust_svc_type_t type;
axutil_dll_desc_t *desc;
void *dll;
-}trust_dll_desc_t;
+} trust_dll_desc_t;
-typedef struct
+typedef struct
{
- axis2_svc_skeleton_t skeleton;
- trust_dll_desc_t dll_desc[4];
+ axis2_svc_skeleton_t skeleton;
+ trust_dll_desc_t dll_desc[4];
} axis2_svc_skeleton_impl_t;
-int AXIS2_CALL
-trust_sts_free(
- axis2_svc_skeleton_t *svc_skeleton,
- const axutil_env_t *env);
-
-axiom_node_t* AXIS2_CALL
-trust_sts_invoke(
- axis2_svc_skeleton_t *svc_skeleton,
- const axutil_env_t *env,
- axiom_node_t *node,
- axis2_msg_ctx_t *msg_ctx);
-
-int AXIS2_CALL
-trust_sts_init(
- axis2_svc_skeleton_t *svc_skeleton,
- const axutil_env_t *env);
-
-axiom_node_t * AXIS2_CALL
-trust_sts_on_fault(
- axis2_svc_skeleton_t *svc_skeli,
- const axutil_env_t *env,
- axiom_node_t *node);
+int AXIS2_CALL trust_sts_free(
+ axis2_svc_skeleton_t * svc_skeleton,
+ const axutil_env_t * env);
+
+axiom_node_t *AXIS2_CALL trust_sts_invoke(
+ axis2_svc_skeleton_t * svc_skeleton,
+ const axutil_env_t * env,
+ axiom_node_t * node,
+ axis2_msg_ctx_t * msg_ctx);
+
+int AXIS2_CALL trust_sts_init(
+ axis2_svc_skeleton_t * svc_skeleton,
+ const axutil_env_t * env);
+
+axiom_node_t *AXIS2_CALL trust_sts_on_fault(
+ axis2_svc_skeleton_t * svc_skeli,
+ const axutil_env_t * env,
+ axiom_node_t * node);
static const axis2_svc_skeleton_ops_t trust_sts_svc_skeleton_ops_var = {
trust_sts_init,
@@ -71,67 +57,18 @@
trust_sts_free
};
-AXIS2_EXPORT int axis2_get_instance(struct axis2_svc_skeleton **inst,
- const axutil_env_t *env)
-{
- axis2_svc_skeleton_impl_t *svc_skeleton = NULL;
- svc_skeleton = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_skeleton_t));
- if (!svc_skeleton)
- {
- return AXIS2_FAILURE;
- }
- svc_skeleton->skeleton.ops = &trust_sts_svc_skeleton_ops_var;
- svc_skeleton->skeleton.func_array = NULL;
- *inst = &svc_skeleton->skeleton;
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXPORT int axis2_remove_instance(axis2_svc_skeleton_t *inst,
- const axutil_env_t *env)
-{
- axis2_status_t status = AXIS2_FAILURE;
- axis2_svc_skeleton_impl_t *skel = (axis2_svc_skeleton_impl_t *)inst;
- if (inst)
- {
- status = AXIS2_SVC_SKELETON_FREE(&skel->skeleton, env);
- AXIS2_FREE(env->allocator, skel);
- }
- return status;
-}
-
int AXIS2_CALL
-trust_sts_init(axis2_svc_skeleton_t *svc_skeleton,
- const axutil_env_t *env)
+trust_sts_init(
+ axis2_svc_skeleton_t * svc_skeleton,
+ const axutil_env_t * env)
{
- axis2_svc_skeleton_impl_t *svc_skel_im = NULL;
- int i = 0;
-
- if (!svc_skeleton)
- {
- return AXIS2_FAILURE;
- }
-
- svc_skel_im = (axis2_svc_skeleton_impl_t *)svc_skeleton;
-
- /* Load the dlls for issuer, validator, canceler, renewer
- implementations */
- for(i = 0; i < 4; i++)
- {
- svc_skel_im->dll_desc[i].type = i;
- svc_skel_im->dll_desc[i].dll =
- trust_get_def_service(i, &svc_skel_im->dll_desc[i].desc, env);
- if(!svc_skel_im->dll_desc[i].dll)
- {
- return AXIS2_FAILURE;
- }
- }
-
return AXIS2_SUCCESS;
}
int AXIS2_CALL
-trust_sts_free(axis2_svc_skeleton_t *svc_skeleton,
- const axutil_env_t *env)
+trust_sts_free(
+ axis2_svc_skeleton_t * svc_skeleton,
+ const axutil_env_t * env)
{
if (svc_skeleton)
{
@@ -141,95 +78,153 @@
return AXIS2_SUCCESS;
}
-axiom_node_t* AXIS2_CALL
-trust_sts_invoke(axis2_svc_skeleton_t *svc_skeleton,
- const axutil_env_t *env,
- axiom_node_t *node,
- axis2_msg_ctx_t *msg_ctx)
-{
- trust_data_t *trust_data = NULL;
- axis2_char_t *om_str = NULL;
- printf("\nInside Invoke");
- if(node){
- om_str = axiom_node_to_string(node, env);
- printf("\nNode: %s", om_str);
- trust_data = trust_data_create(env, node);
- printf("\nRequest Type: %s\nWST NS: %s\n", trust_data_get_request_type(trust_data, env),
- trust_data_get_wst_ns(trust_data, env));
- }
+axiom_node_t *AXIS2_CALL
+trust_sts_invoke(
+ axis2_svc_skeleton_t * svc_skeleton,
+ const axutil_env_t * env,
+ axiom_node_t * node,
+ axis2_msg_ctx_t * msg_ctx)
+{
+ int param_type = NULL;
+ trust_data_t *trust_data = NULL;
+ axis2_char_t *om_str = NULL;
+ axis2_msg_ctx_t *in_msg_ctx = NULL;
+ axis2_op_ctx_t *op_ctx = NULL;
+ axutil_param_t *param_config_file = NULL;
+ axis2_char_t *param_value = NULL;
+ axiom_xml_reader_t *xml_reader = NULL;
+ axiom_stax_builder_t *stax_builder = NULL;
+ axiom_document_t *doc = NULL;
+ axiom_node_t *root_node = NULL;
+
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sts] Inside STS Invoke Function...!");
+
+ op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
+ in_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN);
+
+ param_config_file = axis2_msg_ctx_get_parameter(in_msg_ctx, env, "sts-configuration-file");
+
+ if(param_config_file)
+ {
+ param_type = axutil_param_get_param_type(param, env);
+
+ if(param_type)
+ {
+ param_value = (axis2_char_t *)axutil_param_get_value(param_config_file, env);
+
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sts] STS Configuration file: %s", param_value);
+
+ if(param_value)
+ {
+ xml_reader = axiom_xml_reader_create_for_file(env, param_value, NULL);
+ builder = axiom_stax_builder_create(env, xml_reader);
+ doc = axiom_stax_builder_get_document(builder, env);
+ root_node = axiom_document_get_root_element(doc, env);
+ axiom_document_build_all(doc, env);
+ p_val = axiom_node_to_string(root_node, env);
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[echo_para] Configurations: %s", p_val);
+ }
+ }
+ }
+
+/*
+ if (node)
+ {
+ om_str = axiom_node_to_string(node, env);
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sts] RST: %s", om_str);
+ trust_data = trust_data_create(env, in_msg_ctx);
+ printf("\nRequest Type: %s\nWST NS: %s\n", trust_data_get_request_type(trust_data, env),
+ trust_data_get_wst_ns(trust_data, env));
+ }
+ else
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INPUT_OM_NODE_NULL, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[sts] Input OM node NULL, Probably error in SOAP request..!");
+ }
+*/
return node;
}
-axiom_node_t * AXIS2_CALL trust_sts_on_fault(axis2_svc_skeleton_t *svc_skeli,
- const axutil_env_t *env,
- axiom_node_t *node)
-{
- return NULL;
-}
-
-AXIS2_EXPORT void * trust_get_def_service(trust_svc_type_t type, axutil_dll_desc_t **ret_desc, const axutil_env_t *env)
-{
- void * service = NULL;
- axutil_param_t * param = NULL;
- axutil_dll_desc_t *desc = NULL;
- axis2_char_t *dll_name = NULL;
-
- desc = axutil_dll_desc_create(env);
-
- if (!desc)
- {
- return NULL;
- }
-
- dll_name = axutil_dll_desc_create_platform_specific_dll_name(desc, env, service_dll_def[type]);
- if (dll_name)
- {
- axutil_dll_desc_set_name(desc, env, dll_name);
- /*AXIS2_FREE(env->allocator, dll_name);*/
- }
-
- axutil_dll_desc_set_name(desc, env, "\\home\\milinda\\projects\\axis2c\\deploy\\services\\STS\\issuer.so");
- param = axutil_param_create(env, (axis2_char_t*)service_dll_def[type], desc);
-
- if (!param)
- {
- axutil_dll_desc_free(desc, env);
- return NULL;
- }
-
- service = axutil_class_loader_create_dll(env, param);
- *ret_desc = desc;
-
- return service;
+axiom_node_t *AXIS2_CALL
+trust_sts_on_fault(
+ axis2_svc_skeleton_t * svc_skeli,
+ const axutil_env_t * env,
+ axiom_node_t * node)
+{
+ return NULL;
}
+AXIS2_EXPORT void *
+trust_get_def_service(
+ trust_svc_type_t type,
+ axutil_dll_desc_t ** ret_desc,
+ const axutil_env_t * env)
+{
+ void *service = NULL;
+ axutil_param_t *param = NULL;
+ axutil_dll_desc_t *desc = NULL;
+ axis2_char_t *dll_name = NULL;
+ desc = axutil_dll_desc_create(env);
+ if (!desc)
+ {
+ return NULL;
+ }
+ dll_name = axutil_dll_desc_create_platform_specific_dll_name(desc, env, service_dll_def[type]);
+ if (dll_name)
+ {
+ axutil_dll_desc_set_name(desc, env, dll_name);
+ /*AXIS2_FREE(env->allocator, dll_name); */
+ }
+ axutil_dll_desc_set_name(desc, env,
+ "\\home\\milinda\\projects\\axis2c\\deploy\\services\\STS\\issuer.so");
+ param = axutil_param_create(env, (axis2_char_t *) service_dll_def[type], desc);
+ if (!param)
+ {
+ axutil_dll_desc_free(desc, env);
+ return NULL;
+ }
+ service = axutil_class_loader_create_dll(env, param);
+ *ret_desc = desc;
+ return service;
+}
+AXIS2_EXPORT int
+axis2_get_instance(
+ struct axis2_svc_skeleton **inst,
+ const axutil_env_t * env)
+{
+ axis2_svc_skeleton_impl_t *svc_skeleton = NULL;
+ svc_skeleton = AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_skeleton_t));
+ if (!svc_skeleton)
+ {
+ return AXIS2_FAILURE;
+ }
+ svc_skeleton->skeleton.ops = &trust_sts_svc_skeleton_ops_var;
+ svc_skeleton->skeleton.func_array = NULL;
+ *inst = &svc_skeleton->skeleton;
+ return AXIS2_SUCCESS;
+}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+AXIS2_EXPORT int
+axis2_remove_instance(
+ axis2_svc_skeleton_t * inst,
+ const axutil_env_t * env)
+{
+ axis2_status_t status = AXIS2_FAILURE;
+ axis2_svc_skeleton_impl_t *skel = (axis2_svc_skeleton_impl_t *) inst;
+ if (inst)
+ {
+ status = AXIS2_SVC_SKELETON_FREE(&skel->skeleton, env);
+ AXIS2_FREE(env->allocator, skel);
+ }
+ return status;
+}
Modified: webservices/rampart/scratch/c/trust/src/sts_client.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/src/sts_client.c?rev=589051&r1=589050&r2=589051&view=diff
==============================================================================
--- webservices/rampart/scratch/c/trust/src/sts_client.c (original)
+++ webservices/rampart/scratch/c/trust/src/sts_client.c Fri Oct 26 22:57:24 2007
@@ -20,43 +20,46 @@
struct trust_sts_client
{
- /*WS Trust version*/
+ /*WS Trust version */
int version;
/* Key size */
int key_size;
-
+
/* Algorithm Suite for Entropy */
rp_algorithmsuite_t *algo_suite;
-
+
/* Trust 1.0 Assertions */
rp_trust10_t *trust10;
-
+
/* Requestor Entropy */
axis2_char_t *requestor_entropy;
-
+
/* Time To Live */
int ttl;
-
+
/* Issuer Address */
axis2_char_t *issuer_address;
-
+
/* STS Client Home Directory */
axis2_char_t *home_dir;
-
+
/* Location of the issuer's policy file */
axis2_char_t *issuer_policy_location;
-
+
/* Location of the service's (relying party's) policy file */
axis2_char_t *service_policy_location;
};
-AXIS2_EXPORT trust_sts_client_t* AXIS2_CALL trust_sts_client_create(
- const axutil_env_t *env)
-{
- trust_sts_client_t* sts_client = NULL;
-
- sts_client = (trust_sts_client_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_sts_client_t));
+AXIS2_EXPORT trust_sts_client_t *AXIS2_CALL
+trust_sts_client_create(
+ const axutil_env_t * env)
+{
+ trust_sts_client_t *sts_client = NULL;
+
+ sts_client =
+ (trust_sts_client_t *) AXIS2_MALLOC(env->allocator,
+ sizeof(trust_sts_client_t));
sts_client->version = TRUST_VERSION_05_02;
sts_client->key_size = 0;
@@ -67,312 +70,261 @@
sts_client->issuer_address = NULL;
sts_client->issuer_policy_location = NULL;
sts_client->service_policy_location = NULL;
-
+
return sts_client;
}
-
-AXIS2_EXPORT void AXIS2_CALL trust_sts_client_free(
- trust_sts_client_t* sts_client,
- const axutil_env_t *env)
+AXIS2_EXPORT void AXIS2_CALL
+trust_sts_client_free(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- if(sts_client)
+ if (sts_client)
{
AXIS2_FREE(env->allocator, sts_client);
}
- //return AXIS2_SUCCESS;
}
-AXIS2_EXPORT void AXIS2_CALL trust_sts_client_request_security_token(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- axis2_char_t *applies_to,
- axis2_char_t *token_type)
+AXIS2_EXPORT void AXIS2_CALL
+trust_sts_client_request_security_token(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ axis2_char_t * applies_to,
+ axis2_char_t * token_type)
{
axis2_svc_client_t *svc_client = NULL;
neethi_policy_t *issuer_policy = NULL;
neethi_policy_t *service_policy = NULL;
- axis2_status_t *status = AXIS2_SUCCESS;
+ axis2_status_t status = AXIS2_SUCCESS;
axiom_node_t *return_node = NULL;
-
- issuer_policy = neethi_util_create_policy_from_file(env,
- sts_client->issuer_policy_location);
-
- service_policy = neethi_util_create_policy_from_file(env,
- sts_client->service_policy_location);
-
- if(!issuer_policy || !service_policy)
+
+ issuer_policy =
+ neethi_util_create_policy_from_file(env,
+ sts_client->issuer_policy_location);
+
+ service_policy =
+ neethi_util_create_policy_from_file(env,
+ sts_client->
+ service_policy_location);
+
+ if (!issuer_policy || !service_policy)
{
status = AXIS2_FAILURE;
}
else
{
- trust_sts_client_process_policies(sts_client, env, issuer_policy, service_policy);
+ trust_sts_client_process_policies(sts_client, env, issuer_policy,
+ service_policy);
}
-
+
/* TODO : Fix action logic */
- svc_client = trust_sts_client_get_svc_client(sts_client, env, "http://schemas.xmlsoap.org/ws/2005/02/RST/issue");
-
- if(status = AXIS2_SUCCESS)
+ svc_client =
+ trust_sts_client_get_svc_client(sts_client, env,
+ "http://schemas.xmlsoap.org/ws/2005/02/RST/issue");
+
+ if (status = AXIS2_SUCCESS)
{
status = axis2_svc_client_set_policy(svc_client, env, issuer_policy);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
printf("Policy setting failed\n");
}
-
- return_node = axis2_svc_client_send_receive(svc_client, env,
- trust_sts_client_create_issue_request(sts_client, env, "/Issue", applies_to, token_type));
+
+ return_node =
+ axis2_svc_client_send_receive(svc_client, env,
+ trust_sts_client_create_issue_request
+ (sts_client, env, "/Issue",
+ applies_to, token_type));
}
+ if (svc_client)
+ {
+ axis2_svc_client_free(svc_client, env);
+ svc_client = NULL;
+ }
+
return;
}
-AXIS2_EXPORT axis2_svc_client_t* AXIS2_CALL trust_sts_client_get_svc_client(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- axis2_char_t *action)
+AXIS2_EXPORT axis2_svc_client_t *AXIS2_CALL
+trust_sts_client_get_svc_client(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ axis2_char_t * action)
{
axis2_endpoint_ref_t *endpoint_ref = NULL;
axis2_options_t *options = NULL;
axis2_svc_client_t *svc_client = NULL;
-
+
endpoint_ref = axis2_endpoint_ref_create(env, sts_client->issuer_address);
-
+
options = axis2_options_create(env);
axis2_options_set_to(options, env, endpoint_ref);
- axis2_options_set_action(options, env, action);
-
- svc_client = axis2_svc_client_create(env, sts_client->home_dir);
- if (!svc_client)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Stub invoke FAILED: Error code:" " %d :: %s", env->error->error_number,
- AXIS2_ERROR_GET_MESSAGE(env->error));
- return NULL;
- }
-
+ axis2_options_set_action(options, env, action);
+
+ svc_client = axis2_svc_client_create(env, sts_client->home_dir);
+ if (!svc_client)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Stub invoke FAILED: Error code:" " %d :: %s",
+ env->error->error_number,
+ AXIS2_ERROR_GET_MESSAGE(env->error));
+ return NULL;
+ }
+
/* Set service client options */
axis2_svc_client_set_options(svc_client, env, options);
/* Engage addressing module */
axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
-
+
return svc_client;
}
-
-
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_sts_client_process_policies(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- neethi_policy_t *issuer_policy,
- neethi_policy_t *service_policy)
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_sts_client_process_policies(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ neethi_policy_t * issuer_policy,
+ neethi_policy_t * service_policy)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- if(issuer_policy)
+
+ if (issuer_policy)
{
- sts_client->algo_suite = trust_policy_util_get_algorithmsuite(env, issuer_policy);
+ sts_client->algo_suite =
+ trust_policy_util_get_algorithmsuite(env, issuer_policy);
}
-
- if(service_policy)
+
+ if (service_policy)
{
- sts_client->trust10 = trust_policy_util_get_trust10(env, service_policy);
+ sts_client->trust10 =
+ trust_policy_util_get_trust10(env, service_policy);
}
-
+
return AXIS2_SUCCESS;
}
-AXIS2_EXPORT axiom_node_t* AXIS2_CALL trust_sts_client_create_issue_request(
- trust_sts_client_t* sts_client,
- const axutil_env_t *env,
- const axis2_char_t *request_type,
- const axis2_char_t *applies_to,
- const axis2_char_t *token_type)
+AXIS2_EXPORT axiom_node_t *AXIS2_CALL
+trust_sts_client_create_issue_request(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ axis2_char_t * request_type,
+ axis2_char_t * applies_to,
+ axis2_char_t * token_type)
{
axiom_node_t *rst_node = NULL;
+ axiom_node_t *entropy_node = NULL;
+ axiom_node_t *binsec_node = NULL;
+ int maxkey_len = 0;
rst_node = trust_util_create_rst_element(env, sts_client->version);
/* Setting up the request type */
- trust_util_create_request_type_element(env, sts_client->version, rst_node, request_type);
+ trust_util_create_request_type_element(env, sts_client->version, rst_node,
+ request_type);
/* Setting up the token type */
- if(token_type)
+ if (token_type)
{
- trust_util_set_node_text(
- env,
- trust_util_create_token_type_element(env, sts_client->version, rst_node),
- token_type);
+ trust_util_set_node_text(env,
+ trust_util_create_token_type_element(env,
+ sts_client->
+ version,
+ rst_node),
+ token_type);
}
- if(applies_to)
- trust_util_create_applies_to_element(env, rst_node, applies_to, TRUST_WSA_XMLNS);
-
- return rst_node;
-}
-
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_sts_client_set_ttl(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- int ttl)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, ttl, AXIS2_FAILURE);
-
- sts_client->ttl = ttl;
-
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXPORT int AXIS2_CALL trust_sts_client_get_ttl(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- return sts_client->ttl;
-}
-
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_sts_client_set_issuer_address(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- axis2_char_t *address)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, address, AXIS2_FAILURE);
-
- sts_client->issuer_address = address;
-
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_sts_client_get_issuer_address(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- return sts_client->issuer_address;
-}
-
-
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_sts_client_set_home_dir(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- axis2_char_t *directory)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, directory, AXIS2_FAILURE);
-
- sts_client->home_dir = directory;
-
- return AXIS2_SUCCESS;
-}
-
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_sts_client_get_home_dir(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- return sts_client->home_dir;
-}
-
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_sts_client_set_issuer_policy_location(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- axis2_char_t *file_path)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, file_path, AXIS2_FAILURE);
-
- sts_client->issuer_policy_location = file_path;
-
- return AXIS2_SUCCESS;
-}
+ if (applies_to)
+ trust_util_create_applies_to_element(env, rst_node, applies_to,
+ TRUST_WSA_XMLNS);
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_sts_client_get_issuer_policy_location(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- return sts_client->issuer_policy_location;
-}
-
-AXIS2_EXPORT axis2_status_t AXIS2_CALL trust_sts_client_set_service_policy_location(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env,
- axis2_char_t *file_path)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, file_path, AXIS2_FAILURE);
-
- sts_client->service_policy_location = file_path;
+ if (sts_client->trust10 && sts_client->algo_suite)
+ {
+ if (rp_trust10_get_require_client_entropy(sts_client->trust10, env) ==
+ AXIS2_TRUE)
+ {
+ entropy_node =
+ trust_util_create_entropy_element(env, sts_client->version,
+ rst_node);
+
+ maxkey_len =
+ rp_algorithmsuite_get_max_symmetric_keylength(sts_client->
+ algo_suite, env);
+ sts_client->requestor_entropy =
+ (axis2_char_t*)rampart_generate_nonce(env, maxkey_len);
+
+ binsec_node =
+ trust_util_create_binary_secret_element(env,
+ sts_client->version,
+ entropy_node, sts_client->requestor_entropy,
+ TRUST_BIN_SEC_TYPE_NONCE);
+
+ trust_util_create_computed_key_algo_element(env,
+ sts_client->version,
+ rst_node,
+ TRUST_COMPUTED_KEY_PSHA1);
+ }
+ }
+ else
+ {
+ printf("Algo Suite or Trust10 Error!\n");
+ }
- return AXIS2_SUCCESS;
-}
+ trust_sts_client_free(sts_client, env);
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_sts_client_get_service_policy_location(
- trust_sts_client_t *sts_client,
- const axutil_env_t *env)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- return sts_client->service_policy_location;
+ return rst_node;
}
-
/* Process ISSUE RESPONSE */
-AXIS2_EXPORT trust_token_t* AXIS2_CALL trust_sts_client_process_issue_response(
- trust_sts_client_t* sts_client,
+AXIS2_EXPORT trust_token_t *AXIS2_CALL
+trust_sts_client_process_issue_response(
+ trust_sts_client_t * sts_client,
int version,
- axiom_node_t* response_node,
- axiom_node_t* payload_sent,
- const axutil_env_t *env)
+ axiom_node_t * response_node,
+ axiom_node_t * payload_sent,
+ const axutil_env_t * env)
{
/* Token */
trust_token_t *token = NULL;
- /* RSTR*/
+ /* RSTR */
axiom_node_t *rstr_node = NULL;
axiom_element_t *rstr_ele = NULL;
axis2_char_t *trust_ns_str = NULL;
- /* Attached Reference*/
+ /* Attached Reference */
axiom_node_t *attached_ref_node = NULL;
axiom_element_t *attached_ref_ele = NULL;
- axutil_qname_t* attached_ref_qname = NULL;
+ axutil_qname_t *attached_ref_qname = NULL;
axiom_node_t *req_attached_ref_node = NULL;
- /* Unattached Reference*/
+ /* Unattached Reference */
axiom_node_t *unattached_ref_node = NULL;
axiom_element_t *unattached_ref_ele = NULL;
axutil_qname_t *unattached_ref_qname = NULL;
axiom_node_t *req_unattached_ref_node = NULL;
- /*Requsted Security Token*/
+ /*Requsted Security Token */
axiom_node_t *req_sec_token_node = NULL;
- axiom_element_t * req_sec_token_ele = NULL;
+ axiom_element_t *req_sec_token_ele = NULL;
axutil_qname_t *req_sec_token_qname = NULL;
- axiom_node_t *sec_token = NULL;
+ axiom_node_t *sec_token = NULL;
/* Life Time */
axiom_node_t *life_time_node = NULL;
- axiom_element_t * life_time_ele = NULL;
+ axiom_element_t *life_time_ele = NULL;
axutil_qname_t *life_time_qname = NULL;
-
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
rstr_node = response_node;
if (TRUST_VERSION_05_12 == version)
{
- rstr_node = axiom_node_get_first_element(rstr_node, env);
+ rstr_node = axiom_node_get_first_element(rstr_node, env);
}
trust_ns_str = trust_util_get_wst_ns(env, version);
@@ -380,51 +332,65 @@
/* Extract Attached Reference */
- attached_ref_qname = axutil_qname_create(env, TRUST_REQUESTED_ATTACH_REFERENCE,
- trust_ns_str, TRUST_WST);
-
- attached_ref_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, attached_ref_qname,
- rstr_node, &attached_ref_node);
+ attached_ref_qname =
+ axutil_qname_create(env, TRUST_REQUESTED_ATTACH_REFERENCE, trust_ns_str,
+ TRUST_WST);
+
+ attached_ref_ele =
+ axiom_element_get_first_child_with_qname(rstr_ele, env,
+ attached_ref_qname, rstr_node,
+ &attached_ref_node);
if (attached_ref_ele)
{
- req_attached_ref_node = axiom_node_get_first_element(attached_ref_node, env);
+ req_attached_ref_node =
+ axiom_node_get_first_element(attached_ref_node, env);
}
/* Extract unattached Reference */
- unattached_ref_qname = axutil_qname_create(env, TRUST_REQUESTED_UNATTACHED_REFERENCE,
- trust_ns_str, TRUST_WST);
-
- unattached_ref_ele = axiom_element_get_first_child_with_qname(rstr_ele, env,
- unattached_ref_qname, rstr_node, &unattached_ref_node);
+ unattached_ref_qname =
+ axutil_qname_create(env, TRUST_REQUESTED_UNATTACHED_REFERENCE,
+ trust_ns_str, TRUST_WST);
+
+ unattached_ref_ele =
+ axiom_element_get_first_child_with_qname(rstr_ele, env,
+ unattached_ref_qname,
+ rstr_node,
+ &unattached_ref_node);
if (unattached_ref_ele)
{
- req_unattached_ref_node = axiom_node_get_first_element(unattached_ref_node, env);
+ req_unattached_ref_node =
+ axiom_node_get_first_element(unattached_ref_node, env);
}
/* Extract Requested Security Token */
- req_sec_token_qname = axutil_qname_create(env, TRUST_REQUESTED_SECURITY_TOKEN,
- trust_ns_str, TRUST_WST);
- req_sec_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, req_sec_token_qname,
- rstr_node, &req_sec_token_node);
+ req_sec_token_qname =
+ axutil_qname_create(env, TRUST_REQUESTED_SECURITY_TOKEN, trust_ns_str,
+ TRUST_WST);
+ req_sec_token_ele =
+ axiom_element_get_first_child_with_qname(rstr_ele, env,
+ req_sec_token_qname, rstr_node,
+ &req_sec_token_node);
if (req_sec_token_node)
{
- sec_token = axiom_node_get_first_element(req_sec_token_node, env);
+ sec_token = axiom_node_get_first_element(req_sec_token_node, env);
}
- else
+ else
{
- /*Requsted Token Missing - Handle*/
+ /*Requsted Token Missing - Handle */
}
/* Extract Life Time */
- life_time_qname = axutil_qname_create(env, TRUST_LIFE_TIME, trust_ns_str, TRUST_WST);
- life_time_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, life_time_qname,
- rstr_node, &life_time_node);
+ life_time_qname =
+ axutil_qname_create(env, TRUST_LIFE_TIME, trust_ns_str, TRUST_WST);
+ life_time_ele =
+ axiom_element_get_first_child_with_qname(rstr_ele, env, life_time_qname,
+ rstr_node, &life_time_node);
if (NULL == life_time_ele)
{
- /* Handle NULL - life time ele*/
+ /* Handle NULL - life time ele */
}
/* TOKEN Creation */
@@ -435,38 +401,161 @@
}
-
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_sts_client_find_identifier(
- trust_sts_client_t* sts_client,
- axiom_node_t* req_att_ref_node,
- axiom_node_t* req_unatt_ref_node,
- axiom_node_t* sec_token_node,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_sts_client_find_identifier(
+ trust_sts_client_t * sts_client,
+ axiom_node_t * req_att_ref_node,
+ axiom_node_t * req_unatt_ref_node,
+ axiom_node_t * sec_token_node,
+ const axutil_env_t * env)
{
axis2_char_t *id_str = NULL;
- if(req_att_ref_node)
+ if (req_att_ref_node)
{
- id_str = trust_sts_client_get_id_from_str(sts_client, req_att_ref_node, env);
+ id_str =
+ trust_sts_client_get_id_from_str(sts_client, req_att_ref_node, env);
}
else if (req_unatt_ref_node)
{
- id_str = trust_sts_client_get_id_from_str(sts_client, req_unatt_ref_node, env);
+ id_str =
+ trust_sts_client_get_id_from_str(sts_client, req_unatt_ref_node,
+ env);
}
else
{
- /* FIX : WSConstants based wsu:Id */
+ /* FIX : WSConstants based wsu:Id */
}
return id_str;
}
-
-AXIS2_EXPORT axis2_char_t* AXIS2_CALL trust_sts_client_get_id_from_str(
- trust_sts_client_t* sts_client,
- axiom_node_t* ref_node,
- const axutil_env_t *env)
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_sts_client_get_id_from_str(
+ trust_sts_client_t * sts_client,
+ axiom_node_t * ref_node,
+ const axutil_env_t * env)
{
/*FIX : implementation requires WS.Consatants paramaters */
return NULL;
+}
+
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_sts_client_set_ttl(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ int ttl)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, ttl, AXIS2_FAILURE);
+
+ sts_client->ttl = ttl;
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXPORT int AXIS2_CALL
+trust_sts_client_get_ttl(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ return sts_client->ttl;
+}
+
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_sts_client_set_issuer_address(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ axis2_char_t * address)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, address, AXIS2_FAILURE);
+
+ sts_client->issuer_address = address;
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_sts_client_get_issuer_address(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ return sts_client->issuer_address;
+}
+
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_sts_client_set_home_dir(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ axis2_char_t * directory)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, directory, AXIS2_FAILURE);
+
+ sts_client->home_dir = directory;
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_sts_client_get_home_dir(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ return sts_client->home_dir;
+}
+
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_sts_client_set_issuer_policy_location(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ axis2_char_t * file_path)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, file_path, AXIS2_FAILURE);
+
+ sts_client->issuer_policy_location = file_path;
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_sts_client_get_issuer_policy_location(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ return sts_client->issuer_policy_location;
+}
+
+AXIS2_EXPORT axis2_status_t AXIS2_CALL
+trust_sts_client_set_service_policy_location(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env,
+ axis2_char_t * file_path)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, file_path, AXIS2_FAILURE);
+
+ sts_client->service_policy_location = file_path;
+
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXPORT axis2_char_t *AXIS2_CALL
+trust_sts_client_get_service_policy_location(
+ trust_sts_client_t * sts_client,
+ const axutil_env_t * env)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ return sts_client->service_policy_location;
}
Modified: webservices/rampart/scratch/c/trust/src/util.c
URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/src/util.c?rev=589051&r1=589050&r2=589051&view=diff
==============================================================================
--- webservices/rampart/scratch/c/trust/src/util.c (original)
+++ webservices/rampart/scratch/c/trust/src/util.c Fri Oct 26 22:57:24 2007
@@ -149,9 +149,9 @@
AXIS2_EXPORT axiom_node_t* AXIS2_CALL trust_util_create_claims_element(
const axutil_env_t *env,
axiom_node_t *parent_node,
- const axis2_char_t *claims_val,
- const axis2_char_t *dialect_uri,
- const int version)
+ axis2_char_t *claims_val,
+ axis2_char_t *dialect_uri,
+ int version)
{
axis2_char_t *wst_ns_str = NULL;
axiom_node_t *util_claims_node = NULL;
@@ -243,10 +243,10 @@
AXIS2_EXPORT axiom_node_t* AXIS2_CALL trust_util_create_binary_secret_element(
const axutil_env_t *env,
- const int version,
+ int version,
axiom_node_t *parent_node,
- const axis2_char_t *enc_secret,
- const axis2_char_t *bs_type)
+ axis2_char_t *enc_secret,
+ axis2_char_t *bs_type)
{
axis2_char_t *trust_ns_str = NULL;
axiom_node_t* util_bs_node = NULL;
@@ -714,7 +714,7 @@
util_qname = axutil_qname_create(env, local_name, ns_uri, prefix);
util_ele = axiom_element_get_first_child_with_qname(parent_ele, env, util_qname,
parent_node, &util_node);
-
+
return util_node;
}
@@ -729,9 +729,9 @@
switch(version)
{
case TRUST_VERSION_05_02:
- return TRUST_WST_XMLNS_05_02;
+ return axutil_strdup(env, TRUST_WST_XMLNS_05_02);
case TRUST_VERSION_05_12:
- return TRUST_WST_XMLNS_05_12;
+ return axutil_strdup(env, TRUST_WST_XMLNS_05_12);
default:
return NULL;
}