| /* |
| * 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 <saml.h> |
| #include <saml_req.h> |
| |
| AXIS2_EXTERN saml_subject_query_t* AXIS2_CALL saml_subject_query_create(const axutil_env_t *env) |
| { |
| saml_subject_query_t *subject_query = NULL; |
| |
| subject_query = (saml_subject_query_t *)AXIS2_MALLOC(env->allocator, |
| sizeof(saml_subject_query_t)); |
| if(subject_query) |
| { |
| subject_query->subject = saml_subject_create(env); |
| } |
| return subject_query; |
| } |
| |
| AXIS2_EXTERN void AXIS2_CALL saml_subject_query_free(saml_subject_query_t *subject_query, const axutil_env_t *env) |
| { |
| if(subject_query->subject) |
| { |
| saml_subject_free(subject_query->subject, env); |
| } |
| AXIS2_FREE(env->allocator, subject_query); |
| subject_query = NULL; |
| } |
| |
| |
| AXIS2_EXTERN saml_authentication_query_t* AXIS2_CALL saml_authentication_query_create(const axutil_env_t *env) |
| { |
| saml_authentication_query_t *authentication_query = NULL; |
| |
| authentication_query = (saml_authentication_query_t*)AXIS2_MALLOC(env->allocator, |
| sizeof(saml_authentication_query_t)); |
| if(authentication_query) |
| { |
| authentication_query->subject = saml_subject_create(env); |
| authentication_query->auth_method = NULL; |
| } |
| return authentication_query; |
| } |
| |
| AXIS2_EXTERN void AXIS2_CALL saml_authentication_query_free(saml_authentication_query_t *auth_query, const axutil_env_t *env) |
| { |
| if(auth_query->auth_method) |
| { |
| AXIS2_FREE(env->allocator, auth_query->auth_method); |
| } |
| if(auth_query->subject) |
| { |
| saml_subject_free(auth_query->subject, env); |
| } |
| AXIS2_FREE(env->allocator, auth_query); |
| auth_query = NULL; |
| } |
| |
| AXIS2_EXTERN saml_attr_query_t* AXIS2_CALL saml_attr_query_create(const axutil_env_t *env) |
| { |
| saml_attr_query_t *attribute_query = NULL; |
| attribute_query = (saml_attr_query_t *)AXIS2_MALLOC(env->allocator, |
| sizeof(saml_attr_query_t)); |
| |
| if(attribute_query) |
| { |
| attribute_query->resource = NULL; |
| attribute_query->subject = saml_subject_create(env); |
| attribute_query->attr_desigs = axutil_array_list_create(env, SAML_ARRAY_LIST_DEF); |
| |
| } |
| return attribute_query; |
| } |
| |
| AXIS2_EXTERN void AXIS2_CALL saml_attr_query_free(saml_attr_query_t *attr_query, const axutil_env_t *env) |
| { |
| int size = 0, i = 0; |
| saml_attr_desig_t *attr_desig = NULL; |
| |
| if(attr_query->resource) |
| { |
| AXIS2_FREE(env->allocator, attr_query->resource); |
| } |
| if(attr_query->subject) |
| { |
| saml_subject_free(attr_query->subject, env); |
| } |
| if(attr_query->attr_desigs) |
| { |
| size = axutil_array_list_size(attr_query->attr_desigs, env); |
| for(i = 0; i < size; i++) |
| { |
| attr_desig = (saml_attr_desig_t*) axutil_array_list_get(attr_query->attr_desigs, env, i); |
| if(attr_desig) |
| saml_attr_desig_free(attr_desig, env); |
| } |
| |
| axutil_array_list_free(attr_query->attr_desigs, env); |
| } |
| |
| AXIS2_FREE(env->allocator, attr_query); |
| attr_query = NULL; |
| } |
| |
| AXIS2_EXTERN saml_autho_decision_query_t* AXIS2_CALL saml_autho_decision_query_create(const axutil_env_t *env) |
| { |
| saml_autho_decision_query_t *autho_decision_query = NULL; |
| |
| autho_decision_query = (saml_autho_decision_query_t *)AXIS2_MALLOC(env->allocator, |
| sizeof(saml_autho_decision_query_t)); |
| |
| if(autho_decision_query) |
| { |
| autho_decision_query->subject = saml_subject_create(env); |
| autho_decision_query->resource = NULL; |
| autho_decision_query->saml_actions = axutil_array_list_create(env, |
| SAML_ARRAY_LIST_DEF); |
| autho_decision_query->evidence = saml_evidence_create(env); |
| } |
| return autho_decision_query; |
| } |
| |
| AXIS2_EXTERN void AXIS2_CALL saml_autho_decision_query_free(saml_autho_decision_query_t* autho_decision_query, |
| const axutil_env_t *env) |
| { |
| int size = 0, i = 0; |
| saml_action_t *action = NULL; |
| |
| if(autho_decision_query->evidence) |
| { |
| saml_evidence_free(autho_decision_query->evidence, env); |
| } |
| if(autho_decision_query->resource) |
| { |
| AXIS2_FREE(env->allocator, autho_decision_query->resource); |
| } |
| if(autho_decision_query->subject) |
| { |
| saml_subject_free(autho_decision_query->subject, env); |
| } |
| if(autho_decision_query->saml_actions) |
| { |
| size = axutil_array_list_size(autho_decision_query->saml_actions, env); |
| for(i = 0; i < size ; i++) |
| { |
| action = (saml_action_t *)axutil_array_list_get(autho_decision_query->saml_actions, env, i); |
| if(action) |
| saml_action_free(action, env); |
| } |
| axutil_array_list_free(autho_decision_query->saml_actions, env); |
| } |
| AXIS2_FREE(env->allocator, autho_decision_query); |
| autho_decision_query = NULL; |
| |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_subject_query_build(saml_subject_query_t* subject_query, |
| axiom_node_t *node, |
| const axutil_env_t *env) |
| |
| { |
| |
| axiom_element_t *element = NULL; |
| axiom_child_element_iterator_t *iterator = NULL; |
| axiom_node_t *child_node = NULL; |
| |
| if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| if ((element = axiom_node_get_data_element(node, env)) == NULL) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| iterator = axiom_element_get_child_elements(element, env, node); |
| |
| if(iterator) |
| { |
| while(axiom_child_element_iterator_has_next(iterator, env)) |
| { |
| child_node = axiom_child_element_iterator_next(iterator, env); |
| element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); |
| |
| if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), |
| SAML_SUBJECT))) |
| { |
| if(subject_query->subject) |
| return saml_subject_build(subject_query->subject, child_node, env); |
| else |
| return AXIS2_FAILURE; /*subject query saml subject does not exist*/ |
| } |
| } |
| return AXIS2_SUCCESS; |
| } |
| else |
| return AXIS2_FAILURE; |
| |
| } |
| |
| AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_subject_query_to_om(saml_subject_query_t *subject_query, |
| axiom_node_t *parent, |
| const axutil_env_t *env) |
| { |
| |
| axiom_element_t *e = NULL; |
| axiom_node_t *n = NULL; |
| axiom_namespace_t *ns = NULL; |
| |
| ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX); |
| e = axiom_element_create(env, parent, SAML_SUBJECT_QUERY, ns, &n); |
| |
| if(e) |
| { |
| if(subject_query->subject) |
| saml_subject_to_om(subject_query->subject, n, env); |
| } |
| return n; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_authentication_query_build(saml_authentication_query_t* authentication_query, |
| axiom_node_t *node, |
| const axutil_env_t *env) |
| { |
| axutil_hash_t *attr_hash = NULL; |
| axiom_element_t *element = NULL; |
| axutil_hash_index_t *hi = NULL; |
| axiom_child_element_iterator_t *iterator = NULL; |
| axiom_node_t *child_node; |
| |
| |
| if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| if ((element = axiom_node_get_data_element(node, env)) == NULL) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| /* initialize the attributes */ |
| attr_hash = axiom_element_get_all_attributes(element, env); |
| |
| if(attr_hash) |
| { |
| for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi)) |
| { |
| void *v = NULL; |
| axutil_hash_this(hi, NULL, NULL, &v); |
| if (v) |
| { |
| axis2_char_t *attr_val = NULL; |
| axiom_attribute_t *attr = (axiom_attribute_t*)v; |
| attr_val = axiom_attribute_get_value(attr, env); |
| |
| if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_AUTHENTICATION_METHOD)) |
| { |
| authentication_query->auth_method = attr_val; |
| break; |
| } |
| } |
| } |
| } |
| |
| iterator = axiom_element_get_child_elements(element, env, node); |
| if(iterator) |
| { |
| while(axiom_child_element_iterator_has_next(iterator, env)) |
| { |
| |
| child_node = axiom_child_element_iterator_next(iterator, env); |
| element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); |
| |
| if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), |
| SAML_SUBJECT))) |
| { |
| if(authentication_query->subject) |
| return saml_subject_build(authentication_query->subject, child_node, env); |
| else |
| return AXIS2_FAILURE; |
| } |
| } |
| return AXIS2_SUCCESS; |
| } |
| else |
| return AXIS2_FAILURE; |
| |
| |
| } |
| |
| AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_authentication_query_to_om(saml_authentication_query_t *authentication_query, |
| axiom_node_t *parent, |
| const axutil_env_t *env) |
| { |
| axiom_element_t *e = NULL; |
| axiom_node_t *n = NULL; |
| axiom_namespace_t *ns = NULL; |
| axiom_attribute_t *attr = NULL; |
| |
| ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX); |
| e = axiom_element_create(env, parent, SAML_AUTHENTICATION_QUERY, ns, &n); |
| |
| if(e) |
| { |
| if(authentication_query->subject) |
| saml_subject_to_om(authentication_query->subject, n, env); |
| if(authentication_query->auth_method) |
| { |
| attr = axiom_attribute_create(env, SAML_AUTHENTICATION_METHOD, authentication_query->auth_method, NULL); |
| axiom_element_add_attribute(e, env, attr, n); |
| } |
| } |
| return n; |
| |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_build(saml_autho_decision_query_t* autho_decision_query, |
| axiom_node_t *node, |
| const axutil_env_t *env) |
| { |
| axutil_hash_t *attr_hash = NULL; |
| axiom_element_t *element = NULL; |
| axutil_hash_index_t *hi = NULL; |
| axiom_child_element_iterator_t *iterator = NULL; |
| axiom_node_t *child_node; |
| saml_action_t *action; |
| |
| if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| if ((element = axiom_node_get_data_element(node, env)) == NULL) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| /* initialize the attributes */ |
| attr_hash = axiom_element_get_all_attributes(element, env); |
| |
| for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi)) |
| { |
| void *v = NULL; |
| axutil_hash_this(hi, NULL, NULL, &v); |
| if (v) |
| { |
| axis2_char_t *attr_val = NULL; |
| axiom_attribute_t *attr = (axiom_attribute_t*)v; |
| attr_val = axiom_attribute_get_value(attr, env); |
| |
| if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_RESOURCE)) |
| { |
| if(autho_decision_query->resource) |
| { |
| autho_decision_query->resource = attr_val; |
| break; |
| } |
| else |
| return AXIS2_FAILURE; |
| } |
| } |
| } |
| |
| iterator = axiom_element_get_child_elements(element, env, node); |
| |
| if(iterator) |
| { |
| while(axiom_child_element_iterator_has_next(iterator, env)) |
| { |
| child_node = axiom_child_element_iterator_next(iterator, env); |
| element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); |
| |
| if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), |
| SAML_SUBJECT))) |
| { |
| if(autho_decision_query->subject) |
| saml_subject_build(autho_decision_query->subject, child_node, env); |
| } |
| |
| else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), |
| SAML_ACTION))) |
| { |
| if(autho_decision_query->saml_actions) |
| { |
| action = saml_action_create(env); |
| saml_action_build(action, child_node, env); |
| axutil_array_list_add(autho_decision_query->saml_actions, env, action); |
| } |
| } |
| else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), |
| SAML_EVIDENCE))) |
| { |
| if(autho_decision_query->evidence) |
| saml_evidence_build(autho_decision_query->evidence, child_node, env); |
| } |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| else |
| return AXIS2_FAILURE; |
| |
| |
| |
| } |
| |
| AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_autho_decision_query_to_om(saml_autho_decision_query_t *autho_decision_query, |
| axiom_node_t *parent, |
| const axutil_env_t *env) |
| { |
| int size = 0, i = 0; |
| axiom_element_t *e = NULL; |
| axiom_node_t *n = NULL; |
| axiom_namespace_t *ns = NULL; |
| axiom_attribute_t *attr = NULL; |
| saml_action_t *action; |
| |
| ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX); |
| e = axiom_element_create(env, parent, SAML_AUTHORIZATION_DECISION_QUERY, ns, &n); |
| |
| if(e) |
| { |
| if(autho_decision_query->subject) |
| saml_subject_to_om(autho_decision_query->subject, n, env); |
| |
| if(autho_decision_query->resource) |
| { |
| attr = axiom_attribute_create(env, SAML_RESOURCE, autho_decision_query->resource, NULL); |
| axiom_element_add_attribute(e, env, attr, n); |
| } |
| if(autho_decision_query->saml_actions) |
| { |
| size = axutil_array_list_size(autho_decision_query->saml_actions, env); |
| |
| for(i = 0 ; i < size ; i++) |
| { |
| action = (saml_action_t*)axutil_array_list_get(autho_decision_query->saml_actions, env, i); |
| saml_action_to_om(action, n, env); |
| } |
| } |
| if(autho_decision_query->evidence) |
| { |
| saml_evidence_to_om(autho_decision_query->evidence, n, env); |
| } |
| } |
| return n; |
| |
| |
| |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_attr_query_build(saml_attr_query_t* attribute_query, |
| axiom_node_t *node, |
| const axutil_env_t *env) |
| { |
| axutil_hash_t *attr_hash = NULL; |
| axiom_element_t *element = NULL; |
| axutil_hash_index_t *hi = NULL; |
| axiom_child_element_iterator_t *iterator = NULL; |
| axiom_node_t *child_node; |
| saml_attr_desig_t *attr_desig = NULL; |
| |
| if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| if ((element = axiom_node_get_data_element(node, env)) == NULL) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| /* initialize the attributes */ |
| attr_hash = axiom_element_get_all_attributes(element, env); |
| |
| /*One resource attribute relate to the attibute query*/ |
| for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi)) |
| { |
| void *v = NULL; |
| axutil_hash_this(hi, NULL, NULL, &v); |
| if (v) |
| { |
| axis2_char_t *attr_val = NULL; |
| axiom_attribute_t *attr = (axiom_attribute_t*)v; |
| attr_val = axiom_attribute_get_value(attr, env); |
| |
| if(!axutil_strcmp(axiom_attribute_get_localname(attr, env),SAML_RESOURCE)) |
| { |
| attribute_query->resource = attr_val; |
| break; |
| } |
| } |
| } |
| |
| iterator = axiom_element_get_child_elements(element, env, node); |
| if(iterator) |
| { |
| while(axiom_child_element_iterator_has_next(iterator, env)) |
| { |
| child_node = axiom_child_element_iterator_next(iterator, env); |
| element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); |
| |
| if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), |
| SAML_SUBJECT))) |
| { |
| if(attribute_query->subject) |
| saml_subject_build(attribute_query->subject, child_node, env); |
| } |
| |
| else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), |
| SAML_ATTRIBUTE_DESIGNATOR))) |
| { |
| /*attr_desig = saml_attr_desig_create(env); |
| */ |
| attr_desig = (saml_attr_desig_t*)AXIS2_MALLOC(env->allocator, |
| sizeof(saml_attr_desig_t)); |
| |
| if( AXIS2_SUCCESS == saml_attr_desig_build(attr_desig, child_node, env)) |
| { |
| axutil_array_list_add(attribute_query->attr_desigs,env, attr_desig); |
| } |
| } |
| |
| } |
| return AXIS2_SUCCESS; |
| } |
| else |
| return AXIS2_FAILURE; |
| |
| |
| } |
| |
| AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_attr_query_to_om(saml_attr_query_t *attribute_query, |
| axiom_node_t *parent, |
| const axutil_env_t *env) |
| { |
| int size = 0, i = 0; |
| axiom_element_t *e = NULL; |
| axiom_node_t *n = NULL; |
| axiom_namespace_t *ns = NULL; |
| axiom_attribute_t *attr = NULL; |
| saml_attr_desig_t *attr_desig = NULL; |
| |
| ns = axiom_namespace_create(env, SAML_PROTOCOL_NMSP, SAML_PROTOCOL_PREFIX); |
| e = axiom_element_create(env, parent, SAML_ATTRIBUTE_QUERY, ns, &n); |
| |
| if(e) |
| { |
| if(attribute_query->subject) |
| saml_subject_to_om(attribute_query->subject, n, env); |
| |
| if(attribute_query->resource) |
| { |
| attr = axiom_attribute_create(env, SAML_RESOURCE, attribute_query->resource, NULL); |
| axiom_element_add_attribute(e, env, attr, n); |
| } |
| if(attribute_query->attr_desigs) |
| { |
| size = axutil_array_list_size(attribute_query->attr_desigs, env); |
| |
| for( i=0 ; i < size ; i++) |
| { |
| attr_desig = (saml_attr_desig_t*)axutil_array_list_get(attribute_query->attr_desigs, env, i); |
| saml_attr_desig_to_om(attr_desig, n, env); |
| } |
| } |
| } |
| return n; |
| |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_query_build(saml_query_t *query, axiom_node_t *node, const axutil_env_t *env) |
| { |
| if(!axutil_strcmp(query->type,SAML_SUBJECT_QUERY)) |
| { |
| query->query = saml_subject_query_create(env); |
| if(query->query) |
| { |
| saml_subject_query_build((saml_subject_query_t*)query->query, node, env); |
| return AXIS2_SUCCESS; |
| } |
| else |
| return AXIS2_FAILURE; |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHENTICATION_QUERY)) |
| { |
| query->query = saml_authentication_query_create(env); |
| if(query->query) |
| { |
| saml_authentication_query_build((saml_authentication_query_t*)query->query, node, env); |
| return AXIS2_SUCCESS; |
| } |
| else |
| return AXIS2_FAILURE; |
| } |
| if(!axutil_strcmp(query->type, SAML_ATTRIBUTE_QUERY)) |
| { |
| query->query = saml_attr_query_create(env); |
| if(query->query) |
| { |
| saml_attr_query_build((saml_attr_query_t*)query->query, node, env); |
| return AXIS2_SUCCESS; |
| } |
| else |
| return AXIS2_FAILURE; |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHORIZATION_DECISION_QUERY)) |
| { |
| query->query = saml_autho_decision_query_create(env); |
| if(query->query) |
| { |
| saml_autho_decision_query_build((saml_autho_decision_query_t*)query->query, node, env); |
| return AXIS2_SUCCESS; |
| } |
| else |
| return AXIS2_FAILURE; |
| } |
| else |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN saml_query_t* AXIS2_CALL saml_query_create(const axutil_env_t *env) |
| { |
| saml_query_t* query = NULL; |
| query = AXIS2_MALLOC(env->allocator, sizeof(saml_query_t)); |
| if(query) |
| { |
| query->query = NULL; |
| query->type = NULL; |
| } |
| return query; |
| } |
| |
| |
| AXIS2_EXTERN void AXIS2_CALL saml_query_free(saml_query_t *query, const axutil_env_t *env) |
| { |
| if(query->type) |
| { |
| if(!axutil_strcmp(query->type,SAML_SUBJECT_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_subject_query_free(query->query, env); |
| } |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHENTICATION_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_authentication_query_free(query->query, env); |
| } |
| } |
| if(!axutil_strcmp(query->type, SAML_ATTRIBUTE_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_attr_query_free(query->query, env); |
| } |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHORIZATION_DECISION_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_autho_decision_query_free(query->query, env); |
| } |
| } |
| |
| AXIS2_FREE(env->allocator, query->type); |
| AXIS2_FREE(env->allocator, query); |
| query = NULL; |
| } |
| |
| } |
| AXIS2_EXTERN axiom_node_t* AXIS2_CALL saml_query_to_om(saml_query_t *query, axiom_node_t *parent, const axutil_env_t *env) |
| { |
| |
| if(!axutil_strcmp(query->type,SAML_SUBJECT_QUERY)) |
| { |
| return saml_subject_query_to_om((saml_subject_query_t*)query->query, parent, env); |
| |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHENTICATION_QUERY)) |
| { |
| return saml_authentication_query_to_om((saml_authentication_query_t*)query->query, parent, env); |
| } |
| if(!axutil_strcmp(query->type, SAML_ATTRIBUTE_QUERY)) |
| { |
| return saml_attr_query_to_om((saml_attr_query_t*)query->query, parent, env); |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHORIZATION_DECISION_QUERY)) |
| { |
| return saml_autho_decision_query_to_om((saml_autho_decision_query_t*)query->query, parent, env); |
| } |
| return NULL; |
| } |
| |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_auth_query_set_authentication_method(saml_authentication_query_t *authentication_query, |
| const axutil_env_t *env, |
| axis2_char_t *authentication_mtd) |
| { |
| if(authentication_query->auth_method) |
| { |
| AXIS2_FREE(env->allocator, authentication_query->auth_method); |
| } |
| authentication_query->auth_method = axutil_strdup(env, authentication_mtd); |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_attr_query_set_resource(saml_attr_query_t *attr_query, const axutil_env_t *env, axis2_char_t *resource) |
| { |
| if(attr_query->resource) |
| { |
| AXIS2_FREE(env->allocator, attr_query->resource); |
| } |
| attr_query->resource = axutil_strdup(env, resource); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_char_t* AXIS2_CALL saml_auth_query_get_authentication_method(saml_authentication_query_t *authentication_query, |
| const axutil_env_t *env) |
| { |
| if(authentication_query) |
| return authentication_query->auth_method; |
| else |
| return NULL; |
| |
| } |
| |
| |
| AXIS2_EXTERN axis2_char_t* AXIS2_CALL saml_attr_query_get_resource(saml_attr_query_t *attr_query, const axutil_env_t *env) |
| { |
| if(attr_query) |
| return attr_query->resource; |
| else |
| return NULL; |
| } |
| |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_attr_query_set_designators(saml_attr_query_t *attr_query, const axutil_env_t *env, |
| axutil_array_list_t *attr_desigs) |
| { |
| if(attr_query->attr_desigs) |
| { |
| axutil_array_list_free(attr_query->attr_desigs, env); |
| } |
| attr_query->attr_desigs = attr_desigs; |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axutil_array_list_t* AXIS2_CALL saml_attr_query_get_designators(saml_attr_query_t *attr_query, |
| const axutil_env_t *env) |
| { |
| if(attr_query) |
| return attr_query->attr_desigs; |
| else |
| return NULL; |
| } |
| |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_attr_query_add_designators(saml_attr_query_t *attr_query, const axutil_env_t *env, |
| saml_attr_desig_t *desig) |
| { |
| if(!attr_query->attr_desigs) |
| { |
| axutil_array_list_create(env, SAML_ARRAY_LIST_DEF); |
| } |
| axutil_array_list_add(attr_query->attr_desigs, env, desig); |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_attr_query_remove_designator(saml_attr_query_t *attr_query, const axutil_env_t *env, int index) |
| { |
| saml_attr_desig_t *desig; |
| |
| if(attr_query->attr_desigs) |
| { |
| desig = axutil_array_list_remove(attr_query->attr_desigs, env, index); |
| if(desig) |
| { |
| saml_attr_desig_free(desig, env); |
| return AXIS2_SUCCESS; |
| } |
| |
| } |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_set_resource(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env, |
| axis2_char_t *resource) |
| { |
| if(autho_dec_query->resource) |
| { |
| AXIS2_FREE(env->allocator, autho_dec_query->resource); |
| } |
| |
| autho_dec_query->resource = axutil_strdup(env, resource); |
| return AXIS2_SUCCESS; |
| } |
| AXIS2_EXTERN axis2_char_t* AXIS2_CALL saml_autho_decision_query_get_resource(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env) |
| { |
| if(autho_dec_query) |
| return autho_dec_query->resource; |
| else |
| return NULL; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_set_actions(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env, |
| axutil_array_list_t *actions) |
| { |
| if(autho_dec_query->saml_actions) |
| { |
| axutil_array_list_free(autho_dec_query->saml_actions, env); |
| } |
| autho_dec_query->saml_actions = actions; |
| return AXIS2_SUCCESS; |
| } |
| AXIS2_EXTERN axutil_array_list_t* AXIS2_CALL saml_autho_decision_query_get_actions(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env) |
| { |
| if(autho_dec_query) |
| return autho_dec_query->saml_actions; |
| else |
| return NULL; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_add_action(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env, |
| saml_action_t *action) |
| { |
| if(!autho_dec_query->saml_actions) |
| { |
| autho_dec_query->saml_actions = axutil_array_list_create(env, SAML_ARRAY_LIST_DEF); |
| } |
| if(autho_dec_query->saml_actions) |
| { |
| axutil_array_list_add(autho_dec_query->saml_actions, env, action); |
| return AXIS2_SUCCESS; |
| } |
| return AXIS2_FAILURE; |
| } |
| AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_remove_action(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env, |
| int index) |
| { |
| saml_action_t *act; |
| if(autho_dec_query->saml_actions) |
| { |
| act = axutil_array_list_remove(autho_dec_query->saml_actions, env, index); |
| if(act) |
| { |
| saml_action_free(act, env); |
| return AXIS2_SUCCESS; |
| } |
| } |
| return AXIS2_FAILURE; |
| } |
| AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_set_evidence(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env, |
| saml_evidence_t *evidence) |
| { |
| if(autho_dec_query->evidence) |
| { |
| saml_evidence_free(autho_dec_query->evidence, env); |
| } |
| autho_dec_query->evidence = evidence; |
| return AXIS2_FAILURE; |
| } |
| |
| AXIS2_EXTERN saml_evidence_t* AXIS2_CALL saml_autho_decision_query_get_evidence(saml_autho_decision_query_t *autho_dec_query, |
| const axutil_env_t *env) |
| { |
| if(autho_dec_query) |
| return autho_dec_query->evidence; |
| else |
| return NULL; |
| } |
| AXIS2_EXTERN int AXIS2_CALL saml_query_set_subject(saml_query_t* query, const axutil_env_t *env, |
| saml_subject_t *subject) |
| { |
| saml_subject_query_t *sub_q = NULL; |
| saml_authentication_query_t *authent_q; |
| saml_autho_decision_query_t *autho_de_q; |
| saml_attr_query_t *attr_q; |
| if(query) |
| { |
| if(query->type) |
| { |
| if(!axutil_strcmp(query->type,SAML_SUBJECT_QUERY)) |
| { |
| sub_q = (saml_subject_query_t*)query->query; |
| if(sub_q) |
| { |
| if(sub_q->subject) |
| { |
| saml_subject_free(sub_q->subject, env); |
| } |
| sub_q->subject = subject; |
| } |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHENTICATION_QUERY)) |
| { |
| authent_q = (saml_authentication_query_t*)query->query; |
| if(authent_q->subject) |
| { |
| saml_subject_free(authent_q->subject, env); |
| } |
| authent_q->subject = subject; |
| } |
| if(!axutil_strcmp(query->type, SAML_ATTRIBUTE_QUERY)) |
| { |
| attr_q = (saml_attr_query_t*)query->query; |
| if(attr_q) |
| { |
| saml_subject_free(attr_q->subject, env); |
| } |
| attr_q->subject = subject; |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHORIZATION_DECISION_QUERY)) |
| { |
| autho_de_q = (saml_autho_decision_query_t*)query->query; |
| if(autho_de_q) |
| { |
| saml_subject_free(autho_de_q->subject, env); |
| } |
| autho_de_q->subject = subject; |
| } |
| |
| } |
| |
| } |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN saml_subject_t* AXIS2_CALL saml_query_get_subject(saml_query_t* query, |
| const axutil_env_t *env) |
| { |
| saml_subject_query_t *sub_q = NULL; |
| saml_authentication_query_t *authent_q; |
| saml_autho_decision_query_t *autho_de_q; |
| saml_attr_query_t *attr_q; |
| if(query) |
| { |
| if(query->type) |
| { |
| if(!axutil_strcmp(query->type,SAML_SUBJECT_QUERY)) |
| { |
| sub_q = (saml_subject_query_t*)query->query; |
| if(sub_q) |
| return sub_q->subject; |
| else |
| return NULL; |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHENTICATION_QUERY)) |
| { |
| authent_q = (saml_authentication_query_t*)query->query; |
| if(authent_q) |
| return authent_q->subject; |
| } |
| if(!axutil_strcmp(query->type, SAML_ATTRIBUTE_QUERY)) |
| { |
| attr_q = (saml_attr_query_t*)query->query; |
| if(attr_q) |
| return attr_q->subject; |
| else |
| return NULL; |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHORIZATION_DECISION_QUERY)) |
| { |
| autho_de_q = (saml_autho_decision_query_t*)query->query; |
| if(autho_de_q) |
| return autho_de_q->subject; |
| else |
| return NULL; |
| } |
| |
| } |
| |
| } |
| return NULL; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_query_set_type(saml_query_t *query, const axutil_env_t *env, |
| axis2_char_t *type) |
| { |
| if(query->type) |
| { |
| AXIS2_FREE(env->allocator, query->type); |
| } |
| query->type = axutil_strdup(env, type); |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL saml_query_set_query(saml_query_t *query, const axutil_env_t *env, void *spec_query, |
| axis2_char_t *type) |
| { |
| if(query->query) |
| { |
| |
| if(!axutil_strcmp(query->type,SAML_SUBJECT_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_subject_query_free(query->query, env); |
| } |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHENTICATION_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_authentication_query_free(query->query, env); |
| } |
| } |
| if(!axutil_strcmp(query->type, SAML_ATTRIBUTE_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_attr_query_free(query->query, env); |
| } |
| } |
| if(!axutil_strcmp(query->type, SAML_AUTHORIZATION_DECISION_QUERY)) |
| { |
| if(query->query) |
| { |
| saml_autho_decision_query_free(query->query, env); |
| } |
| } |
| AXIS2_FREE(env->allocator, query->type); |
| } |
| |
| query->query = spec_query; |
| query->type = axutil_strdup(env, type); |
| return AXIS2_SUCCESS; |
| |
| } |