Author: milinda
Date: Mon Nov 5 21:07:32 2007
New Revision: 592281
URL: http://svn.apache.org/viewvc?rev=592281&view=rev
Log:
New things added.
Modified:
webservices/rampart/scratch/c/trust/src/util.c
Modified: webservices/rampart/scratch/c/trust/src/util.c
URL:
http://svn.apache.org/viewvc/webservices/rampart/scratch/c/trust/src/util.c?rev=592281&r1=592280&r2=592281&view=diff
==============================================================================
--- webservices/rampart/scratch/c/trust/src/util.c (original)
+++ webservices/rampart/scratch/c/trust/src/util.c Mon Nov 5 21:07:32 2007
@@ -141,16 +141,17 @@
AXIS2_ENV_CHECK(env, NULL);
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
-
+
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
- request_type_ele = axiom_element_create(env, parent_node,
TRUST_REQUEST_TYPE, wst_ns, &request_type_node);
+ request_type_ele =
+ axiom_element_create(env, parent_node, TRUST_REQUEST_TYPE, wst_ns,
&request_type_node);
- if(!request_type_ele)
+ if (!request_type_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestType Element
creation failed.");
return NULL;
}
-
+
if (0 == axutil_strcmp(request_type, TRUST_REQ_TYPE_ISSUE) ||
0 == axutil_strcmp(request_type, TRUST_REQ_TYPE_CANCEL) ||
0 == axutil_strcmp(request_type, TRUST_REQ_TYPE_RENEW) ||
@@ -163,10 +164,11 @@
{
status = axiom_element_set_text(request_type_ele, env, request_type,
request_type_node);
}
-
- if(status == AXIS2_FAILURE)
+
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestType Element's
setting text function failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] RequestType Element's setting text function
failed.");
return NULL;
}
@@ -178,35 +180,37 @@
const axutil_env_t * env,
int wst_version,
axiom_node_t * parent_node,
- axis2_char_t *token_type)
+ axis2_char_t * token_type)
{
axis2_char_t *wst_ns_uri = NULL;
axiom_node_t *token_type_node = NULL;
axiom_element_t *token_type_ele = NULL;
axiom_namespace_t *wst_ns = NULL;
axis2_status_t status = AXIS2_SUCCESS;
-
+
AXIS2_ENV_CHECK(env, NULL);
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
-
+
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
- token_type_ele = axiom_element_create(env, parent_node, TRUST_TOKEN_TYPE,
wst_ns, &token_type_node);
-
- if(!token_type_ele)
+ token_type_ele =
+ axiom_element_create(env, parent_node, TRUST_TOKEN_TYPE, wst_ns,
&token_type_node);
+
+ if (!token_type_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Element
creation failed.");
return NULL;
}
-
+
status = axiom_element_set_text(token_type_ele, env, token_type,
token_type_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Element's
setting text function failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] TokenType Element's setting text function
failed.");
return NULL;
}
-
- return token_type_node;
+
+ return token_type_node;
}
AXIS2_EXPORT axiom_node_t *AXIS2_CALL
@@ -217,7 +221,7 @@
const axis2_char_t * addressing_ns)
{
axiom_node_t *applies_to_node = NULL;
- axiom_node_t *epr_node = NULL;
+ axiom_node_t *epr_node = NULL;
axiom_node_t *addr_node = NULL;
axiom_element_t *applies_to_ele = NULL;
axiom_element_t *epr_ele = NULL;
@@ -228,72 +232,102 @@
wsp_ns = axiom_namespace_create(env, TRUST_WSP_XMLNS, TRUST_WSP);
wsa_ns = axiom_namespace_create(env, addressing_ns, TRUST_WSA);
-
- applies_to_ele = axiom_element_create(env, parent_node, TRUST_APPLIES_TO,
wsp_ns, &applies_to_node);
- if(!applies_to_ele)
+
+ applies_to_ele =
+ axiom_element_create(env, parent_node, TRUST_APPLIES_TO, wsp_ns,
&applies_to_node);
+ if (!applies_to_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] AppliesTo Element
creation failed!");
return NULL;
}
-
+
epr_ele = axiom_element_create(env, applies_to_node, TRUST_EPR, wsa_ns,
&epr_node);
- if(!epr_ele)
+ if (!epr_ele)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] EndpointReference
Element creation failed!");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] EndpointReference Element creation failed!");
return NULL;
}
-
+
addr_ele = axiom_element_create(env, epr_node, TRUST_EPR_ADDRESS, wsa_ns,
&addr_node);
- if(!addr_ele)
+ if (!addr_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Address Element
creation failed!");
return NULL;
}
-
+
status = axiom_element_set_text(addr_ele, env, address, addr_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Address Element's
setting text function failed.");
- return NULL;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] Address Element's setting text function
failed.");
+ return NULL;
}
-
+
return applies_to_node;
}
AXIS2_EXPORT axiom_node_t *AXIS2_CALL
trust_util_create_claims_element(
const axutil_env_t * env,
+ int wst_version,
axiom_node_t * parent_node,
- axis2_char_t * claims_val,
- axis2_char_t * dialect_uri,
- int version)
+ axiom_node_t * claims_content,
+ axis2_char_t * dialect_uri)
{
axis2_char_t *wst_ns_uri = NULL;
- axiom_node_t *util_claims_node = NULL;
- axiom_element_t *util_claims_ele = NULL;
+ axiom_node_t *claims_node = NULL;
+ axiom_element_t *claims_ele = NULL;
+ axiom_namespace_t *wst_ns = NULL;
+ axiom_attribute_t *dialect_attr = NULL;
+ axis2_status_t status = AXIS2_SUCCESS;
- AXIS2_ENV_CHECK(env, NULL);
+ wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
+ wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
- wst_ns_uri = trust_util_get_wst_ns(env, version);
- util_claims_node =
- trust_util_create_om_node(env, parent_node, wst_ns_uri, TRUST_CLAIMS,
TRUST_WST);
- util_claims_ele = axiom_node_get_data_element(util_claims_node, env);
+ claims_ele = axiom_element_create(env, parent_node, TRUST_CLAIMS, wst_ns,
&claims_node);
+ if (!claims_ele)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims Element
creation failed!");
+ return NULL;
+ }
+ if (claims_content)
+ {
+ status = axiom_node_add_child(claims_node, env, claims_content);
+ if (status == AXIS2_FAILURE)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Claims element
adding child failed.");
+ return NULL;
+ }
+ }
if (dialect_uri)
{
- /* Set Dialect Attribute */
- /* Dialect NS - NULL */
- trust_util_create_attribute(env, util_claims_node, version,
TRUST_CLAIMS_DIALECT,
- dialect_uri, NULL);
- }
+ dialect_attr = axiom_attribute_create(env, TRUST_CLAIMS_DIALECT,
dialect_uri, wst_ns);
+ if (dialect_attr)
+ {
+ status = axiom_element_add_attribute(claims_ele, env,
dialect_attr, claims_node);
+ if (status == AXIS2_FAILURE)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] Claims element adding attribute
failed.");
+ return NULL;
+ }
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Dialect attribute
creation failed.");
+ return NULL;
+ }
- if (claims_val)
+ }
+ else
{
- trust_util_set_node_text(env, util_claims_node, claims_val);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Dialect uri null.");
+ return NULL;
}
- return util_claims_node;
-
+ return claims_node;
}
AXIS2_EXPORT axiom_node_t *AXIS2_CALL
@@ -304,16 +338,19 @@
{
axis2_char_t *wst_ns_uri = NULL;
axiom_node_t *requested_token_node = NULL;
- axiom_element_t *requested_token_ele = NULL;
+ axiom_element_t *requested_token_ele = NULL;
axiom_namespace_t *wst_ns = NULL;
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- requested_token_ele = axiom_element_create(env, parent_node,
TRUST_REQUESTED_SECURITY_TOKEN, wst_ns, &requested_token_node);
- if(!requested_token_ele)
+
+ requested_token_ele =
+ axiom_element_create(env, parent_node, TRUST_REQUESTED_SECURITY_TOKEN,
wst_ns,
+ &requested_token_node);
+ if (!requested_token_ele)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust]
RequestedSecurityToken Element creation failed!");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] RequestedSecurityToken Element creation
failed!");
return NULL;
}
@@ -333,11 +370,14 @@
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- requested_prooft_ele = axiom_element_create(env, parent_node,
TRUST_REQUESTED_PROOF_TOKEN, wst_ns, &requested_prooft_node);
- if(!requested_prooft_ele)
+
+ requested_prooft_ele =
+ axiom_element_create(env, parent_node, TRUST_REQUESTED_PROOF_TOKEN,
wst_ns,
+ &requested_prooft_node);
+ if (!requested_prooft_ele)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedProofToken
Element creation failed!");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] RequestedProofToken Element creation
failed!");
return NULL;
}
@@ -357,9 +397,9 @@
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
+
entropy_ele = axiom_element_create(env, parent_node, TRUST_ENTROPY,
wst_ns, &entropy_node);
- if(!entropy_ele)
+ if (!entropy_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy Element
creation failed!");
return NULL;
@@ -381,9 +421,10 @@
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- computed_key_ele = axiom_element_create(env, parent_node,
TRUST_COMPUTED_KEY, wst_ns, &computed_key_node);
- if(!computed_key_ele)
+
+ computed_key_ele =
+ axiom_element_create(env, parent_node, TRUST_COMPUTED_KEY, wst_ns,
&computed_key_node);
+ if (!computed_key_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] ComputedKey Element
creation failed!");
return NULL;
@@ -410,9 +451,10 @@
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- bin_sec_ele = axiom_element_create(env, parent_node, TRUST_BINARY_SECRET,
wst_ns, &bin_sec_node);
- if(!bin_sec_ele)
+
+ bin_sec_ele =
+ axiom_element_create(env, parent_node, TRUST_BINARY_SECRET, wst_ns,
&bin_sec_node);
+ if (!bin_sec_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] BinarySecret Element
creation failed!");
return NULL;
@@ -422,10 +464,11 @@
{
/* Setting up the encoeded secret */
status = axiom_element_set_text(bin_sec_ele, env, enc_secret,
bin_sec_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] BinarySecret
Element's setting text failed.");
- return NULL;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] BinarySecret Element's setting text
failed.");
+ return NULL;
}
}
@@ -434,20 +477,22 @@
/* Setting up BS-Type attribute */
type_str = axutil_stracat(env, wst_ns_uri, bin_sec_type);
bin_sec_type_attr = axiom_attribute_create(env, ATTR_TYPE, type_str,
NULL);
- if(!bin_sec_type_attr)
+ if (!bin_sec_type_attr)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] BinarySecret
Element's Type attribute creation failed.");
- return NULL;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] BinarySecret Element's Type attribute
creation failed.");
+ return NULL;
}
-
+
status = axiom_element_add_attribute(bin_sec_ele, env,
bin_sec_type_attr, bin_sec_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] BinarySecret
Element's attribute adding failed.");
- return NULL;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] BinarySecret Element's attribute adding
failed.");
+ return NULL;
}
}
-
+
return bin_sec_node;
}
@@ -464,29 +509,33 @@
axiom_namespace_t *wst_ns = NULL;
axis2_char_t *algo = NULL;
axis2_status_t status = AXIS2_SUCCESS;
-
+
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- if(algo_id)
+
+ if (algo_id)
{
- comp_key_algo_ele = axiom_element_create(env, parent_node,
TRUST_COMPUTED_KEY_ALGO, wst_ns, &comp_key_algo_node);
- if(!comp_key_algo_ele)
+ comp_key_algo_ele =
+ axiom_element_create(env, parent_node, TRUST_COMPUTED_KEY_ALGO,
wst_ns,
+ &comp_key_algo_node);
+ if (!comp_key_algo_ele)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust]
ComputedKeyAlgorithm element creation failed.");
- return NULL;
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] ComputedKeyAlgorithm element creation
failed.");
+ return NULL;
}
-
+
algo = axutil_strcat(env, wst_ns_uri, algo_id);
status = axiom_element_set_text(comp_key_algo_ele, env, algo,
comp_key_algo_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust]
ComputedKeyAlgorithm Element's setting text failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] ComputedKeyAlgorithm Element's setting
text failed.");
return NULL;
}
-
+
}
-
+
return comp_key_algo_node;
}
@@ -503,25 +552,26 @@
axiom_element_t *key_size_ele = NULL;
axiom_namespace_t *wst_ns = NULL;
axis2_status_t status = AXIS2_SUCCESS;
-
+
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
key_size_ele = axiom_element_create(env, parent_node, TRUST_KEY_SIZE,
wst_ns, &key_size_node);
- if(!key_size_ele)
+ if (!key_size_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeySize element
creation failed.");
- return NULL;
+ return NULL;
}
-
- if (size)
+
+ if (key_size)
{
status = axiom_element_set_text(key_size_ele, env, key_size,
key_size_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeySize Element's
setting text failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] KeySize Element's setting text failed.");
return NULL;
- }
+ }
}
return key_size_node;
@@ -542,11 +592,11 @@
axis2_char_t *type = NULL;
axis2_status_t status = AXIS2_SUCCESS;
- wst_ns_uri = trust_util_get_wst_ns(env, version);
+ wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
+
key_type_ele = axiom_element_create(env, parent_node, TRUST_KEY_TYPE,
wst_ns, &key_type_node);
- if(!key_type_ele)
+ if (!key_type_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeyType element
creation failed.");
return NULL;
@@ -560,11 +610,12 @@
{
type = axutil_stracat(env, wst_ns_uri, key_type);
status = axiom_element_set_text(key_type_ele, env, type,
key_type_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeyType
Element's setting text failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] KeyType Element's setting text
failed.");
return NULL;
- }
+ }
}
}
@@ -595,8 +646,9 @@
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WSU);
wsu_ns = axiom_namespace_create(env, TRUST_WSU_XMLNS, TRUST_WSU);
-
- life_time_ele = axiom_element_create(env, parent_node, TRUST_LIFE_TIME,
wst_ns, &life_time_node);
+
+ life_time_ele =
+ axiom_element_create(env, parent_node, TRUST_LIFE_TIME, wst_ns,
&life_time_node);
if (life_time_ele)
{
@@ -608,12 +660,13 @@
dt = axutil_date_time_create_with_offset(env, 0);
created_val_str = axutil_date_time_serialize_date_time(dt, env);
status = axiom_element_set_text(created_ele, env, created_val_str,
created_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Created
Element's setting text failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] Created Element's setting text
failed.");
return NULL;
}
-
+
AXIS2_FREE(env->allocator, created_val_str);
axutil_date_time_free(dt, env);
created_val_str = NULL;
@@ -638,12 +691,13 @@
dt = axutil_date_time_create_with_offset(env, ttl);
expires_val_str = axutil_date_time_serialize_date_time(dt, env);
axiom_element_set_text(expires_ele, env, expires_val_str,
expires_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Expires
Element's setting text failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] Expires Element's setting text
failed.");
return NULL;
}
-
+
AXIS2_FREE(env->allocator, expires_val_str);
axutil_date_time_free(dt, env);
expires_val_str = NULL;
@@ -676,39 +730,44 @@
axiom_node_t *attached_ref_node = NULL;
axiom_element_t *attached_ref_ele = NULL;
axiom_namespace_t *wst_ns = NULL;
-
+
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- attached_ref_ele = axiom_element_create(env, parent_node,
TRUST_REQUESTED_ATTACHED_REFERENCE, wst_ns, &attached_ref_node);
- if(!attached_ref_ele)
+
+ attached_ref_ele =
+ axiom_element_create(env, parent_node,
TRUST_REQUESTED_ATTACHED_REFERENCE, wst_ns,
+ &attached_ref_node);
+ if (!attached_ref_ele)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust]
RequestedAttachedReference element creation failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] RequestedAttachedReference element creation
failed.");
return NULL;
}
return attached_ref_node;
}
-
AXIS2_EXPORT axiom_node_t *AXIS2_CALL
trust_util_create_req_unattached_reference_element(
const axutil_env_t * env,
- const int version,
+ int wst_version,
axiom_node_t * parent_node)
{
axis2_char_t *wst_ns_uri = NULL;
axiom_node_t *unattached_ref_node = NULL;
axiom_element_t *unattached_ref_ele = NULL;
axiom_namespace_t *wst_ns = NULL;
-
+
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- unattached_ref_ele = axiom_element_create(env, parent_node,
TRUST_REQUESTED_UNATTACHED_REFERENCE, wst_ns, &unattached_ref_node);
- if(!unattached_ref_ele)
+
+ unattached_ref_ele =
+ axiom_element_create(env, parent_node,
TRUST_REQUESTED_UNATTACHED_REFERENCE, wst_ns,
+ &unattached_ref_node);
+ if (!unattached_ref_ele)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust]
RequestedUnAttachedReference element creation failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] RequestedUnAttachedReference element creation
failed.");
return NULL;
}
@@ -726,20 +785,22 @@
axiom_element_t *encrypted_ele = NULL;
axiom_namespace_t *xenc_ns = NULL;
axis2_status_t status = AXIS2_SUCCESS;
-
+
xenc_ns = axiom_namespace_create(env, TRUST_XENC_XMLNS, TRUST_XENC);
- encrypted_ele = axiom_element_create(env, parent_node,
TRUST_ENCRYPTED_DATA, xenc_ns, &encrypted_node);
- if(!encrypted_ele)
+ encrypted_ele =
+ axiom_element_create(env, parent_node, TRUST_ENCRYPTED_DATA, xenc_ns,
&encrypted_node);
+ if (!encrypted_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] EncryptedData element
creation failed.");
return NULL;
}
- if(enc_data)
+ if (enc_data)
{
status = axiom_element_set_text(encrypted_ele, env, enc_data,
encrypted_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Encrypted Data
Element's setting text failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] Encrypted Data Element's setting text
failed.");
return NULL;
}
}
@@ -752,7 +813,7 @@
const axutil_env_t * env,
int wst_version,
axiom_node_t * parent_node,
- axiom_node_t * token_renew_pending_node)
+ axiom_node_t * renew_pending_node)
{
axiom_node_t *renew_target_node = NULL;
axiom_element_t *renew_target_ele = NULL;
@@ -762,20 +823,22 @@
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- renew_target_ele = axiom_element_create(env, parent_node,
TRUST_RENEW_TARGET, wst_ns, &renew_target_node);
- if(!renew_target_ele)
+
+ renew_target_ele =
+ axiom_element_create(env, parent_node, TRUST_RENEW_TARGET, wst_ns,
&renew_target_node);
+ if (!renew_target_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RenewTarget element
creation failed.");
return NULL;
}
- if (token_renew_pending_node)
+ if (renew_pending_node)
{
/* Set up token as it is for the request */
status = axiom_node_add_child(renew_target_node, env,
renew_pending_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] token renew
pending node adding as a child failed.");
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] token renew pending node adding as a
child failed.");
}
}
@@ -796,12 +859,14 @@
axiom_node_t *allow_postdating_node = NULL;
axiom_element_t *allow_postdating_ele = NULL;
axiom_namespace_t *wst_ns = NULL;
-
+
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
- allow_postdating_ele = axiom_element_create(env, parent_node,
TRUST_REQUESTED_UNATTACHED_REFERENCE, wst_ns, &allow_postdating_node);
- if(!allow_postdating_ele)
+
+ allow_postdating_ele =
+ axiom_element_create(env, parent_node,
TRUST_REQUESTED_UNATTACHED_REFERENCE, wst_ns,
+ &allow_postdating_node);
+ if (!allow_postdating_ele)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] AllowPostdating
element creation failed.");
return NULL;
@@ -825,37 +890,152 @@
axiom_attribute_t *allow_attr = NULL;
axiom_attribute_t *ok_attr = NULL;
axis2_status_t status = AXIS2_SUCCESS;
+ axis2_char_t *allow = NULL;
+ axis2_char_t *ok = NULL;
wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
-
+
renewing_ele = axiom_element_create(env, parent_node, TRUST_RENEWING,
wst_ns, &renewing_node);
- allow_attr = axiom_attribute_create(env, TRUST_RENEW_ALLOW_ATTR,
allow_attr, wst_ns);
- ok_attr = axiom_attribute_create(env, TRUST_RENEW_OK_ATTR, ok_flag,
wst_ns);
-
+ sprintf(allow, "%d", allow_flag);
+ sprintf(ok, "%d", ok_flag);
+
+ allow_attr = axiom_attribute_create(env, TRUST_RENEW_ALLOW_ATTR, allow,
wst_ns);
+ ok_attr = axiom_attribute_create(env, TRUST_RENEW_OK_ATTR, ok, wst_ns);
+
status = axiom_element_add_attribute(renewing_ele, env, allow_attr,
renewing_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Allow attribute
setting failed.");
}
status = axiom_element_add_attribute(renewing_ele, env, ok_attr,
renewing_node);
- if(status == AXIS2_FAILURE)
+ if (status == AXIS2_FAILURE)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Ok attribute setting
failed.");
}
-
+
return renewing_node;
}
+AXIS2_EXPORT axiom_node_t *AXIS2_CALL
+trust_util_create_cancel_target_element(
+ const axutil_env_t * env,
+ int wst_version,
+ axiom_node_t * parent_node,
+ axiom_node_t * token_cancel_pending_node)
+{
+ axiom_node_t *cancel_target_node = NULL;
+ axiom_element_t *cancel_target_ele = NULL;
+ axis2_char_t *wst_ns_uri = NULL;
+ axiom_namespace_t *wst_ns = NULL;
+
+ wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
+ wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
+
+ cancel_target_ele =
+ axiom_element_create(env, parent_node, TRUST_CANCEL_TARGET, wst_ns,
&cancel_target_node);
+ if (!cancel_target_ele)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] CancelTarget element
creation failed.");
+ return NULL;
+ }
+
+ if (token_cancel_pending_node)
+ {
+ /* Set up token as it is for the request */
+ axiom_node_add_child(cancel_target_node, env,
token_cancel_pending_node);
+ }
+
+ /** Otherwise user has to create a STR as a child ot CancelTarget element
and
+ * add the token reference to it.
+ **/
+ return cancel_target_node;
+
+}
+
+AXIS2_EXPORT axiom_node_t *AXIS2_CALL
+trust_util_create_validation_response_element(
+ const axutil_env_t * env,
+ axiom_node_t * parent_node,
+ int wst_version,
+ axis2_char_t * code,
+ axis2_char_t * reason)
+{
+ axis2_char_t *wst_ns_uri = NULL;
+ axiom_node_t *status_node = NULL;
+ axiom_node_t *code_node = NULL;
+ axiom_node_t *reason_node = NULL;
+ axiom_element_t *status_ele = NULL;
+ axiom_element_t *code_ele = NULL;
+ axiom_element_t *reason_ele = NULL;
+ axiom_namespace_t *wst_ns = NULL;
+ axis2_status_t status = AXIS2_SUCCESS;
+
+ wst_ns_uri = trust_util_get_wst_ns(env, wst_version);
+ wst_ns = axiom_namespace_create(env, wst_ns_uri, TRUST_WST);
+
+ status_ele =
+ axiom_element_create(env, parent_node, TRUST_VALIDATION_STATUS,
wst_ns, &status_node);
+ if (status_ele)
+ {
+ if (code)
+ {
+ code_ele =
+ axiom_element_create(env, status_node, TRUST_VALIDATION_CODE,
wst_ns, &code_node);
+ if (!code_ele)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Code element
creation failed.");
+ return NULL;
+ }
+ status = axiom_element_set_text(code_ele, env, code, code_node);
+ if (status == AXIS2_FAILURE)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] Code element text setting failed.");
+ return NULL;
+ }
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Code string
null.");
+ return NULL;
+ }
+
+ if (reason)
+ {
+ reason_ele =
+ axiom_element_create(env, status_node,
TRUST_VALIDATION_REASON, wst_ns,
+ &reason_node);
+ if (!reason_ele)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Reason
element creation failed.");
+ return NULL;
+ }
+ status = axiom_element_set_text(reason_ele, env, reason,
reason_node);
+ if (status == AXIS2_FAILURE)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "[trust] Reason element text setting failed.");
+ return status_node;
+ }
+ }
+ }
+ else
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Status element
creation failed.");
+ return NULL;
+ }
+
+ return status_node;
+}
+
axis2_char_t *AXIS2_CALL
trust_util_get_wst_ns(
const axutil_env_t * env,
- const int version)
+ int wst_version)
{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- switch (version)
+ switch (wst_version)
{
case TRUST_VERSION_05_02:
return axutil_strdup(env, TRUST_WST_XMLNS_05_02);
@@ -864,4 +1044,4 @@
default:
return NULL;
}
-}
\ No newline at end of file
+}
