Added: webservices/rampart/scratch/c/fed/c/src/fed/fed_metadata_om.c URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/fed/c/src/fed/fed_metadata_om.c?rev=642897&view=auto ============================================================================== --- webservices/rampart/scratch/c/fed/c/src/fed/fed_metadata_om.c (added) +++ webservices/rampart/scratch/c/fed/c/src/fed/fed_metadata_om.c Sun Mar 30 23:25:17 2008 @@ -0,0 +1,912 @@ +/* + * 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 <fed_metadata_om.h> + +struct fed_metadata_om +{ + /* Metadata Context Node . full node for a single federation*/ + axiom_node_t *metadata_om_node; + + /* Federation ID : unique for a given federation*/ + axis2_char_t *federation_id; + + /* The key that is used to sign the tokens issued by the metadata owner*/ + axiom_node_t *token_signing_key_info_node; + axis2_char_t *token_signing_key; + + /* The key that is used to encrypt key and key materials*/ + axiom_node_t *token_key_transfer_key_info_node; + axis2_char_t *token_key_transfer_key; + + /*Token issuers logical name*/ + axis2_char_t *token_issuer_name; + + /* Indicate a set logical names associated with the issuer*/ + axutil_array_list_t *issuer_names_offered_list; + + /* Allows a federation metadata provider to specify the end point [STS] that can be used to + * get sec tokens to consume metadata provider*/ + axis2_char_t *token_issuer_end_point; + + /* Allows a federation metadata provider to specify the end point address of the pseudonym service */ + axis2_char_t *pseudonym_service_end_point; + + /* Allows a federation metadata provider to specify the end point address of the attribute service */ + axis2_char_t *attribute_service_end_point; + + /* Allows a federation metadata provider to specify the end point address of its subscription service that is used to subscribe to + * fed sign out*/ + axis2_char_t *single_signout_subscription_end_point; + + /* Allows a federation metadata provider to specify the endpoint address to which push notifications of sign-out are to be sent*/ + axis2_char_t *single_signout_notification_end_point; + + /* Allows a metadata provider to specify the list of token types offered by its sts */ + axutil_array_list_t *token_types_offered_list; + + + /* Allows a metadata provider to specify list of publicly offered claim types that can be asserted in sec tokens issued by its STS */ + axutil_array_list_t *uri_named_claim_types_offered_list; /* Set of axiom_nodes - <ClaimType URI="id"> <DisplayName><Description> ...*/ + + /* xs:boolean */ + int automatic_pseudonyms_element; + + + /* Generic Implementations for various key types e.g. x509, RSA etc*/ + /* Function pointers*/ + + /* TokenSigningKey : fp*/ + /*Extract Key*/ + axis2_char_t* (AXIS2_CALL *extract_token_signing_key) (fed_metadata_om_t *metadata_om, const axutil_env_t * env); + /*Build OM*/ + axiom_node_t* (AXIS2_CALL *build_token_signing_info) (fed_metadata_om_t *metadata_om, axis2_char_t *token_signing_key, const axutil_env_t * env); + + /*TokenKeyTransferKey : fp*/ + /*Extract Key*/ + axis2_char_t* (AXIS2_CALL *extract_token_key_transfer_key_info) (fed_metadata_om_t *metadata_om, const axutil_env_t * env); + /* Build OM*/ + axiom_node_t* (AXIS2_CALL *build_token_key_transfer_key_info) (fed_metadata_om_t *metadata_om, + axis2_char_t *token_key_transfer_key, const axutil_env_t * env); + +}; + +AXIS2_EXTERN fed_metadata_om_t* AXIS2_CALL +fed_metadata_om_create( + axiom_node_t *metadata_node, + const axutil_env_t * env) +{ + fed_metadata_om_t *metadata_om = NULL; + AXIS2_ENV_CHECK(env, NULL); + + metadata_om = (fed_metadata_om_t *) AXIS2_MALLOC(env->allocator, sizeof(fed_metadata_om_t)); + + + if(!metadata_om) + { + return NULL; + } + /*Initializations*/ + metadata_om->metadata_om_node = metadata_node; + metadata_om->extract_token_signing_key = NULL; + metadata_om->build_token_signing_info = NULL; + metadata_om->extract_token_key_transfer_key_info = NULL; + metadata_om->build_token_key_transfer_key_info = NULL; + + /* Create Array List*/ + metadata_om->token_types_offered_list = axutil_array_list_create(env, 5); + metadata_om->issuer_names_offered_list = axutil_array_list_create(env, 5); + metadata_om->uri_named_claim_types_offered_list = axutil_array_list_create(env, 5); + + return metadata_om; +} + +AXIS2_EXTERN void AXIS2_CALL +fed_metadata_om_free( + fed_metadata_om_t *metadata_om, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + + if(metadata_om) + { + AXIS2_FREE(env->allocator, metadata_om); + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +fed_metadata_om_populate_metadata( + fed_metadata_om_t *metadata_om, + const axutil_env_t * env) +{ + /*Metadata Context*/ + axiom_element_t *metadata_om_element = NULL; + + /*TokenSigningKeyInfo*/ + axiom_node_t *token_signing_key_info_node = NULL; + axiom_element_t *token_signing_key_info_element = NULL; + axutil_qname_t *token_signing_key_info_qname = NULL; + + /*TokenSigningKeyTransferKeyInfo*/ + axiom_node_t *token_key_transfer_key_info_node = NULL; + axiom_element_t *token_key_transfer_key_info_element = NULL; + axutil_qname_t *token_key_transfer_key_info_qname = NULL; + + /*IssuerName*/ + axiom_node_t *token_issuer_name_node = NULL; + axiom_element_t *token_issuer_name_element = NULL; + axutil_qname_t *token_issuer_name_qname = NULL; + + /*TokenIssuerEndPoint*/ + axiom_node_t *token_issuer_endpoint_node = NULL; + axiom_element_t *token_issuer_endpoint_element = NULL; + axutil_qname_t *token_issuer_endpoint_qname = NULL; + axutil_qname_t *token_issuer_endpoint_addr_qname = NULL; + axiom_node_t *token_issuer_endpoint_addr_node = NULL; + axiom_element_t *token_issuer_endpoint_addr_element = NULL; + + /*TokenTypesOffered*/ + axiom_node_t *token_types_offered_node = NULL; + axiom_element_t *token_types_offered_element = NULL; + axutil_qname_t *token_types_offered_qname = NULL; + axiom_children_qname_iterator_t *token_types_offered_qname_iter = NULL; + axutil_qname_t *token_type_qname = NULL; + axiom_node_t *token_type_node = NULL; + axiom_element_t *token_type_element = NULL; + axutil_qname_t *token_type_uri_attr_qname = NULL; + + /*IssuerNamedOffered*/ + axiom_node_t *issuer_names_offered_node = NULL; + axiom_element_t *issuer_names_offered_element = NULL; + axutil_qname_t *issuer_names_offered_qname = NULL; + axiom_children_qname_iterator_t *issuer_names_offered_qname_iter = NULL; + axutil_qname_t *issuer_name_qname = NULL; + axiom_node_t *issuer_name_node = NULL; + axiom_element_t *issuer_name_element = NULL; + axutil_qname_t *issuer_name_uri_attr_qname = NULL; + + /*UriNamedClaimTypesOffered*/ + axiom_node_t *uri_named_claim_types_offered_node = NULL; + axiom_element_t *uri_named_claim_types_offered_element = NULL; + axutil_qname_t *uri_named_claim_types_offered_qname = NULL; + axiom_children_qname_iterator_t *uri_named_claim_types_qname_iter = NULL; + fed_metadata_claim_type_t *uri_named_claim_type = NULL; + + + + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + if(metadata_om->metadata_om_node) + { + metadata_om_element = (axiom_element_t *) + (axiom_node_get_data_element(metadata_om->metadata_om_node, env)); + + /*Get Federation ID*/ + metadata_om->federation_id = axiom_element_get_attribute_value_by_name( metadata_om_element, env, + FED_ATTR_FED_ID); + + + /*TokenKeySigningInfo*/ + token_signing_key_info_qname = axutil_qname_create(env, FED_TOKEN_SIGNING_KEY_INFO, + FED_FED_XML_NS, FED_WSF); + token_signing_key_info_element = axiom_element_get_first_child_with_qname(metadata_om_element, + env, token_signing_key_info_qname, metadata_om->metadata_om_node, &token_signing_key_info_node); + /* Set TokenSigningInfoNode */ + metadata_om->token_signing_key_info_node = token_signing_key_info_node; + /* Process TokenSigningInfoNode and extract the key : using call back fn*/ + if(metadata_om->extract_token_signing_key) + { + /*Set Key value*/ + metadata_om->token_signing_key = metadata_om->extract_token_signing_key(metadata_om, env); + } + + /*TokenKeyTransferKeyInfo*/ + token_key_transfer_key_info_qname = axutil_qname_create(env, FED_TOKEN_KEY_TRANSFER_KEY_INFO, + FED_FED_XML_NS, FED_WSF); + token_key_transfer_key_info_element = axiom_element_get_first_child_with_qname(metadata_om_element, + env, token_key_transfer_key_info_qname, + metadata_om->metadata_om_node, &token_key_transfer_key_info_node); + metadata_om->token_key_transfer_key_info_node = token_key_transfer_key_info_node; + + if(metadata_om->extract_token_key_transfer_key_info) + { + metadata_om->token_key_transfer_key = metadata_om->extract_token_key_transfer_key_info( + metadata_om, env); + } + + /*TokenIssuerName*/ + token_issuer_name_qname = axutil_qname_create(env, FED_TOKEN_ISSUER_NAME, FED_FED_XML_NS, FED_WSF); + token_issuer_name_element = axiom_element_get_first_child_with_qname(metadata_om_element, + env, token_issuer_name_qname, metadata_om->metadata_om_node, &token_issuer_name_node); + if (token_issuer_name_node) + { + metadata_om->token_issuer_name = axiom_element_get_text(token_issuer_name_element, + env, token_issuer_name_node); + } + + /*TokenIssuerEndpoint*/ + token_issuer_endpoint_qname = axutil_qname_create(env, FED_TOKEN_ISSUER_END_POINT, FED_FED_XML_NS, FED_WSF); + token_issuer_endpoint_element = axiom_element_get_first_child_with_qname(metadata_om_element, + env, token_issuer_endpoint_qname, metadata_om->metadata_om_node, &token_issuer_endpoint_node); + if (token_issuer_endpoint_node) + { + + token_issuer_endpoint_addr_qname = axutil_qname_create(env, FED_WSA_ADDRESS, FED_WSA_XMLNS, FED_WSA); + token_issuer_endpoint_addr_element = axiom_element_get_first_child_with_qname(token_issuer_endpoint_element, + env, token_issuer_endpoint_addr_qname, token_issuer_endpoint_node, &token_issuer_endpoint_addr_node); + + metadata_om->token_issuer_end_point = axiom_element_get_text(token_issuer_endpoint_addr_element, + env, token_issuer_endpoint_addr_node); + } + + + /*PseudonymServiceEndpoint*/ + + /*AttributeServiceEndpoint*/ + + /*SingleSignOutSubscripionEndpoint*/ + + /*SingleSignOutNotificationEndpoint*/ + + + /*TokenTypesOffered*/ + token_types_offered_qname = axutil_qname_create(env, FED_TOKEN_TYPES_OFFERED, FED_FED_XML_NS, FED_WSF); + token_types_offered_element = axiom_element_get_first_child_with_qname(metadata_om_element, + env, token_types_offered_qname, metadata_om->metadata_om_node, &token_types_offered_node); + + if(token_types_offered_node) + { + token_type_qname = axutil_qname_create(env, FED_TOKEN_TYPE, FED_FED_XML_NS, FED_WSF); + token_types_offered_qname_iter = axiom_element_get_children_with_qname(token_types_offered_element, + env, token_type_qname, token_types_offered_node); + + while(axiom_children_qname_iterator_has_next(token_types_offered_qname_iter, env)) + { + token_type_node = axiom_children_qname_iterator_next(token_types_offered_qname_iter, env); + + if(axiom_node_get_node_type(token_type_node, env) == AXIOM_ELEMENT) + { + token_type_element = axiom_node_get_data_element(token_type_node, env); + + if(token_type_element) + { + token_type_uri_attr_qname = axutil_qname_create(env, + FED_ATTR_TOKEN_TYPE_URI, FED_FED_XML_NS, FED_WSF); + axutil_array_list_add(metadata_om->token_types_offered_list, env, + axiom_element_get_attribute_value_by_name( token_type_element, env, + FED_ATTR_TOKEN_TYPE_URI)); + } + + } + } + + } + + /*IssuerNamesOffered*/ + issuer_names_offered_qname = axutil_qname_create(env, FED_ISSER_NAMES_OFFERED, FED_FED_XML_NS, FED_WSF); + issuer_names_offered_element = axiom_element_get_first_child_with_qname(metadata_om_element, + env, issuer_names_offered_qname, metadata_om->metadata_om_node, &issuer_names_offered_node); + if(issuer_names_offered_node) + { + issuer_name_qname = axutil_qname_create(env, FED_ISSER_NAMES_OFFERED_ISSUER_NAME, FED_FED_XML_NS, FED_WSF); + issuer_names_offered_qname_iter = axiom_element_get_children_with_qname(issuer_names_offered_element, + env, issuer_name_qname, issuer_names_offered_node); + while(axiom_children_qname_iterator_has_next(issuer_names_offered_qname_iter, env)) + { + issuer_name_node = axiom_children_qname_iterator_next(issuer_names_offered_qname_iter, env); + if(axiom_node_get_node_type(issuer_name_node, env) == AXIOM_ELEMENT) + { + issuer_name_element = axiom_node_get_data_element(issuer_name_node, env); + if(issuer_name_element) + { + issuer_name_uri_attr_qname = axutil_qname_create(env, + FED_ATTR_URI, FED_FED_XML_NS, FED_WSF); + axutil_array_list_add(metadata_om->issuer_names_offered_list, env, + axiom_element_get_attribute_value_by_name( issuer_name_element, env, + FED_ATTR_URI)); + } + } + } + } + + /*UriNamedClaimTypesOffered*/ + uri_named_claim_types_offered_qname = axutil_qname_create(env, FED_URI_NAMED_CLAIM_TYPES_OFFERED, + FED_FED_XML_NS, FED_WSF); + uri_named_claim_types_offered_element = axiom_element_get_first_child_with_qname(metadata_om_element, + env, uri_named_claim_types_offered_qname, metadata_om->metadata_om_node, + &uri_named_claim_types_offered_node); + + if(uri_named_claim_types_offered_node) + { + axiom_node_t *claim_type_node = NULL; + axiom_element_t *claim_type_element = NULL; + axiom_node_t *display_name_node = NULL; + axiom_element_t *display_name_element = NULL; + axiom_node_t *description_node = NULL; + axiom_element_t *description_element = NULL; + axutil_qname_t *claim_type_qname = NULL; + axutil_qname_t *claim_type_uri_attr_qname = NULL; + axutil_qname_t *display_name_qname = NULL; + axutil_qname_t *description_qname = NULL; + + /*creating claim type object*/ + uri_named_claim_types_offered_qname = axutil_qname_create(env, FED_URI_NAMED_CLAIM_TYPES_OFFERED, + FED_FED_XML_NS, FED_WSF); + + claim_type_qname = axutil_qname_create(env, FED_URI_NAMED_CLAIM_TYPE, FED_FED_XML_NS, FED_WSF); + + uri_named_claim_types_qname_iter = axiom_element_get_children_with_qname( + uri_named_claim_types_offered_element, + env, claim_type_qname, uri_named_claim_types_offered_node); + + /*Iterating through the claim type elements */ + while(axiom_children_qname_iterator_has_next(uri_named_claim_types_qname_iter, env)) + { + claim_type_node = axiom_children_qname_iterator_next(uri_named_claim_types_qname_iter, env); + if(axiom_node_get_node_type(claim_type_node, env) == AXIOM_ELEMENT) + { + claim_type_element = axiom_node_get_data_element(claim_type_node, env); + if(claim_type_element) + { + /*Creating Claim Type object*/ + uri_named_claim_type = AXIS2_MALLOC(env->allocator, sizeof(fed_metadata_claim_type_t)); + uri_named_claim_type->claim_type_uri_attr = NULL; + uri_named_claim_type->display_name = NULL; + uri_named_claim_type->description = NULL; + + if(uri_named_claim_type) + { + /*Processing The Uri Attribute*/ + claim_type_uri_attr_qname = axutil_qname_create(env, FED_ATTR_URI, FED_FED_XML_NS, FED_WSF); + uri_named_claim_type->claim_type_uri_attr = axiom_element_get_attribute_value_by_name( + claim_type_element, env, + FED_ATTR_URI); + /*Processing DisplayName element*/ + display_name_qname = axutil_qname_create(env, FED_URI_NAMED_CLAIM_TYPE_DISPLAY_NAME, + FED_FED_XML_NS, FED_WSF); + display_name_element = axiom_element_get_first_child_with_qname(claim_type_element, + env, display_name_qname, + claim_type_node, &display_name_node); + if(display_name_node) + { + uri_named_claim_type->display_name = axiom_element_get_text(display_name_element, + env, display_name_node); + } + + /*Processing Description element*/ + description_qname = axutil_qname_create(env, FED_URI_NAMED_CLAIM_TYPE_DESCRIPTION, + FED_FED_XML_NS, FED_WSF); + description_element = axiom_element_get_first_child_with_qname(claim_type_element, + env, description_qname, claim_type_node, &description_node); + if(description_node) + { + uri_named_claim_type->description = axiom_element_get_text(description_element, + env, description_node); + } + + /*Add UriClaimType object to the UriNamedClaimType list*/ + axutil_array_list_add(metadata_om->uri_named_claim_types_offered_list, env, + uri_named_claim_type); + + } + + } + } + } + } + } +} + + +/*Build FED Context OM*/ +AXIS2_EXTERN axiom_node_t* AXIS2_CALL +fed_metadata_om_build_metadata_om( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + axiom_node_t *federation_node = NULL; + axiom_element_t *federation_element = NULL; + axiom_namespace_t *wsf_ns = NULL; + axiom_attribute_t *fed_id_attr = NULL; + + axiom_node_t *token_issuer_name_node = NULL; + axiom_element_t *token_issuer_name_element = NULL; + + axiom_node_t *token_issuer_endpoint_node = NULL; + axiom_element_t *token_issuer_endpoint_element = NULL; + axiom_node_t *token_issuer_endpoint_addr_node = NULL; + axiom_element_t *token_issuer_endpoint_addr_element = NULL; + axiom_namespace_t *wsa_ns = NULL; + + axiom_node_t *token_types_offered_node = NULL; + axiom_element_t *token_types_offered_element = NULL; + + axiom_node_t *issuer_names_offered_node = NULL; + axiom_element_t *issuer_names_offered_element = NULL; + + axiom_node_t *uri_named_claim_types_offered_node = NULL; + axiom_element_t *uri_named_claim_types_offered_element = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + if(metadata_om->federation_id) + { + wsf_ns = axiom_namespace_create(env, FED_FED_XML_NS, FED_WSF); + federation_element = axiom_element_create(env, NULL, FED_FEDERATION, wsf_ns, &federation_node); + fed_id_attr = axiom_attribute_create(env, FED_ATTR_FED_ID, metadata_om->federation_id, NULL); + axiom_element_add_attribute(federation_element, env, fed_id_attr, federation_node); + + /*Token Key Signing Info*/ + if(metadata_om->token_signing_key) + { + if(metadata_om->build_token_signing_info) + { + axiom_node_t *token_siging_info_node = NULL; + /*Callback function to create the token signing key element*/ + token_siging_info_node =metadata_om->build_token_signing_info(metadata_om, + (axis2_char_t*)metadata_om->token_signing_key, env); + + if(token_siging_info_node) + axiom_node_add_child(federation_node, env, token_siging_info_node); + } + } + + /*TokenIssuerName*/ + if(metadata_om->token_issuer_name) + { + token_issuer_name_element = axiom_element_create(env, federation_node, FED_TOKEN_ISSUER_NAME, + wsf_ns, &token_issuer_name_node); + axiom_element_set_text(token_issuer_name_element, env, + metadata_om->token_issuer_name, token_issuer_name_node); + } + + /*TokenIssuerEndPoint*/ + if(metadata_om->token_issuer_end_point) + { + token_issuer_endpoint_element = axiom_element_create(env, federation_node, FED_TOKEN_ISSUER_END_POINT, + wsf_ns, &token_issuer_endpoint_node); + + wsa_ns = axiom_namespace_create(env, FED_WSA_XMLNS, FED_WSA); + + token_issuer_endpoint_addr_element = axiom_element_create(env, token_issuer_endpoint_node, + FED_WSA_ADDRESS, wsa_ns, &token_issuer_endpoint_addr_node); + axiom_element_set_text(token_issuer_endpoint_addr_element, env, metadata_om->token_issuer_end_point, + token_issuer_endpoint_addr_node); + } + + /*TokenTypesOffered*/ + if(metadata_om->token_types_offered_list) + { + axiom_node_t *token_type_node = NULL; + axiom_element_t *token_type_element = NULL; + axiom_attribute_t *token_type_uri_attr = NULL; + int list_size = 0; + int index = 0; + + list_size = axutil_array_list_size( metadata_om->token_types_offered_list, env); + + token_types_offered_element = axiom_element_create(env, federation_node, FED_TOKEN_TYPES_OFFERED, + wsf_ns, &token_types_offered_node); + for(index = 0; index < list_size; index++) + { + token_type_element = axiom_element_create(env, token_types_offered_node, FED_TOKEN_TYPE, + wsf_ns, &token_type_node); + token_type_uri_attr = axiom_attribute_create(env, FED_ATTR_TOKEN_TYPE_URI, + (axis2_char_t*)axutil_array_list_get(metadata_om->token_types_offered_list, env, index), + wsf_ns); + axiom_element_add_attribute(token_type_element, env, token_type_uri_attr, token_type_node); + } + + + } + + /* IssuerNamesOffered*/ + if(metadata_om->issuer_names_offered_list) + { + axiom_node_t *issuer_name_node = NULL; + axiom_element_t *issuer_name_element = NULL; + axiom_attribute_t *issuer_name_uri_attr = NULL; + int list_size = 0; + int index = 0; + + list_size = axutil_array_list_size( metadata_om->issuer_names_offered_list, env); + issuer_names_offered_element = axiom_element_create(env, federation_node, FED_ISSER_NAMES_OFFERED, + wsf_ns, &issuer_names_offered_node); + for(index = 0; index < list_size; index++) + { + issuer_name_element = axiom_element_create(env, issuer_names_offered_node, + FED_ISSER_NAMES_OFFERED_ISSUER_NAME, + wsf_ns, &issuer_name_node); + issuer_name_uri_attr = axiom_attribute_create(env, + FED_ATTR_URI, + (axis2_char_t*)axutil_array_list_get(metadata_om->issuer_names_offered_list, env, index), + NULL); + axiom_element_add_attribute(issuer_name_element, env, issuer_name_uri_attr, issuer_name_node); + } + } + + /*UriNamedClaimTypes*/ + if(metadata_om->uri_named_claim_types_offered_list) + { + fed_metadata_claim_type_t *uri_named_claim_type; + axiom_node_t *claim_type_node = NULL; + axiom_element_t *claim_type_element = NULL; + axiom_attribute_t *claim_type_uri_attr = NULL; + axiom_node_t *display_name_node = NULL; + axiom_element_t *display_name_element = NULL; + axiom_node_t *description_node = NULL; + axiom_element_t *description_element = NULL; + int list_size = 0; + int index = 0; + + + list_size = axutil_array_list_size( metadata_om->uri_named_claim_types_offered_list, env); + uri_named_claim_types_offered_element = axiom_element_create(env, federation_node, + FED_URI_NAMED_CLAIM_TYPES_OFFERED, + wsf_ns, &uri_named_claim_types_offered_node); + for(index = 0; index < list_size; index++) + { + claim_type_element = axiom_element_create(env, uri_named_claim_types_offered_node, + FED_URI_NAMED_CLAIM_TYPE, + wsf_ns, &claim_type_node); + + uri_named_claim_type = (fed_metadata_claim_type_t*)axutil_array_list_get( + metadata_om->uri_named_claim_types_offered_list, env, index); + if(uri_named_claim_type) + { + if(uri_named_claim_type->claim_type_uri_attr) + { + claim_type_uri_attr = axiom_attribute_create(env, FED_ATTR_URI, + uri_named_claim_type->claim_type_uri_attr, NULL); + axiom_element_add_attribute(claim_type_element, env, claim_type_uri_attr, claim_type_node); + } + if(uri_named_claim_type->display_name) + { + display_name_element = axiom_element_create(env, claim_type_node, FED_URI_NAMED_CLAIM_TYPE_DISPLAY_NAME, + wsf_ns, &display_name_node); + axiom_element_set_text(display_name_element, env, + uri_named_claim_type->display_name, display_name_node); + } + if(uri_named_claim_type->description) + { + description_element = axiom_element_create(env, claim_type_node, FED_URI_NAMED_CLAIM_TYPE_DESCRIPTION, + wsf_ns, &description_node); + axiom_element_set_text(description_element, env, + uri_named_claim_type->description, description_node); + + } + } + + } + } + } + + if(!federation_element) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[fed]Build Fed Context Failed"); + return NULL; + } + + + return federation_node; + +} + +AXIS2_EXTERN axis2_char_t* AXIS2_CALL +fed_metadata_om_get_token_signing_key( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if(metadata_om) + return metadata_om->token_signing_key; + return NULL; +} + +AXIS2_EXTERN axis2_char_t* AXIS2_CALL +fed_metadata_om_get_federation_id( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if(metadata_om) + { + return metadata_om->federation_id; + } + return NULL; + +} + +AXIS2_EXTERN axiom_node_t* AXIS2_CALL +fed_metadata_om_get_metadata_node( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if(metadata_om) + { + return metadata_om->metadata_om_node; + } + return NULL; +} + + + +AXIS2_EXTERN axis2_char_t* AXIS2_CALL +fed_metadata_om_get_token_issuer_name( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if(metadata_om) + { + return metadata_om->token_issuer_name; + } + return NULL; +} + +AXIS2_EXTERN axis2_char_t * AXIS2_CALL +fed_metadata_om_get_token_issuer_epr(fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if (metadata_om) + { + return metadata_om->token_issuer_end_point; + } + return NULL; +} + +AXIS2_EXTERN axutil_array_list_t* AXIS2_CALL +fed_metadata_om_get_token_types_offered_list( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if(metadata_om) + { + return metadata_om->token_types_offered_list; + } + return NULL; +} + +AXIS2_EXTERN axiom_node_t* AXIS2_CALL +fed_metadata_om_get_token_signing_info_node( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if(metadata_om) + { + return metadata_om->token_signing_key_info_node; + } +} + +AXIS2_EXTERN axiom_node_t* AXIS2_CALL +fed_metadata_om_get_token_key_transfer_key_info_node( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env) +{ + if(metadata_om) + { + return metadata_om->token_key_transfer_key_info_node; + } +} + + + +/*Setters*/ +AXIS2_EXTERN void AXIS2_CALL +fed_metadata_om_set_token_signing_key( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env, + axis2_char_t *signing_key) +{ + if(metadata_om) + { + metadata_om->token_signing_key = signing_key; + return; + } + +} + + + /*Set Function Pointers*/ +AXIS2_EXTERN void AXIS2_CALL +fed_metadata_om_set_process_token_key_signing_info_fp( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env, + void *processing_logic_fp) +{ + if(metadata_om) + { + metadata_om->extract_token_signing_key = processing_logic_fp; + return; + } +} + +AXIS2_EXTERN void AXIS2_CALL +fed_metadata_om_set_build_token_key_signing_info_fp( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env, + void *build_logic_fp) +{ + if(metadata_om) + { + metadata_om->build_token_signing_info = build_logic_fp; + } +} + +AXIS2_EXTERN void AXIS2_CALL +fed_metadata_om_set_process_token_key_transfer_key_info_fp( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env, + void *processing_logic_fp) +{ + if(metadata_om) + { + metadata_om->extract_token_key_transfer_key_info = processing_logic_fp; + } +} + + AXIS2_EXTERN void AXIS2_CALL + fed_metadata_om_set_build_token_key_transfer_key_info_fp( + fed_metadata_om_t *metadata_om, + const axutil_env_t *env, + void *build_logic_fp) +{ + if(metadata_om) + { + metadata_om->build_token_key_transfer_key_info = build_logic_fp; + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +fed_metadata_om_set_token_issuer_epr(fed_metadata_om_t *metadata_om, + const axutil_env_t *env, + axis2_char_t *epr) +{ + if (!metadata_om) + { + return AXIS2_FAILURE; + } + if (metadata_om->token_issuer_end_point) + { + AXIS2_FREE(metadata_om->token_issuer_end_point); + } + metadata_om->token_issuer_end_point = axis2_strdup(env, epr); + return AXIS2_SUCCESS; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Added: webservices/rampart/scratch/c/fed/c/src/fed/test_main.c URL: http://svn.apache.org/viewvc/webservices/rampart/scratch/c/fed/c/src/fed/test_main.c?rev=642897&view=auto ============================================================================== --- webservices/rampart/scratch/c/fed/c/src/fed/test_main.c (added) +++ webservices/rampart/scratch/c/fed/c/src/fed/test_main.c Sun Mar 30 23:25:17 2008 @@ -0,0 +1,143 @@ +/* Test main for Federation Metadata */ + +#include <stdio.h> + +#include <axiom_xml_reader.h> +#include <axiom.h> +#include <axutil_utils.h> + +#include <fed_federation_metadata.h> + +axis2_char_t* AXIS2_CALL token_signing_key_test (fed_metadata_om_t *metadata_om, const axutil_env_t * env); + + +int main() +{ + axutil_env_t * env = axutil_env_create_all("jaxc.log",4); + axiom_xml_reader_t *xml_reader = NULL; + axiom_stax_builder_t *xml_stax_builder = NULL; + axiom_document_t *om_document = NULL; + axiom_node_t* root_node = NULL; + + axiom_node_t* created_node = NULL; + axiom_element_t* created_element = NULL; + + axiom_node_t* first_node = NULL; + axiom_element_t* first_element = NULL; + + axis2_char_t *root_text = NULL; + + /*Metadata Testing*/ + fed_federation_metadata_t *federation_metadata = NULL; + fed_metadata_om_t *metadata_om = NULL; + + root_node = axiom_node_create(env); + created_node = axiom_node_create(env); + + xml_reader = axiom_xml_reader_create_for_file(env, "./fed_metadata.xml", NULL); + xml_stax_builder = axiom_stax_builder_create(env, xml_reader); + om_document = axiom_document_create( env, NULL, xml_stax_builder); + + /* Created Node is the completed metadata node*/ + created_node = axiom_document_build_all(om_document, env); + + + federation_metadata = fed_federation_metadata_create(env); + fed_federation_metadata_load_metadata(federation_metadata, env, created_node); + + /*Get required Metadata Context*/ + metadata_om = fed_federation_metadata_get_fed_metadata_om(federation_metadata, env, "http://contosso.com/fed2";); + /*Set TokenSigningKeyInfo element processing call back fn*/ + fed_metadata_om_set_process_token_key_signing_info_fp(metadata_om, env, token_signing_key_test); + + fed_federation_metadata_populate_all( federation_metadata, env); + + printf("%s\n", axiom_node_to_string(fed_federation_metadata_build_all(federation_metadata, env), env)); + + + + //metadata_om = fed_federation_metadata_get_fed_metadata_om(federation_metadata, "http://contosso.com/fed2";, env); + /* + if(fed_metadata_om_get_metadata_node(metadata_om, env)) + printf("Acquired Metadata Context : %s\n", axiom_node_to_string(fed_metadata_om_get_metadata_node(metadata_om, env), + env)); + //printf("Acquired Metadata Context : %s\n", axiom_node_to_string(created_node, env)); + + fed_metadata_om_set_process_token_key_signing_info_fp(metadata_om, token_signing_key_test, env); + fed_metadata_om_populate_metadata(metadata_om, env); + + fed_federation_metadata_populate_all( federation_metadata, env); + + printf("Array lst - %s\n", axutil_array_list_get( + fed_metadata_om_get_token_types_offered_list(metadata_om, env), + env, + 2)); + + + printf("----- K -----Built Node : %s\n", + axiom_node_to_string(fed_federation_metadata_build_all(federation_metadata, env) , env)); + + + */ + return 0; +} + + + + +/* Test for user define token_key_singing_info generic function */ +axis2_char_t* AXIS2_CALL token_signing_key_test (fed_metadata_om_t *metadata_om, const axutil_env_t * env) +{ + axiom_node_t* token_signing_key_info_node = NULL; + + + token_signing_key_info_node = fed_metadata_om_get_token_signing_info_node(metadata_om, env); + + + + + //printf("Function Ptr Called------------***--------\n"); + //printf("Acquired Metadata Context : %s\n", + // axiom_node_to_string(fed_metadata_om_get_token_signing_info_node(metadata_om, env),env)); + + return "OK"; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
