diff options
Diffstat (limited to 'neethi/include')
71 files changed, 6106 insertions, 0 deletions
diff --git a/neethi/include/axis2_rm_assertion.h b/neethi/include/axis2_rm_assertion.h new file mode 100644 index 0000000..81f612d --- /dev/null +++ b/neethi/include/axis2_rm_assertion.h @@ -0,0 +1,267 @@ + +/* + * 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. + */ + + +#ifndef AXIS2_RM_ASSERTION_H +#define AXIS2_RM_ASSERTION_H + +/** @defgroup axis2_rm_assertion + * @ingroup axis2_rm_assertion + * @{ + */ + +#include <neethi_includes.h> +#include <neethi_policy.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct axis2_rm_assertion_t axis2_rm_assertion_t; + + + AXIS2_EXTERN axis2_rm_assertion_t *AXIS2_CALL + axis2_rm_assertion_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + axis2_rm_assertion_free( + axis2_rm_assertion_t * rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_rm_assertion_get_is_sequence_str( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_is_sequence_str( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_bool_t is_sequence_str); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_rm_assertion_get_is_sequence_transport_security( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_is_sequence_transport_security( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_bool_t is_sequence_transport_security); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_rm_assertion_get_is_exactly_once( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_is_exactly_once( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_bool_t is_exactly_once); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_rm_assertion_get_is_atleast_once( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_is_atleast_once( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_bool_t is_atleast_once); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_rm_assertion_get_is_atmost_once( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_is_atmost_once( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_bool_t is_atmost_once); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_rm_assertion_get_is_inorder( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_is_inorder( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_bool_t is_inorder); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_inactivity_timeout( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_inactivity_timeout( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* inactivity_timeout); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_retrans_interval( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_retrans_interval( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* retrans_interval); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_ack_interval( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_ack_interval( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* ack_interval); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_rm_assertion_get_is_exp_backoff( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_is_exp_backoff( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_bool_t is_exp_backoff); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_storage_mgr( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_storage_mgr( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* storage_mgr); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_message_types_to_drop( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_message_types_to_drop( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* message_types_to_drop); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_max_retrans_count( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_max_retrans_count( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* max_retrans_count); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_sender_sleep_time( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_sender_sleep_time( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* sender_sleep_time); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_invoker_sleep_time( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_invoker_sleep_time( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* invoker_sleep_time); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_polling_wait_time( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_polling_wait_time( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* polling_wait_time); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_terminate_delay( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_terminate_delay( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* terminate_delay); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_sandesha2_db( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_sandesha2_db( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* sandesha2_db); + + AXIS2_EXTERN axis2_char_t* AXIS2_CALL + axis2_rm_assertion_get_spec_version( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_rm_assertion_set_spec_version( + axis2_rm_assertion_t *rm_assertion, + const axutil_env_t * env, + axis2_char_t* spec_version); + + AXIS2_EXTERN axis2_rm_assertion_t* AXIS2_CALL + axis2_rm_assertion_get_from_policy( + const axutil_env_t *env, + neethi_policy_t *policy); + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/axis2_rm_assertion_builder.h b/neethi/include/axis2_rm_assertion_builder.h new file mode 100644 index 0000000..276030b --- /dev/null +++ b/neethi/include/axis2_rm_assertion_builder.h @@ -0,0 +1,48 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef AXIS2_RM_ASSERTION_BUILDER_H +#define AXIS2_RM_ASSERTION_BUILDER_H + +/** @defgroup axis2_rm_assertion_builder + * @ingroup axis2_rm_assertion_builder + * @{ + */ + +#include <neethi_constants.h> +#include <axis2_rm_assertion.h> +#include <neethi_assertion.h> +#include <neethi_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + #define RM_SPEC_VERSION_1_0 "Spec_2005_02" + #define RM_SPEC_VERSION_1_1 "Spec_2007_02" + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + axis2_rm_assertion_builder_build( + const axutil_env_t *env, + axiom_node_t *rm_assertion_node, + axiom_element_t *rm_assertion_ele); + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/neethi_all.h b/neethi/include/neethi_all.h new file mode 100644 index 0000000..83c518c --- /dev/null +++ b/neethi/include/neethi_all.h @@ -0,0 +1,81 @@ + +/* + * 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. + */ + +#ifndef NEETHI_ALL_H +#define NEETHI_ALL_H + +/** + * @file neethi_all.h + * @struct for operator all + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_operator.h> +#include <neethi_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct neethi_all_t neethi_all_t; + + AXIS2_EXTERN neethi_all_t *AXIS2_CALL + neethi_all_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + neethi_all_free( + neethi_all_t * neethi_all, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + neethi_all_get_policy_components( + neethi_all_t * neethi_all, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_all_add_policy_components( + neethi_all_t * all, + axutil_array_list_t * arraylist, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_all_add_operator( + neethi_all_t * neethi_all, + const axutil_env_t * env, + neethi_operator_t * op); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + neethi_all_is_empty( + neethi_all_t * all, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_all_serialize( + neethi_all_t * neethi_all, + axiom_node_t * parent, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_ALL_H */ diff --git a/neethi/include/neethi_assertion.h b/neethi/include/neethi_assertion.h new file mode 100644 index 0000000..5a4fa97 --- /dev/null +++ b/neethi/include/neethi_assertion.h @@ -0,0 +1,208 @@ + +/* + * 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. + */ + +#ifndef NEETHI_ASSERTION_H +#define NEETHI_ASSERTION_H + +/** + * @file neethi_assertion.h + * @common struct for policy assertions. + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_includes.h> +#include <neethi_operator.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef enum + { + ASSERTION_TYPE_TRANSPORT_BINDING = 0, + ASSERTION_TYPE_TRANSPORT_TOKEN, + ASSERTION_TYPE_ALGORITHM_SUITE, + ASSERTION_TYPE_INCLUDE_TIMESTAMP, + ASSERTION_TYPE_LAYOUT, + ASSERTION_TYPE_SUPPORTING_TOKENS, + ASSERTION_TYPE_HTTPS_TOKEN, + ASSERTION_TYPE_WSS_USERNAME_TOKEN_10, + ASSERTION_TYPE_WSS_USERNAME_TOKEN_11, + ASSERTION_TYPE_USERNAME_TOKEN, + ASSERTION_TYPE_X509_TOKEN, + ASSERTION_TYPE_SAML_TOKEN, + ASSERTION_TYPE_ISSUED_TOKEN, + ASSERTION_TYPE_SECURITY_CONTEXT_TOKEN, + ASSERTION_TYPE_REQUIRE_EXTERNAL_URI, + ASSERTION_TYPE_SC10_SECURITY_CONTEXT_TOKEN, + ASSERTION_TYPE_SC13_SECURITY_CONTEXT_TOKEN, + ASSERTION_TYPE_ISSUER, + ASSERTION_TYPE_BOOTSTRAP_POLICY, + ASSERTION_TYPE_MUST_SUPPORT_REF_KEY_IDENTIFIER, + ASSERTION_TYPE_MUST_SUPPORT_REF_ISSUER_SERIAL, + ASSERTION_TYPE_MUST_SUPPORT_REF_EXTERNAL_URI, + ASSERTION_TYPE_MUST_SUPPORT_REF_EMBEDDED_TOKEN, + ASSERTION_TYPE_WSS10, + ASSERTION_TYPE_WSS11, + ASSERTION_TYPE_TRUST10, + ASSERTION_TYPE_RAMPART_CONFIG, + ASSERTION_TYPE_ASSYMMETRIC_BINDING, + ASSERTION_TYPE_SYMMETRIC_BINDING, + ASSERTION_TYPE_INITIATOR_TOKEN, + ASSERTION_TYPE_RECIPIENT_TOKEN, + ASSERTION_TYPE_PROTECTION_TOKEN, + ASSERTION_TYPE_ENCRYPTION_TOKEN, + ASSERTION_TYPE_SIGNATURE_TOKEN, + ASSERTION_TYPE_ENCRYPT_BEFORE_SIGNING, + ASSERTION_TYPE_SIGN_BEFORE_ENCRYPTING, + ASSERTION_TYPE_ENCRYPT_SIGNATURE, + ASSERTION_TYPE_PROTECT_TOKENS, + ASSERTION_TYPE_ONLY_SIGN_ENTIRE_HEADERS_AND_BODY, + ASSERTION_TYPE_REQUIRE_KEY_IDENTIFIRE_REFERENCE, + ASSERTION_TYPE_REQUIRE_ISSUER_SERIAL_REFERENCE, + ASSERTION_TYPE_REQUIRE_EMBEDDED_TOKEN_REFERENCE, + ASSERTION_TYPE_REQUIRE_THUMBPRINT_REFERENCE, + ASSERTION_TYPE_REQUIRE_EXTERNAL_REFERENCE, + ASSERTION_TYPE_REQUIRE_INTERNAL_REFERENCE, + ASSERTION_TYPE_MUST_SUPPORT_REF_THUMBPRINT, + ASSERTION_TYPE_MUST_SUPPORT_REF_ENCRYPTED_KEY, + ASSERTION_TYPE_REQUIRE_SIGNATURE_CONFIRMATION, + ASSERTION_TYPE_WSS_X509_V1_TOKEN_10, + ASSERTION_TYPE_WSS_X509_V3_TOKEN_10, + ASSERTION_TYPE_WSS_SAML_V10_TOKEN_V10, + ASSERTION_TYPE_WSS_SAML_V10_TOKEN_V11, + ASSERTION_TYPE_WSS_SAML_V11_TOKEN_V10, + ASSERTION_TYPE_WSS_SAML_V11_TOKEN_V11, + ASSERTION_TYPE_WSS_SAML_V20_TOKEN_V11, + ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS, + ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10, + ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC13, + ASSERTION_TYPE_MUST_SUPPORT_CLIENT_CHALLENGE, + ASSERTION_TYPE_MUST_SUPPORT_SERVER_CHALLENGE, + ASSERTION_TYPE_REQUIRE_CLIENT_ENTROPY, + ASSERTION_TYPE_REQUIRE_SERVER_ENTROPHY, + ASSERTION_TYPE_MUST_SUPPORT_ISSUED_TOKENS, + ASSERTION_TYPE_OPTIMIZED_MIME_SERIALIZATION, + ASSERTION_TYPE_RM_ASSERTION, + ASSERTION_TYPE_UNKNOWN + } neethi_assertion_type_t; + + typedef struct neethi_assertion_t neethi_assertion_t; + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + neethi_assertion_create( + const axutil_env_t * env); + + neethi_assertion_t *AXIS2_CALL + neethi_assertion_create_with_args( + const axutil_env_t * env, + AXIS2_FREE_VOID_ARG free_func, + void *value, + neethi_assertion_type_t type); + + AXIS2_EXTERN void AXIS2_CALL + neethi_assertion_free( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN neethi_assertion_type_t AXIS2_CALL + neethi_assertion_get_type( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN void *AXIS2_CALL + neethi_assertion_get_value( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_assertion_set_value( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env, + void *value, + neethi_assertion_type_t type); + + AXIS2_EXTERN axiom_element_t *AXIS2_CALL + neethi_assertion_get_element( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_assertion_set_element( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env, + axiom_element_t * element); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + neethi_assertion_get_is_optional( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_assertion_set_is_optional( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env, + axis2_bool_t is_optional); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + neethi_assertion_get_policy_components( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_assertion_add_policy_components( + neethi_assertion_t * neethi_assertion, + axutil_array_list_t * arraylist, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_assertion_add_operator( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env, + neethi_operator_t * op); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + neethi_assertion_is_empty( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + neethi_assertion_get_node( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_assertion_set_node( + neethi_assertion_t * neethi_assertion, + const axutil_env_t * env, + axiom_node_t * node); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_assertion_serialize( + neethi_assertion_t * assertion, + axiom_node_t * parent, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_ASSERTION_H */ diff --git a/neethi/include/neethi_assertion_builder.h b/neethi/include/neethi_assertion_builder.h new file mode 100644 index 0000000..8014fcd --- /dev/null +++ b/neethi/include/neethi_assertion_builder.h @@ -0,0 +1,46 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef NEETHI_ASSERTION_BUILDER_H +#define NEETHI_ASSERTION_BUILDER_H + +/** @defgroup neethi_assertion_builder + * @ingroup neethi_assertion_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <neethi_assertion.h> +#include <rp_builders.h> +#include <axis2_rm_assertion_builder.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + neethi_assertion_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/neethi_constants.h b/neethi/include/neethi_constants.h new file mode 100644 index 0000000..6351f00 --- /dev/null +++ b/neethi/include/neethi_constants.h @@ -0,0 +1,87 @@ + +/* + * 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. + */ + +#ifndef NEETHI_CONSTANTS_H +#define NEETHI_CONSTANTS_H + +#define NEETHI_EXACTLYONE "ExactlyOne" +#define NEETHI_ALL "All" +#define NEETHI_POLICY "Policy" +#define NEETHI_REFERENCE "PolicyReference" +#define NEETHI_URI "URI" +#define NEETHI_NAMESPACE "http://schemas.xmlsoap.org/ws/2004/09/policy" +#define NEETHI_POLICY_15_NAMESPACE "http://www.w3.org/ns/ws-policy" +#define NEETHI_PREFIX "wsp" +#define NEETHI_WSU_NS "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" +#define NEETHI_ID "Id" +#define NEETHI_WSU_NS_PREFIX "wsu" +#define NEETHI_NAME "Name" +#define AXIS2_OPTIMIZED_MIME_SERIALIZATION "OptimizedMimeSerialization" +#define AXIS2_MTOM_POLICY_NS "http://schemas.xmlsoap.org/ws/2004/09/policy/optimizedmimeserialization" +#define AXIS2_RM_POLICY_10_NS "http://schemas.xmlsoap.org/ws/2005/02/rm/policy" +#define AXIS2_RM_POLICY_11_NS "http://docs.oasis-open.org/ws-rx/wsrmp/200702" +#define AXIS2_SANDESHA2_NS "http://ws.apache.org/sandesha2/c/policy" + +/* Reliable messaging related constatnts */ + +/* RMPolicy 1.0 */ + +#define AXIS2_RM_RMASSERTION "RMAssertion" +#define AXIS2_RM_INACTIVITY_TIMEOUT "InactivityTimeout" +#define AXIS2_RM_BASE_RETRANSMISSION_INTERVAL "BaseRetransmissionInterval" +#define AXIS2_RM_EXPONENTIAL_BACK_OFF "ExponentialBackoff" +#define AXIS2_RM_ACKNOWLEDGEMENT_INTERVAL "AcknowledgementInterval" + +/* RM policy 1.1 */ + +#define AXIS2_RM_SEQUENCE_STR "SequenceSTR" +#define AXIS2_RM_SEQUENCE_TRANSPORT_SECURITY "SequenceTransportSecurity" +#define AXIS2_RM_DELIVERY_ASSURANCE "DeliveryAssurance" +#define AXIS2_RM_EXACTLY_ONCE "ExactlyOnce" +#define AXIS2_RM_AT_LEAST_ONCE "AtLeastOnce" +#define AXIS2_RM_AT_MOST_ONCE "AtMostOnce" +#define AXIS2_RM_IN_ORDER "InOrder" + +/* Sandesha2/C specific */ + +#define AXIS2_RM_SANDESHA2_DB "sandesha2_db" +#define AXIS2_RM_STORAGE_MANAGER "StorageManager" +#define AXIS2_RM_MESSAGE_TYPES_TO_DROP "MessageTypesToDrop" +#define AXIS2_RM_MAX_RETRANS_COUNT "MaxRetransCount" +#define AXIS2_RM_SENDER_SLEEP_TIME "SenderSleepTime" +#define AXIS2_RM_INVOKER_SLEEP_TIME "InvokerSleepTime" +#define AXIS2_RM_POLLING_WAIT_TIME "PollingWaitTime" +#define AXIS2_RM_TERMINATE_DELAY "TerminateDelay" + + +/** +* @file neethi_constants.h +* @brief includes all the string constants +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /*NEETHI_INCLUDES_H */ diff --git a/neethi/include/neethi_engine.h b/neethi/include/neethi_engine.h new file mode 100644 index 0000000..4ea34e3 --- /dev/null +++ b/neethi/include/neethi_engine.h @@ -0,0 +1,144 @@ + +/* + * 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. + */ + +#ifndef NEETHI_ENGINE_H +#define NEETHI_ENGINE_H + +/*neethis_engine.c contains all the useful functions + * for dealing with a neethi_policy object + */ + + + +/** + * @file neethi_engine.h + * @contains neethi_policy creation logic. + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_includes.h> +#include <neethi_operator.h> +#include <neethi_policy.h> +#include <neethi_all.h> +#include <neethi_exactlyone.h> +#include <neethi_reference.h> +#include <neethi_registry.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * Given an axiom model this function will return + * a neethi_policy object. + * @param env pointer to environment struct + * @param node to an axiom_node + * @param node to an axiom_element + * @return pointer to a neethi_policy_t struct + */ + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_engine_get_policy( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + + /** + * Given a neethi_policy object this will return the + * normalized policy object. + * @param env pointer to environment struct + * @param deep to specify whether assertion level normalization + needed. + * @param neethi_policy_t to the policy which is not + normalized. + * @return pointer to a normalized neethi_policy_t struct + */ + + /*This function will return a new neethi_policy struct. + So it is callers responsibility to free the neethi_policy + which is passed as an argument. */ + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_engine_get_normalize( + const axutil_env_t * env, + axis2_bool_t deep, + neethi_policy_t * neethi_policy); + + /** + * Given a neethi_policy object this will return the + * normalized policy object. + * @param env pointer to environment struct + * @param deep to specify whether assertion level normalization + needed. + * @param neethi_policy_t to the policy which is not + normalized. + * @param registry neethi_registry_t struct which contains + policy objects. + * @return pointer to a normalized neethi_policy_t struct + */ + + /*This function will return a new neethi_policy struct. + So it is callers responsibility to free the neethi_policy + which is passed as an argument. */ + + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_engine_normalize( + const axutil_env_t * env, + neethi_policy_t * neethi_policy, + neethi_registry_t * registry, + axis2_bool_t deep); + + /*Givnen to normalized policy objects this function will + retun the merged policy object. + * @param env pointer to environment struct + * @param neethi_policy1 pointer neethi_policy_t struct as an + * input for merge. + * @param neethi_policy2 pointer neethi_policy_t struct as an + * input for merge. + * @return pointer to a merged policy of both inputs.*/ + + /*The input for this function should be two normalized policies + otherwise the output may be wrong.*/ + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_engine_merge( + const axutil_env_t * env, + neethi_policy_t * neethi_policy1, + neethi_policy_t * neethi_policy2); + + /*Given a policy object this function will give the + * corresponding axiom model for that policy object. + * @param policy pointer to the neethi_policy_t struct. + * @param env pointer to environment struct + */ + + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + neethi_engine_serialize( + neethi_policy_t * policy, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_ENGINE_H */ diff --git a/neethi/include/neethi_exactlyone.h b/neethi/include/neethi_exactlyone.h new file mode 100644 index 0000000..fc3d065 --- /dev/null +++ b/neethi/include/neethi_exactlyone.h @@ -0,0 +1,81 @@ + +/* + * 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. + */ + +#ifndef NEETHI_EXACTLYONE_H +#define NEETHI_EXACTLYONE_H + +/** + * @file neethi_exactlyone.h + * @struct for operator exactlyone + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_operator.h> +#include <neethi_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct neethi_exactlyone_t neethi_exactlyone_t; + + AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL + neethi_exactlyone_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + neethi_exactlyone_free( + neethi_exactlyone_t * neethi_exactlyone, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + neethi_exactlyone_get_policy_components( + neethi_exactlyone_t * neethi_exactlyone, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_exactlyone_add_policy_components( + neethi_exactlyone_t * exactlyone, + axutil_array_list_t * arraylist, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_exactlyone_add_operator( + neethi_exactlyone_t * neethi_exactlyone, + const axutil_env_t * env, + neethi_operator_t * op); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + neethi_exactlyone_is_empty( + neethi_exactlyone_t * exactlyone, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_exactlyone_serialize( + neethi_exactlyone_t * neethi_exactlyone, + axiom_node_t * parent, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_EXACTLYONE_H */ diff --git a/neethi/include/neethi_includes.h b/neethi/include/neethi_includes.h new file mode 100644 index 0000000..88550af --- /dev/null +++ b/neethi/include/neethi_includes.h @@ -0,0 +1,55 @@ + +/* + * 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. + */ + +#ifndef NEETHI_INCLUDES_H +#define NEETHI_INCLUDES_H + +#include <axis2_util.h> +#include <axutil_allocator.h> +#include <axutil_string.h> +#include <axutil_array_list.h> +#include <axis2_const.h> +#include <axutil_error.h> +#include <axutil_utils_defines.h> +#include <axutil_log_default.h> +#include <axutil_error_default.h> +#include <axutil_env.h> +#include <axiom.h> +#include <axiom_soap.h> +#include <axutil_qname.h> +#include <axutil_hash.h> +#include <neethi_constants.h> +#include <axutil_hash.h> +#include <rp_defines.h> + +/** +* @file neethi_includes.h +* @brief includes most useful headers for policy +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /*NEETHI_INCLUDES_H */ diff --git a/neethi/include/neethi_mtom_assertion_checker.h b/neethi/include/neethi_mtom_assertion_checker.h new file mode 100644 index 0000000..2081f41 --- /dev/null +++ b/neethi/include/neethi_mtom_assertion_checker.h @@ -0,0 +1,43 @@ + +/* + * 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. + */ + +#ifndef NEETHI_MTOM_ASSERTION_CHECKER_H +#define NEETHI_MTOM_ASSERTION_CHECKER_H + + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_policy.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + neethi_is_mtom_required( + const axutil_env_t *env, + neethi_policy_t *policy); + + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif diff --git a/neethi/include/neethi_operator.h b/neethi/include/neethi_operator.h new file mode 100644 index 0000000..9b38f70 --- /dev/null +++ b/neethi/include/neethi_operator.h @@ -0,0 +1,95 @@ + +/* + * 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. + */ + +#ifndef NEETHI_OPERATOR_H +#define NEETHI_OPERATOR_H + +/** + * @file neethi_operator.h + * @common struct for policy operators. + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef enum + { + OPERATOR_TYPE_POLICY = 0, + OPERATOR_TYPE_ALL, + OPERATOR_TYPE_EXACTLYONE, + OPERATOR_TYPE_REFERENCE, + OPERATOR_TYPE_ASSERTION, + OPERATOR_TYPE_UNKNOWN + } neethi_operator_type_t; + + typedef struct neethi_operator_t neethi_operator_t; + + AXIS2_EXTERN neethi_operator_t *AXIS2_CALL + neethi_operator_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + neethi_operator_free( + neethi_operator_t * neethi_operator, + const axutil_env_t * env); + + AXIS2_EXTERN neethi_operator_type_t AXIS2_CALL + neethi_operator_get_type( + neethi_operator_t * neethi_operator, + const axutil_env_t * env); + + AXIS2_EXTERN void *AXIS2_CALL + neethi_operator_get_value( + neethi_operator_t * neethi_operator, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_operator_set_value( + neethi_operator_t * neethi_operator, + const axutil_env_t * env, + void *value, + neethi_operator_type_t type); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_operator_serialize( + neethi_operator_t * neethi_operator, + const axutil_env_t * env, + axiom_node_t * parent); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_operator_set_value_null( + neethi_operator_t * neethi_operator, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_operator_increment_ref( + neethi_operator_t * neethi_operator, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_OPERATOR_H */ diff --git a/neethi/include/neethi_policy.h b/neethi/include/neethi_policy.h new file mode 100644 index 0000000..bdc2b52 --- /dev/null +++ b/neethi/include/neethi_policy.h @@ -0,0 +1,126 @@ + +/* + * 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. + */ + +#ifndef NEETHI_POLICY_H +#define NEETHI_POLICY_H + +/** + * @file neethi_policy.h + * @struct for operator neethi_policy + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_operator.h> +#include <neethi_includes.h> +#include <neethi_exactlyone.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct neethi_policy_t neethi_policy_t; + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_policy_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + neethi_policy_free( + neethi_policy_t * neethi_policy, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + neethi_policy_get_policy_components( + neethi_policy_t * neethi_policy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_policy_add_policy_components( + neethi_policy_t * neethi_policy, + axutil_array_list_t * arraylist, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_policy_add_operator( + neethi_policy_t * neethi_policy, + const axutil_env_t * env, + neethi_operator_t * op); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + neethi_policy_is_empty( + neethi_policy_t * neethi_policy, + const axutil_env_t * env); + + AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL + neethi_policy_get_exactlyone( + neethi_policy_t * normalized_neethi_policy, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + neethi_policy_get_alternatives( + neethi_policy_t * neethi_policy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + neethi_policy_get_name( + neethi_policy_t * neethi_policy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_policy_set_name( + neethi_policy_t * neethi_policy, + const axutil_env_t * env, + axis2_char_t * name); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + neethi_policy_get_id( + neethi_policy_t * neethi_policy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_policy_set_id( + neethi_policy_t * neethi_policy, + const axutil_env_t * env, + axis2_char_t * id); + + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + neethi_policy_serialize( + neethi_policy_t * neethi_policy, + axiom_node_t * parent, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_policy_set_root_node( + neethi_policy_t * policy, + const axutil_env_t * env, + axiom_node_t * root_node); + + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + neethi_policy_get_attributes( + neethi_policy_t *neethi_policy, + const axutil_env_t *env); + + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_POLICY_H */ diff --git a/neethi/include/neethi_reference.h b/neethi/include/neethi_reference.h new file mode 100644 index 0000000..42b07c4 --- /dev/null +++ b/neethi/include/neethi_reference.h @@ -0,0 +1,69 @@ + +/* + * 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. + */ + +#ifndef NEETHI_REFERENCE_H +#define NEETHI_REFERENCE_H + +/** + * @file neethi_reference.h + * @struct for operator reference + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct neethi_reference_t neethi_reference_t; + + AXIS2_EXTERN neethi_reference_t *AXIS2_CALL + neethi_reference_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + neethi_reference_free( + neethi_reference_t * neethi_reference, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + neethi_reference_get_uri( + neethi_reference_t * neethi_reference, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_reference_set_uri( + neethi_reference_t * neethi_reference, + const axutil_env_t * env, + axis2_char_t * uri); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_reference_serialize( + neethi_reference_t * neethi_reference, + axiom_node_t * parent, + const axutil_env_t * env); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_REFERENCE_H */ diff --git a/neethi/include/neethi_registry.h b/neethi/include/neethi_registry.h new file mode 100644 index 0000000..fd6e1d1 --- /dev/null +++ b/neethi/include/neethi_registry.h @@ -0,0 +1,71 @@ + +/* + * 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. + */ + +#ifndef NEETHI_REGISTRY_H +#define NEETHI_REGISTRY_H + +/** + * @file neethi_registry.h + * @struct for operator registry + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_includes.h> +#include <neethi_policy.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct neethi_registry_t neethi_registry_t; + + AXIS2_EXTERN neethi_registry_t *AXIS2_CALL + neethi_registry_create( + const axutil_env_t * env); + + AXIS2_EXTERN neethi_registry_t *AXIS2_CALL + neethi_registry_create_with_parent( + const axutil_env_t * env, + neethi_registry_t * parent); + + AXIS2_EXTERN void AXIS2_CALL + neethi_registry_free( + neethi_registry_t * neethi_registry, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + neethi_registry_register( + neethi_registry_t * neethi_registry, + const axutil_env_t * env, + axis2_char_t * key, + neethi_policy_t * value); + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_registry_lookup( + neethi_registry_t * neethi_registry, + const axutil_env_t * env, + axis2_char_t * key); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_REGISTRY_H */ diff --git a/neethi/include/neethi_util.h b/neethi/include/neethi_util.h new file mode 100644 index 0000000..6cdf620 --- /dev/null +++ b/neethi/include/neethi_util.h @@ -0,0 +1,53 @@ + +/* + * 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. + */ + +#ifndef NEETHI_UTIL_H +#define NEETHI_UTIL_H + +/** + * @file neethi_util.h + * @policy creation utilities + */ + +#include <axis2_defines.h> +#include <axutil_env.h> +#include <neethi_includes.h> +#include <neethi_policy.h> +#include <neethi_engine.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_util_create_policy_from_file( + const axutil_env_t * env, + axis2_char_t * file_name); + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + neethi_util_create_policy_from_om( + const axutil_env_t * env, + axiom_node_t * root_node); + + /** @} */ +#ifdef __cplusplus +} +#endif + +#endif /* NEETHI_UTIL_H */ diff --git a/neethi/include/rp_algorithmsuite.h b/neethi/include/rp_algorithmsuite.h new file mode 100644 index 0000000..682abf4 --- /dev/null +++ b/neethi/include/rp_algorithmsuite.h @@ -0,0 +1,218 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ALGORITHMSUITE_H +#define RP_ALGORITHMSUITE_H + +/** @defgroup rp_algoruthmsuite + * @ingroup rp_algorithmsuite + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_algorithmsuite_t rp_algorithmsuite_t; + + AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL + rp_algorithmsuite_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_algorithmsuite_free( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_algosuite_string( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_algosuite( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * algosuite_string); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_symmetric_signature( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_symmetric_signature( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * symmetric_signature); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_asymmetric_signature( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_asymmetric_signature( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * asymmetric_signature); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_computed_key( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_computed_key( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * computed_key); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_digest( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_encryption( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN int AXIS2_CALL + rp_algorithmsuite_get_max_symmetric_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_max_symmetric_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + int max_symmetric_keylength); + + AXIS2_EXTERN int AXIS2_CALL + rp_algorithmsuite_get_min_symmetric_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN int AXIS2_CALL + rp_algorithmsuite_get_max_asymmetric_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_max_asymmetric_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + int max_asymmetric_keylength); + + AXIS2_EXTERN int AXIS2_CALL + rp_algorithmsuite_get_min_asymmetric_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_min_asymmetric_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + int min_asymmetric_keylength); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_symmetrickeywrap( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_asymmetrickeywrap( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_signature_key_derivation( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_encryption_key_derivation( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_soap_normalization( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_soap_normalization( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * soap_normalization); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_str_transformation( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_str_transformation( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * str_transformation); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_c14n( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_c14n( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * c14n); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_algorithmsuite_get_xpath( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_set_xpath( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env, + axis2_char_t * xpath); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_algorithmsuite_increment_ref( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN int AXIS2_CALL + rp_algorithmsuite_get_encryption_derivation_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + + AXIS2_EXTERN int AXIS2_CALL + rp_algorithmsuite_get_signature_derivation_keylength( + rp_algorithmsuite_t * algorithmsuite, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_algorithmsuite_builder.h b/neethi/include/rp_algorithmsuite_builder.h new file mode 100644 index 0000000..72140b1 --- /dev/null +++ b/neethi/include/rp_algorithmsuite_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ALGORITHMSUITE_BUILDER_H +#define RP_ALGORITHMSUITE_BUILDER_H + +/** @defgroup rp_algorithmsuite_builder + * @ingroup rp_algorithmsuite_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_algorithmsuite.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_algorithmsuite_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_asymmetric_binding.h b/neethi/include/rp_asymmetric_binding.h new file mode 100644 index 0000000..d41706d --- /dev/null +++ b/neethi/include/rp_asymmetric_binding.h @@ -0,0 +1,88 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ASYMMETRIC_BINDING_H +#define RP_ASYMMETRIC_BINDING_H + +/** @defgroup rp_asymmetric_binding + * @ingroup rp_asymmetric_binding + * @{ + */ + +#include <rp_includes.h> +#include <rp_symmetric_asymmetric_binding_commons.h> +#include <rp_property.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_asymmetric_binding_t rp_asymmetric_binding_t; + + AXIS2_EXTERN rp_asymmetric_binding_t *AXIS2_CALL + rp_asymmetric_binding_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_asymmetric_binding_free( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN rp_symmetric_asymmetric_binding_commons_t *AXIS2_CALL + rp_asymmetric_binding_get_symmetric_asymmetric_binding_commons( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_asymmetric_binding_set_symmetric_asymmetric_binding_commons( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env, + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_asymmetric_binding_set_initiator_token( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env, + rp_property_t * initiator_token); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_asymmetric_binding_get_initiator_token( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_asymmetric_binding_set_recipient_token( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env, + rp_property_t * recipient_token); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_asymmetric_binding_get_recipient_token( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_asymmetric_binding_increment_ref( + rp_asymmetric_binding_t * asymmetric_binding, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_asymmetric_binding_builder.h b/neethi/include/rp_asymmetric_binding_builder.h new file mode 100644 index 0000000..ec70175 --- /dev/null +++ b/neethi/include/rp_asymmetric_binding_builder.h @@ -0,0 +1,46 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ASYMMETRIC_BINDING_BUILDER_H +#define RP_ASYMMETRIC_BINDING_BUILDER_H + +/** @defgroup rp_asymmetric_binding_builder + * @ingroup rp_asymmetric_binding_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_asymmetric_binding.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + + rp_asymmetric_binding_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_binding_commons.h b/neethi/include/rp_binding_commons.h new file mode 100644 index 0000000..4d7da8a --- /dev/null +++ b/neethi/include/rp_binding_commons.h @@ -0,0 +1,126 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_BINDING_COMMONS_H +#define RP_BINDING_COMMONS_H + +/** @defgroup rp_binding_commons + * @ingroup rp_binding_commons + * @{ + */ +#include <rp_includes.h> +#include <rp_algorithmsuite.h> +#include <rp_layout.h> +#include <rp_supporting_tokens.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_binding_commons_t rp_binding_commons_t; + + AXIS2_EXTERN rp_binding_commons_t *AXIS2_CALL + rp_binding_commons_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_binding_commons_free( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL + rp_binding_commons_get_algorithmsuite( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_binding_commons_set_algorithmsuite( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env, + rp_algorithmsuite_t * algorithmsuite); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_binding_commons_get_include_timestamp( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_binding_commons_set_include_timestamp( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env, + axis2_bool_t include_timestamp); + + AXIS2_EXTERN rp_layout_t *AXIS2_CALL + rp_binding_commons_get_layout( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_binding_commons_set_layout( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env, + rp_layout_t * layout); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_binding_commons_get_signed_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_binding_commons_set_signed_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env, + rp_supporting_tokens_t * signed_supporting_tokens); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_binding_commons_get_signed_endorsing_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_binding_commons_set_signed_endorsing_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env, + rp_supporting_tokens_t * signed_endorsing_supporting_tokens); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_binding_commons_get_endorsing_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_binding_commons_set_endorsing_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env, + rp_supporting_tokens_t * endorsing_supporting_tokens); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_binding_commons_get_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_binding_commons_set_supporting_tokens( + rp_binding_commons_t * binding_commons, + const axutil_env_t * env, + rp_supporting_tokens_t * supporting_tokens); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_bootstrap_policy_builder.h b/neethi/include/rp_bootstrap_policy_builder.h new file mode 100644 index 0000000..20b3a0b --- /dev/null +++ b/neethi/include/rp_bootstrap_policy_builder.h @@ -0,0 +1,44 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_BOOTSTRAP_POLICY_BUILDER_H +#define RP_BOOTSTRAP_POLICY_BUILDER_H + +/** @defgroup rp_bootstrap_policy_builder + * @ingroup rp_bootstrap_policy_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_bootstrap_policy_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_builders.h b/neethi/include/rp_builders.h new file mode 100644 index 0000000..1903611 --- /dev/null +++ b/neethi/include/rp_builders.h @@ -0,0 +1,64 @@ + +/* + * 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. + */ + +#ifndef RP_BUILDERS_H +#define RP_BUILDERS_H + +#include <rp_algorithmsuite_builder.h> +#include <rp_defines.h> +#include <rp_layout_builder.h> +#include <rp_supporting_tokens_builder.h> +#include <rp_token_identifier.h> +#include <rp_transport_binding_builder.h> +#include <rp_transport_token_builder.h> +#include <rp_username_token_builder.h> +#include <rp_wss10_builder.h> +#include <rp_wss11_builder.h> +#include <rp_trust10_builder.h> +#include <rp_https_token_builder.h> +#include <rp_x509_token_builder.h> +#include <rp_issued_token_builder.h> +#include <rp_saml_token_builder.h> +#include <rp_security_context_token_builder.h> +#include <rp_bootstrap_policy_builder.h> +#include <rp_recipient_token_builder.h> +#include <rp_initiator_token_builder.h> +#include <rp_asymmetric_binding_builder.h> +#include <rp_signed_encrypted_parts_builder.h> +#include <rp_rampart_config_builder.h> +#include <rp_symmetric_binding_builder.h> +#include <rp_protection_token_builder.h> +#include <rp_encryption_token_builder.h> +#include <rp_signature_token_builder.h> + +/** +* @file rp_builders.h +* @all the secpolicy builders +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /*RP_BUILDERS_H */ diff --git a/neethi/include/rp_defines.h b/neethi/include/rp_defines.h new file mode 100644 index 0000000..33e218e --- /dev/null +++ b/neethi/include/rp_defines.h @@ -0,0 +1,232 @@ +/* + * 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. + */ + +#ifndef RP_DEFINES_H +#define RP_DEFINES_H + +/** @defgroup rp_defines + * @ingroup rp_defines + * @{ + */ +#ifdef __cplusplus +extern "C" +{ +#endif + +#define RP_POLICY "Policy" +#define RP_EXACTLY_ONE "ExactlyOne" +#define RP_ALL "All" + +#define RP_SYMMETRIC_BINDING "SymmetricBinding" +#define RP_ASYMMETRIC_BINDING "AsymmetricBinding" +#define RP_TRANSPORT_BINDING "TransportBinding" + +#define RP_SIGNED_SUPPORTING_TOKENS "SignedSupportingTokens" +#define RP_SIGNED_ENDORSING_SUPPORTING_TOKENS "SignedEndorsingSupportingTokens" +#define RP_SUPPORTING_TOKENS "SupportingTokens" +#define RP_ENDORSING_SUPPORTING_TOKENS "EndorsingSupportingTokens" + +#define RP_SIGNED_PARTS "SignedParts" +#define RP_SIGNED_ELEMENTS "SignedElements" +#define RP_ENCRYPTED_PARTS "EncryptedParts" +#define RP_ENCRYPTED_ELEMENTS "EncryptedElements" +#define RP_SIGNED_ITEMS "SignedItems" +#define RP_ENCRYPTED_ITEMS "EncryptedItems" + +#define RP_BODY "Body" +#define RP_HEADER "Header" +#define RP_NAME "Name" +#define RP_NAMESPACE "Namespace" +#define RP_ELEMENT "Element" +#define RP_ATTACHMENTS "Attachments" + +#define RP_XPATH "XPath" +#define RP_XPATH_VERSION "XPathVersion" + +#define RP_WSS10 "Wss10" +#define RP_WSS11 "Wss11" +#define RP_TRUST10 "Trust10" +#define RP_TRUST13 "Trust13" + +#define RP_MUST_SUPPORT_REF_KEY_IDENTIFIER "MustSupportRefKeyIdentifier" +#define RP_MUST_SUPPORT_REF_ISSUER_SERIAL "MustSupportRefIssuerSerial" +#define RP_MUST_SUPPORT_REF_EXTERNAL_URI "MustSupportRefExternalURI" +#define RP_MUST_SUPPORT_REF_EMBEDDED_TOKEN "MustSupportRefEmbeddedToken" +#define RP_MUST_SUPPORT_REF_THUMBPRINT "MustSupportRefThumbprint" +#define RP_MUST_SUPPORT_REF_ENCRYPTED_KEY "MustSupportRefEncryptedKey" +#define RP_REQUIRE_SIGNATURE_CONFIRMATION "RequireSignatureConfirmation" +#define RP_MUST_SUPPORT_CLIENT_CHALLENGE "MustSupportClientChallenge" +#define RP_MUST_SUPPORT_SERVER_CHALLENGE "MustSupportServerChallenge" +#define RP_REQUIRE_CLIENT_ENTROPY "RequireClientEntropy" +#define RP_REQUIRE_SERVER_ENTROPHY "RequireServerEntropy" +#define RP_MUST_SUPPORT_ISSUED_TOKENS "MustSupportIssuedTokens" + +#define RP_PROTECTION_TOKEN "ProtectionToken" +#define RP_ENCRYPTION_TOKEN "EncryptionToken" +#define RP_SIGNATURE_TOKEN "SignatureToken" +#define RP_INITIATOR_TOKEN "InitiatorToken" +#define RP_RECIPIENT_TOKEN "RecipientToken" +#define RP_TRANSPORT_TOKEN "TransportToken" + +#define RP_ALGORITHM_SUITE "AlgorithmSuite" +#define RP_LAYOUT "Layout" +#define RP_INCLUDE_TIMESTAMP "IncludeTimestamp" +#define RP_ENCRYPT_BEFORE_SIGNING "EncryptBeforeSigning" +#define RP_SIGN_BEFORE_ENCRYPTING "SignBeforeEncrypting" +#define RP_ENCRYPT_SIGNATURE "EncryptSignature" +#define RP_PROTECT_TOKENS "ProtectTokens" +#define RP_ONLY_SIGN_ENTIRE_HEADERS_AND_BODY "OnlySignEntireHeadersAndBody" + +#define RP_ALGO_SUITE_BASIC256 "Basic256" +#define RP_ALGO_SUITE_BASIC192 "Basic192" +#define RP_ALGO_SUITE_BASIC128 "Basic128" +#define RP_ALGO_SUITE_TRIPLE_DES "TripleDes" +#define RP_ALGO_SUITE_BASIC256_RSA15 "Basic256Rsa15" +#define RP_ALGO_SUITE_BASIC192_RSA15 "Basic192Rsa15" +#define RP_ALGO_SUITE_BASIC128_RSA15 "Basic128Rsa15" +#define RP_ALGO_SUITE_TRIPLE_DES_RSA15 "TripleDesRsa15" +#define RP_ALGO_SUITE_BASIC256_SHA256 "Basic256Sha256" +#define RP_ALGO_SUITE_BASIC192_SHA256 "Basic192Sha256" +#define RP_ALGO_SUITE_BASIC128_SHA256 "Basic128Sha256" +#define RP_ALGO_SUITE_TRIPLE_DES_SHA256 "TripleDesSha256" +#define RP_ALGO_SUITE_BASIC256_SHA256_RSA15 "Basic256Sha256Rsa15" +#define RP_ALGO_SUITE_BASIC192_SHA256_RSA15 "Basic192Sha256Rsa15" +#define RP_ALGO_SUITE_BASIC128_SHA256_RSA15 "Basic128Sha256Rsa15" +#define RP_ALGO_SUITE_TRIPLE_DES_SHA256_RSA15 "TripleDesSha256Rsa15" + +#define RP_HMAC_SHA1 "http://www.w3.org/2000/09/xmldsig#hmac-sha1" +#define RP_RSA_SHA1 "http://www.w3.org/2000/09/xmldsig#rsa-sha1" +#define RP_SHA1 "http://www.w3.org/2000/09/xmldsig#sha1" +#define RP_SHA256 "http://www.w3.org/2001/04/xmlenc#sha256" +#define RP_SHA512 "http://www.w3.org/2001/04/xmlenc#sha512" +#define RP_AES128 "http://www.w3.org/2001/04/xmlenc#aes128-cbc" +#define RP_AES192 "http://www.w3.org/2001/04/xmlenc#aes192-cbc" +#define RP_AES256 "http://www.w3.org/2001/04/xmlenc#aes256-cbc" +#define RP_TRIPLE_DES "http://www.w3.org/2001/04/xmlenc#tripledes-cbc" +#define RP_KW_AES128 "http://www.w3.org/2001/04/xmlenc#kw-aes256" +#define RP_KW_AES192 "http://www.w3.org/2001/04/xmlenc#kw-aes192" +#define RP_KW_AES256 "http://www.w3.org/2001/04/xmlenc#kw-aes128" +#define RP_KW_TRIPLE_DES "http://www.w3.org/2001/04/xmlenc#kw-tripledes" +#define RP_KW_RSA_OAEP "http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p" +#define RP_KW_RSA15 "http://www.w3.org/2001/04/xmlenc#rsa-1_5" +#define RP_P_SHA1 "http://schemas.xmlsoap.org/ws/2005/02/sc/dk/p_sha1" +#define RP_P_SHA1_L128 "http://schemas.xmlsoap.org/ws/2005/02/sc/dk/p_sha1" +#define RP_P_SHA1_L192 "http://schemas.xmlsoap.org/ws/2005/02/sc/dk/p_sha1" +#define RP_P_SHA1_L256 "http://schemas.xmlsoap.org/ws/2005/02/sc/dk/p_sha1" +#define RP_X_PATH "http://www.w3.org/TR/1999/REC-xpath-19991116" +#define RP_XPATH20 "http://www.w3.org/2002/06/xmldsig-filter2" +#define RP_C14N "http://www.w3.org/2001/10/xml-c14n#" +#define RP_EX_C14N "http://www.w3.org/2001/10/xml-exc-c14n#" +#define RP_SNT "http://www.w3.org/TR/soap12-n11n" +#define RP_STRT10 "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#STR-Transform" +#define RP_INCLUSIVE_C14N "InclusiveC14N" +#define RP_SOAP_NORMALIZATION_10 "SoapNormalization10" +#define RP_STR_TRANSFORM_10 "STRTransform10" +#define RP_XPATH10 "XPath10" +#define RP_XPATH_FILTER20 "XPathFilter20" + +#define RP_LAYOUT_STRICT "Strict" +#define RP_LAYOUT_LAX "Lax" +#define RP_LAYOUT_LAX_TIMESTAMP_FIRST "LaxTimestampFirst" +#define RP_LAYOUT_LAX_TIMESTAMP_LAST "LaxTimestampLast" + +#define RP_USERNAME_TOKEN "UsernameToken" +#define RP_X509_TOKEN "X509Token" +#define RP_SAML_TOKEN "SamlToken" +#define RP_ISSUED_TOKEN "IssuedToken" +#define RP_SECURITY_CONTEXT_TOKEN "SecurityContextToken" +#define RP_SECURE_CONVERSATION_TOKEN "SecureConversationToken" +#define RP_HTTPS_TOKEN "HttpsToken" + +#define RP_INCLUDE_TOKEN "IncludeToken" +#define RP_INCLUDE_ALWAYS "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Always" +#define RP_INCLUDE_NEVER "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never" +#define RP_INCLUDE_ONCE "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Once" +#define RP_INCLUDE_ALWAYS_TO_RECIPIENT "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient" +#define RP_INCLUDE_NEVER_SP12 "http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Never" +#define RP_INCLUDE_ONCE_SP12 "http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Once" +#define RP_INCLUDE_ALWAYS_TO_RECIPIENT_SP12 "http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToRecipient" +#define RP_INCLUDE_ALWAYS_TO_INITIATOR_SP12 "http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToInitiator" +#define RP_INCLUDE_ALWAYS_SP12 "http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Always" + +#define RP_REQUEST_SEC_TOKEN_TEMPLATE "RequestSecurityTokenTemplate" + +#define RP_REQUIRE_KEY_IDENTIFIRE_REFERENCE "RequireKeyIdentifierReference" +#define RP_REQUIRE_ISSUER_SERIAL_REFERENCE "RequireIssuerSerialReference" +#define RP_REQUIRE_EMBEDDED_TOKEN_REFERENCE "RequireEmbeddedTokenReference" +#define RP_REQUIRE_THUMBPRINT_REFERENCE "RequireThumbprintReference" +#define RP_REQUIRE_DERIVED_KEYS "RequireDerivedKeys" +#define RP_REQUIRE_EXTERNAL_REFERENCE "RequireExternalReference" +#define RP_REQUIRE_INTERNAL_REFERENCE "RequireInternalReference" +#define RP_WSS_X509_V1_TOKEN_10 "WssX509V1Token10" +#define RP_WSS_X509_V3_TOKEN_10 "WssX509V3Token10" +#define RP_WSS_X509_PKCS7_TOKEN_10 "WssX509Pkcs7Token10" +#define RP_WSS_X509_PKI_PATH_V1_TOKEN_10 "WssX509PkiPathV1Token10" +#define RP_WSS_X509_V1_TOKEN_11 "WssX509V1Token11" +#define RP_WSS_X509_V3_TOKEN_11 "WssX509V3Token11" +#define RP_WSS_X509_PKCS7_TOKEN_11 "WssX509Pkcs7Token11" +#define RP_WSS_X509_PKI_PATH_V1_TOKEN_11 "WssX509PkiPathV1Token11" + +#define RP_WSS_USERNAME_TOKEN_10 "WssUsernameToken10" +#define RP_WSS_USERNAME_TOKEN_11 "WssUsernameToken11" + +#define RP_WSS_SAML_V10_TOKEN_V10 "WssSamlV10Token10" +#define RP_WSS_SAML_V11_TOKEN_V10 "WssSamlV11Token10" +#define RP_WSS_SAML_V10_TOKEN_V11 "WssSamlV10Token11" +#define RP_WSS_SAML_V11_TOKEN_V11 "WssSamlV11Token11" +#define RP_WSS_SAML_V20_TOKEN_V11 "WssSamlV20Token11" + +#define RP_REQUIRE_EXTERNAL_URI_REFERENCE "RequireExternalUriReference" +#define RP_SC10_SECURITY_CONTEXT_TOKEN "SC10SecurityContextToken" +#define RP_SC13_SECURITY_CONTEXT_TOKEN "SC13SecurityContextToken" +#define RP_BOOTSTRAP_POLICY "BootstrapPolicy" +#define RP_ISSUER "Issuer" + +#define RP_REQUIRE_CLIENT_CERTIFICATE "RequireClientCertificate" + +#define RP_RAMPART_CONFIG "RampartConfig" +#define RP_USER "User" +#define RP_ENCRYPTION_USER "EncryptionUser" +#define RP_PASSWORD_CALLBACK_CLASS "PasswordCallbackClass" +#define RP_AUTHN_MODULE_NAME "AuthnModuleName" +#define RP_PASSWORD_TYPE "PasswordType" +#define RP_PLAINTEXT "plainText" +#define RP_DIGEST "Digest" +#define RP_RECEIVER_CERTIFICATE "ReceiverCertificate" +#define RP_CERTIFICATE "Certificate" +#define RP_PRIVATE_KEY "PrivateKey" +#define RP_PKCS12_KEY_STORE "PKCS12KeyStore" +#define RP_TIME_TO_LIVE "TimeToLive" +#define RP_CLOCK_SKEW_BUFFER "ClockSkewBuffer" +#define RP_NEED_MILLISECOND_PRECISION "PrecisionInMilliseconds" +#define RP_RD "ReplayDetection" +#define RP_RD_MODULE "ReplayDetectionModule" +#define RP_SCT_MODULE "SecurityContextTokenProvider" + +#define RP_SP_NS_11 "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy" +#define RP_SP_NS_12 "http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702" +#define RP_SECURITY_NS "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" +#define RP_POLICY_NS "http://schemas.xmlsoap.org/ws/2004/09/policy" +#define RP_RAMPART_NS "http://ws.apache.org/rampart/c/policy" +#define RP_POLICY_PREFIX "wsp" +#define RP_RAMPART_PREFIX "rampc" +#define RP_SP_PREFIX "sp" + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_element.h b/neethi/include/rp_element.h new file mode 100644 index 0000000..312f647 --- /dev/null +++ b/neethi/include/rp_element.h @@ -0,0 +1,69 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ELEMENT_H +#define RP_ELEMENT_H + +/** @defgroup rp_element + * @ingroup rp_element + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_element_t rp_element_t; + + AXIS2_EXTERN rp_element_t *AXIS2_CALL + rp_element_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_element_free( + rp_element_t * element, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_element_get_name( + rp_element_t * element, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_element_set_name( + rp_element_t * element, + const axutil_env_t * env, + axis2_char_t * name); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_element_get_namespace( + rp_element_t * element, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_element_set_namespace( + rp_element_t * element, + const axutil_env_t * env, + axis2_char_t * nspace); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_encryption_token_builder.h b/neethi/include/rp_encryption_token_builder.h new file mode 100644 index 0000000..56a5fad --- /dev/null +++ b/neethi/include/rp_encryption_token_builder.h @@ -0,0 +1,48 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ENCRYPTION_TOKEN_BUILDER_H +#define RP_ENCRYPTION_TOKEN_BUILDER_H + +/** @defgroup rp_encryption_token_builder + * @ingroup rp_encryption_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <rp_security_context_token.h> +#include <neethi_assertion.h> +#include <rp_issued_token.h> +#include <rp_saml_token.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_encryption_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_header.h b/neethi/include/rp_header.h new file mode 100644 index 0000000..b4d74f7 --- /dev/null +++ b/neethi/include/rp_header.h @@ -0,0 +1,69 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_HEADER_H +#define RP_HEADER_H + +/** @defgroup rp_header + * @ingroup rp_header + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_header_t rp_header_t; + + AXIS2_EXTERN rp_header_t *AXIS2_CALL + rp_header_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_header_free( + rp_header_t * header, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_header_get_name( + rp_header_t * header, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_header_set_name( + rp_header_t * header, + const axutil_env_t * env, + axis2_char_t * name); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_header_get_namespace( + rp_header_t * header, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_header_set_namespace( + rp_header_t * header, + const axutil_env_t * env, + axis2_char_t * nspace); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_https_token.h b/neethi/include/rp_https_token.h new file mode 100644 index 0000000..d50effa --- /dev/null +++ b/neethi/include/rp_https_token.h @@ -0,0 +1,85 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_HTTPS_TOKEN_H +#define RP_HTTPS_TOKEN_H + +/** @defgroup rp_https_token + * @ingroup rp_https_token + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_https_token_t rp_https_token_t; + + AXIS2_EXTERN rp_https_token_t *AXIS2_CALL + rp_https_token_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_https_token_free( + rp_https_token_t * https_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_https_token_get_inclusion( + rp_https_token_t * https_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_https_token_set_inclusion( + rp_https_token_t * https_token, + const axutil_env_t * env, + axis2_char_t * inclusion); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_https_token_get_derivedkeys( + rp_https_token_t * https_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_https_token_set_derivedkeys( + rp_https_token_t * https_token, + const axutil_env_t * env, + axis2_bool_t derivedkeys); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_https_token_get_require_client_certificate( + rp_https_token_t * https_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_https_token_set_require_client_certificate( + rp_https_token_t * https_token, + const axutil_env_t * env, + axis2_bool_t require_client_certificate); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_https_token_increment_ref( + rp_https_token_t * https_token, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_https_token_builder.h b/neethi/include/rp_https_token_builder.h new file mode 100644 index 0000000..4331ecb --- /dev/null +++ b/neethi/include/rp_https_token_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_HTTPS_TOKEN_BUILDER_H +#define RP_HTTPS_TOKEN_BUILDER_H + +/** @defgroup rp_https_token_builder + * @ingroup rp_https_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_https_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_https_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_includes.h b/neethi/include/rp_includes.h new file mode 100644 index 0000000..c479889 --- /dev/null +++ b/neethi/include/rp_includes.h @@ -0,0 +1,52 @@ + +/* + * 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. + */ + +#ifndef RP_INCLUDES_H +#define RP_INCLUDES_H + +#include <axis2_util.h> +#include <axutil_allocator.h> +#include <axutil_string.h> +#include <axutil_array_list.h> +#include <axis2_const.h> +#include <axutil_error.h> +#include <axutil_utils_defines.h> +#include <axutil_log_default.h> +#include <axutil_error_default.h> +#include <axutil_env.h> +#include <axiom.h> +#include <axiom_soap.h> +#include <axutil_qname.h> +#include <rp_defines.h> + +/** +* @file rp_includes.h +* @brief includes most useful headers for RP +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + + /** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /*RP_INCLUDES_H */ diff --git a/neethi/include/rp_initiator_token_builder.h b/neethi/include/rp_initiator_token_builder.h new file mode 100644 index 0000000..fbfa17f --- /dev/null +++ b/neethi/include/rp_initiator_token_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_INITIATOR_TOKEN_BUILDER_H +#define RP_INITIATOR_TOKEN_BUILDER_H + +/** @defgroup rp_initiator_token_builder + * @ingroup rp_initiator_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_initiator_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_issued_token.h b/neethi/include/rp_issued_token.h new file mode 100644 index 0000000..dbe05a0 --- /dev/null +++ b/neethi/include/rp_issued_token.h @@ -0,0 +1,124 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ISSUED_TOKEN_H +#define RP_ISSUED_TOKEN_H + +/** @defgroup trust10 + * @ingroup trust10 + * @{ + */ + +#include <rp_includes.h> +#include <axutil_utils.h> +#include <neethi_operator.h> +#include <neethi_policy.h> +#include <neethi_exactlyone.h> +#include <neethi_all.h> +#include <neethi_engine.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_issued_token rp_issued_token_t; + + AXIS2_EXTERN rp_issued_token_t * AXIS2_CALL + rp_issued_token_create( + const axutil_env_t *env); + + AXIS2_EXTERN void AXIS2_CALL + rp_issued_token_free( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_char_t * AXIS2_CALL + rp_issued_token_get_inclusion( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_issued_token_set_inclusion( + rp_issued_token_t *issued_token, + const axutil_env_t *env, + axis2_char_t *inclusion); + + AXIS2_EXTERN axiom_node_t * AXIS2_CALL + rp_issued_token_get_issuer_epr( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_issued_token_set_issuer_epr( + rp_issued_token_t *issued_token, + const axutil_env_t *env, + axiom_node_t *issuer_epr); + + AXIS2_EXTERN axiom_node_t * AXIS2_CALL + rp_issued_token_get_requested_sec_token_template( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_issued_token_set_requested_sec_token_template( + rp_issued_token_t *issued_token, + const axutil_env_t *env, + axiom_node_t *req_sec_token_template); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_issued_token_get_derivedkeys( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_issued_token_set_derivedkeys( + rp_issued_token_t *issued_token, + const axutil_env_t *env, + axis2_bool_t derivedkeys); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_issued_token_get_require_external_reference( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_issued_token_set_require_exernal_reference( + rp_issued_token_t *issued_token, + const axutil_env_t *env, + axis2_bool_t require_external_reference); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_issued_token_get_require_internal_reference( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_issued_token_set_require_internal_reference( + rp_issued_token_t *issued_token, + const axutil_env_t *env, + axis2_bool_t require_internal_reference); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_issued_token_increment_ref( + rp_issued_token_t *issued_token, + const axutil_env_t *env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_issued_token_builder.h b/neethi/include/rp_issued_token_builder.h new file mode 100644 index 0000000..6ab3862 --- /dev/null +++ b/neethi/include/rp_issued_token_builder.h @@ -0,0 +1,50 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ISSUED_TOKEN_BUILDER_H +#define RP_ISSUED_TOKEN_BUILDER_H + +/** @defgroup trust10 + * @ingroup trust10 + * @{ + */ + +#include <rp_includes.h> +#include <rp_issued_token.h> +#include <neethi_operator.h> +#include <neethi_policy.h> +#include <neethi_exactlyone.h> +#include <neethi_all.h> +#include <neethi_engine.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t * AXIS2_CALL + rp_issued_token_builder_build(const axutil_env_t *env, + axiom_node_t *node, axiom_element_t *element); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL rp_issued_token_builder_process_alternatives( + const axutil_env_t *env, neethi_all_t *all, + rp_issued_token_t *issued_token); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_layout.h b/neethi/include/rp_layout.h new file mode 100644 index 0000000..7aa1d07 --- /dev/null +++ b/neethi/include/rp_layout.h @@ -0,0 +1,63 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_LAYOUT_H +#define RP_LAYOUT_H + +/** @defgroup rp_layout + * @ingroup rp_layout + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_layout_t rp_layout_t; + + AXIS2_EXTERN rp_layout_t *AXIS2_CALL + rp_layout_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_layout_free( + rp_layout_t * layout, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_layout_get_value( + rp_layout_t * layout, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_layout_set_value( + rp_layout_t * layout, + const axutil_env_t * env, + axis2_char_t * value); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_layout_increment_ref( + rp_layout_t * layout, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_layout_builder.h b/neethi/include/rp_layout_builder.h new file mode 100644 index 0000000..f101c06 --- /dev/null +++ b/neethi/include/rp_layout_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_LAYOUT_BUILDER_H +#define RP_LAYOUT_BUILDER_H + +/** @defgroup rp_layout_builder + * @ingroup rp_layout_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_layout.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_layout_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_policy_creator.h b/neethi/include/rp_policy_creator.h new file mode 100644 index 0000000..2cbe834 --- /dev/null +++ b/neethi/include/rp_policy_creator.h @@ -0,0 +1,52 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_POLICY_CREATOR_H +#define RP_POLICY_CREATOR_H + +/** @defgroup rp_policy_creator + * @ingroup rp_policy_creator + * @{ + */ + +#include <axiom.h> +#include <axis2_util.h> +#include <axutil_env.h> +#include <axutil_log_default.h> +#include <axutil_error_default.h> +#include <stdio.h> +#include <axiom_xml_reader.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL + rp_policy_create_from_file( + const axutil_env_t * env, + axis2_char_t * filename); + + AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL + rp_policy_create_from_om_node( + const axutil_env_t * env, + axiom_node_t * root); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_property.h b/neethi/include/rp_property.h new file mode 100644 index 0000000..ad90036 --- /dev/null +++ b/neethi/include/rp_property.h @@ -0,0 +1,95 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_PROPERTY_H +#define RP_PROPERTY_H + +/** @defgroup rp_property + * @ingroup rp_property + * @{ + */ +#include <rp_includes.h> +#include <rp_username_token.h> +#include <rp_x509_token.h> +#include <rp_issued_token.h> +#include <rp_saml_token.h> +#include <rp_security_context_token.h> +#include <rp_https_token.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef enum + { + RP_PROPERTY_USERNAME_TOKEN = 0, + RP_PROPERTY_X509_TOKEN, + RP_PROPERTY_ISSUED_TOKEN, + RP_PROPERTY_SAML_TOKEN, + RP_PROPERTY_SECURITY_CONTEXT_TOKEN, + RP_PROPERTY_HTTPS_TOKEN, + RP_PROPERTY_SYMMETRIC_BINDING, + RP_PROPERTY_ASYMMETRIC_BINDING, + RP_PROPERTY_TRANSPORT_BINDING, + RP_PROPERTY_SIGNED_SUPPORTING_TOKEN, + RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN, + RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN, + RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN, + RP_PROPERTY_WSS10, + RP_PROPERTY_WSS11, + RP_PROPERTY_SUPPORTING_TOKEN, + RP_PROPERTY_UNKNOWN + } rp_property_type_t; + + typedef struct rp_property_t rp_property_t; + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_property_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_property_free( + rp_property_t * property, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_property_set_value( + rp_property_t * property, + const axutil_env_t * env, + void *value, + rp_property_type_t type); + + AXIS2_EXTERN void *AXIS2_CALL + rp_property_get_value( + rp_property_t * property, + const axutil_env_t * env); + + AXIS2_EXTERN rp_property_type_t AXIS2_CALL + rp_property_get_type( + rp_property_t * property, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_property_increment_ref( + rp_property_t * property, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_protection_token_builder.h b/neethi/include/rp_protection_token_builder.h new file mode 100644 index 0000000..a203047 --- /dev/null +++ b/neethi/include/rp_protection_token_builder.h @@ -0,0 +1,48 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_PROTECTION_TOKEN_BUILDER_H +#define RP_PROTECTION_TOKEN_BUILDER_H + +/** @defgroup rp_protection_token_builder + * @ingroup rp_protection_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <rp_issued_token.h> +#include <rp_saml_token.h> +#include <rp_security_context_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_protection_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_rampart_config.h b/neethi/include/rp_rampart_config.h new file mode 100644 index 0000000..08a2f11 --- /dev/null +++ b/neethi/include/rp_rampart_config.h @@ -0,0 +1,217 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_RAMPART_CONFIG_H +#define RP_RAMPART_CONFIG_H + +/** @defgroup rp_rampart_config + * @ingroup rp_rampart_config + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_rampart_config_t rp_rampart_config_t; + + AXIS2_EXTERN rp_rampart_config_t *AXIS2_CALL + rp_rampart_config_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_rampart_config_free( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_user( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_user( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * user); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_encryption_user( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_encryption_user( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * encryption_user); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_password_callback_class( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_password_callback_class( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * passwprd_callback_class); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_authenticate_module( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_authenticate_module( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * authenticate_module); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_replay_detector( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_replay_detector( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * replay_detector); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_sct_provider( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_sct_provider( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * sct_module); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_password_type( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_password_type( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * password_type); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_private_key_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_private_key_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * private_key_file); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_receiver_certificate_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_receiver_certificate_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * receiver_certificate_file); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_certificate_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_certificate_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * certificate_file); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_time_to_live( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_time_to_live( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * time_to_live); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_clock_skew_buffer( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_clock_skew_buffer( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * clock_skew_buffer); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_need_millisecond_precision( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_need_millisecond_precision( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * need_millisecond_precision); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_rd_val( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_rd_val( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env, + axis2_char_t * rd_val); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_increment_ref( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_rampart_config_set_pkcs12_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t *env, + axis2_char_t * pkcs12_file); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_rampart_config_get_pkcs12_file( + rp_rampart_config_t * rampart_config, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_rampart_config_builder.h b/neethi/include/rp_rampart_config_builder.h new file mode 100644 index 0000000..3dcce53 --- /dev/null +++ b/neethi/include/rp_rampart_config_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_RAMPART_CONFIG_BUILDER_H +#define RP_RAMPART_CONFIG_BUILDER_H + +/** @defgroup rp_rampart_config_builder + * @ingroup rp_rampart_config_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_rampart_config.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_rampart_config_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_recipient_token_builder.h b/neethi/include/rp_recipient_token_builder.h new file mode 100644 index 0000000..08ed111 --- /dev/null +++ b/neethi/include/rp_recipient_token_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_RECIPIENT_TOKEN_BUILDER_H +#define RP_RECIPIENT_TOKEN_BUILDER_H + +/** @defgroup rp_recipient_token_builder + * @ingroup rp_recipient_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_recipient_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_saml_token.h b/neethi/include/rp_saml_token.h new file mode 100644 index 0000000..044a5fb --- /dev/null +++ b/neethi/include/rp_saml_token.h @@ -0,0 +1,97 @@ +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SAML_TOKEN_H +#define RP_SAML_TOKEN_H + +#include <rp_includes.h> +#include <axutil_utils.h> +#include <neethi_operator.h> +#include <neethi_policy.h> +#include <neethi_exactlyone.h> +#include <neethi_all.h> +#include <neethi_engine.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_saml_token rp_saml_token_t; + + AXIS2_EXTERN rp_saml_token_t * AXIS2_CALL + rp_saml_token_create( + const axutil_env_t *env); + + AXIS2_EXTERN void AXIS2_CALL + rp_saml_token_free( + rp_saml_token_t *saml_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_char_t * AXIS2_CALL + rp_saml_token_get_inclusion( + rp_saml_token_t *saml_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_saml_token_set_inclusion( + rp_saml_token_t *saml_token, + const axutil_env_t *env, + axis2_char_t * inclusion); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_saml_token_get_derivedkeys( + rp_saml_token_t *saml_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_saml_token_set_derivedkeys( + rp_saml_token_t *saml_token, + const axutil_env_t *env, + axis2_bool_t derivedkeys); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_saml_token_get_require_key_identifier_reference( + rp_saml_token_t * saml_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_saml_token_set_require_key_identifier_reference( + rp_saml_token_t * saml_token, + const axutil_env_t * env, + axis2_bool_t require_key_identifier_reference); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_saml_token_get_token_version_and_type( + rp_saml_token_t * saml_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_saml_token_set_token_version_and_type( + rp_saml_token_t * saml_token, + const axutil_env_t * env, + axis2_char_t * token_version_and_type); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_saml_token_increment_ref( + rp_saml_token_t * saml_token, + const axutil_env_t * env); + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_saml_token_builder.h b/neethi/include/rp_saml_token_builder.h new file mode 100644 index 0000000..5fbb8d9 --- /dev/null +++ b/neethi/include/rp_saml_token_builder.h @@ -0,0 +1,44 @@ +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SAML_TOKEN_BUILDER_H +#define RP_SAML_TOKEN_BUILDER_H + +/** @defgroup rp_saml_token_builder + * @ingroup rp_saml_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_saml_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_saml_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_secpolicy.h b/neethi/include/rp_secpolicy.h new file mode 100644 index 0000000..138cc1d --- /dev/null +++ b/neethi/include/rp_secpolicy.h @@ -0,0 +1,213 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SECPOLICY_H +#define RP_SECPOLICY_H + +/** @defgroup rp_secpolicy + * @ingroup rp_secpolicy + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_asymmetric_binding.h> +#include <rp_symmetric_binding.h> +#include <rp_transport_binding.h> +#include <rp_signed_encrypted_parts.h> +#include <rp_signed_encrypted_elements.h> +#include <rp_signed_encrypted_items.h> +#include <rp_supporting_tokens.h> +#include <rp_rampart_config.h> +#include <rp_wss10.h> +#include <rp_wss11.h> +#include <rp_trust10.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_secpolicy_t rp_secpolicy_t; + + AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL + rp_secpolicy_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_secpolicy_free( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_binding( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_property_t * binding); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_secpolicy_get_binding( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_supporting_tokens_t * supporting_tokens); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_secpolicy_get_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_signed_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_supporting_tokens_t * signed_supporting_tokens); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_secpolicy_get_signed_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_endorsing_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_supporting_tokens_t * endorsing_supporting_tokens); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_secpolicy_get_endorsing_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_signed_endorsing_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_supporting_tokens_t * signed_endorsing_supporting_tokens); + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_secpolicy_get_signed_endorsing_supporting_tokens( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_signed_parts( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_signed_encrypted_parts_t * signed_parts); + + AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL + rp_secpolicy_get_signed_parts( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_encrypted_parts( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_signed_encrypted_parts_t * encrypted_parts); + + AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL + rp_secpolicy_get_encrypted_parts( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_signed_elements( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_signed_encrypted_elements_t * signed_elements); + + AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL + rp_secpolicy_get_signed_elements( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_encrypted_elements( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_signed_encrypted_elements_t * encrypted_elements); + + AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL + rp_secpolicy_get_encrypted_elements( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_signed_items( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_signed_encrypted_items_t * signed_items); + + AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL + rp_secpolicy_get_signed_items( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_encrypted_items( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_signed_encrypted_items_t * encrypted_items); + + AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL + rp_secpolicy_get_encrypted_items( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_wss( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_property_t * wss); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_secpolicy_get_wss( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_rampart_config( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_rampart_config_t * rampart_config); + + AXIS2_EXTERN rp_rampart_config_t *AXIS2_CALL + rp_secpolicy_get_rampart_config( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_secpolicy_set_trust10( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env, + rp_trust10_t * trust10); + + AXIS2_EXTERN rp_trust10_t *AXIS2_CALL + rp_secpolicy_get_trust10( + rp_secpolicy_t * secpolicy, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_secpolicy_builder.h b/neethi/include/rp_secpolicy_builder.h new file mode 100644 index 0000000..5f32312 --- /dev/null +++ b/neethi/include/rp_secpolicy_builder.h @@ -0,0 +1,44 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SECPOLICY_BUILDER_H +#define RP_SECPOLICY_BUILDER_H + +/** @defgroup rp_secpolicy_builder + * @ingroup rp_secpolicy_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_secpolicy.h> +#include <neethi_policy.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL + rp_secpolicy_builder_build( + const axutil_env_t * env, + neethi_policy_t * policy); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_security_context_token.h b/neethi/include/rp_security_context_token.h new file mode 100644 index 0000000..b06b5e0 --- /dev/null +++ b/neethi/include/rp_security_context_token.h @@ -0,0 +1,143 @@ + +/* + * 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. + */ + +#ifndef RP_SECURITY_CONTEXT_TOKEN_H +#define RP_SECURITY_CONTEXT_TOKEN_H + +/** @defgroup rp_security_context_token + * @ingroup rp_security_context_token + * @{ + */ + +#include <rp_includes.h> +#include <neethi_policy.h> +#include <rp_token.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_security_context_token_t rp_security_context_token_t; + + AXIS2_EXTERN rp_security_context_token_t *AXIS2_CALL + rp_security_context_token_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_security_context_token_free( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_security_context_token_get_inclusion( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_inclusion( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env, + axis2_char_t * inclusion); + + AXIS2_EXTERN derive_key_type_t AXIS2_CALL + rp_security_context_token_get_derivedkey( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_derivedkey( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env, + derive_key_type_t derivedkey); + + AXIS2_EXTERN derive_key_version_t AXIS2_CALL + rp_security_context_token_get_derivedkey_version( + rp_security_context_token_t *security_context_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_derivedkey_version( + rp_security_context_token_t *security_context_token, + const axutil_env_t *env, + derive_key_version_t version); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_security_context_token_get_require_external_uri_ref( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_require_external_uri_ref( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env, + axis2_bool_t require_external_uri_ref); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_security_context_token_get_sc10_security_context_token( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_sc10_security_context_token( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env, + axis2_bool_t sc10_security_context_token); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_security_context_token_get_issuer( + rp_security_context_token_t *security_context_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_issuer( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env, + axis2_char_t *issuer); + + AXIS2_EXTERN neethi_policy_t *AXIS2_CALL + rp_security_context_token_get_bootstrap_policy( + rp_security_context_token_t *security_context_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_bootstrap_policy( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env, + neethi_policy_t *bootstrap_policy); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_security_context_token_get_is_secure_conversation_token( + rp_security_context_token_t *security_context_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_set_is_secure_conversation_token( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env, + axis2_bool_t is_secure_conversation_token); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_security_context_token_increment_ref( + rp_security_context_token_t * security_context_token, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_security_context_token_builder.h b/neethi/include/rp_security_context_token_builder.h new file mode 100644 index 0000000..45e2745 --- /dev/null +++ b/neethi/include/rp_security_context_token_builder.h @@ -0,0 +1,47 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SECURITY_CONTEXT_TOKEN_BUILDER_H +#define RP_SECURITY_CONTEXT_TOKEN_BUILDER_H + +/** @defgroup rp_security_context_token_builder + * @ingroup rp_security_context_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_security_context_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_security_context_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element, + axis2_char_t *sp_ns_uri, + axis2_bool_t is_secure_conversation_token); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_signature_token_builder.h b/neethi/include/rp_signature_token_builder.h new file mode 100644 index 0000000..13e2b79 --- /dev/null +++ b/neethi/include/rp_signature_token_builder.h @@ -0,0 +1,48 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SIGNATURE_TOKEN_BUILDER_H +#define RP_SIGNATURE_TOKEN_BUILDER_H + +/** @defgroup rp_signature_token_builder + * @ingroup rp_signature_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <rp_issued_token.h> +#include <rp_saml_token.h> +#include <rp_security_context_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_signature_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_signed_encrypted_elements.h b/neethi/include/rp_signed_encrypted_elements.h new file mode 100644 index 0000000..dc44b96 --- /dev/null +++ b/neethi/include/rp_signed_encrypted_elements.h @@ -0,0 +1,86 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SIGNED_ENCRYPTED_ELEMENTS_H +#define RP_SIGNED_ENCRYPTED_ELEMENTS_H + +/** @defgroup rp_signed_encrypted_elements + * @ingroup rp_signed_encrypted_elements + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_signed_encrypted_elements_t + rp_signed_encrypted_elements_t; + + AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL + rp_signed_encrypted_elements_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_signed_encrypted_elements_free( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_signed_encrypted_elements_get_signedelements( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_elements_set_signedelements( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env, + axis2_bool_t signedelements); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + rp_signed_encrypted_elements_get_xpath_expressions( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_elements_add_expression( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env, + axis2_char_t * expression); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_signed_encrypted_elements_get_xpath_version( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_elements_set_xpath_version( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env, + axis2_char_t * xpath_version); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_elements_increment_ref( + rp_signed_encrypted_elements_t * signed_encrypted_elements, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_signed_encrypted_items.h b/neethi/include/rp_signed_encrypted_items.h new file mode 100644 index 0000000..c29b82d --- /dev/null +++ b/neethi/include/rp_signed_encrypted_items.h @@ -0,0 +1,70 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SIGNED_ENCRYPTED_ITEMS_H +#define RP_SIGNED_ENCRYPTED_ITEMS_H + +/** @defgroup rp_signed_encrypted_items + * @ingroup rp_signed_encrypted_itemss + * @{ + */ + +#include <rp_includes.h> +#include <rp_element.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_signed_encrypted_items_t rp_signed_encrypted_items_t; + + AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL + rp_signed_encrypted_items_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_signed_encrypted_items_free( + rp_signed_encrypted_items_t * signed_encrypted_items, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_signed_encrypted_items_get_signeditems( + rp_signed_encrypted_items_t * signed_encrypted_items, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_items_set_signeditems( + rp_signed_encrypted_items_t * signed_encrypted_items, + const axutil_env_t * env, + axis2_bool_t signeditems); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + rp_signed_encrypted_items_get_elements( + rp_signed_encrypted_items_t * signed_encrypted_items, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_items_add_element( + rp_signed_encrypted_items_t * signed_encrypted_items, + const axutil_env_t * env, + rp_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_signed_encrypted_parts.h b/neethi/include/rp_signed_encrypted_parts.h new file mode 100644 index 0000000..3df23a0 --- /dev/null +++ b/neethi/include/rp_signed_encrypted_parts.h @@ -0,0 +1,98 @@ + +/* + * 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. + */ + +#ifndef RP_SIGNED_ENCRYPTED_PARTS_H +#define RP_SIGNED_ENCRYPTED_PARTS_H + +/** @defgroup rp_signed_encrypted_parts + * @ingroup rp_signed_encrypted_parts + * @{ + */ + +#include <rp_includes.h> +#include <rp_header.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_signed_encrypted_parts_t rp_signed_encrypted_parts_t; + + AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL + rp_signed_encrypted_parts_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_signed_encrypted_parts_free( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_signed_encrypted_parts_get_body( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_parts_set_body( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env, + axis2_bool_t body); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_signed_encrypted_parts_get_signedparts( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_parts_set_signedparts( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env, + axis2_bool_t signedparts); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_signed_encrypted_parts_get_attachments( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_parts_set_attachments( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env, + axis2_bool_t attachments); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + rp_signed_encrypted_parts_get_headers( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_parts_add_header( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env, + rp_header_t * header); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_signed_encrypted_parts_increment_ref( + rp_signed_encrypted_parts_t * signed_encrypted_parts, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_signed_encrypted_parts_builder.h b/neethi/include/rp_signed_encrypted_parts_builder.h new file mode 100644 index 0000000..fa7809e --- /dev/null +++ b/neethi/include/rp_signed_encrypted_parts_builder.h @@ -0,0 +1,55 @@ +/* + * 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. + */ + +#ifndef RP_SIGNED_ENCRYPTED_PARTS_BUILDER_H +#define RP_SIGNED_ENCRYPTED_PARTS_BUILDER_H + +/** @defgroup rp_signed_encrypted_parts_builder + * @ingroup rp_signed_encrypted_parts_builder + * @{ + */ + +#include <rp_signed_encrypted_parts.h> +#include <rp_header.h> +#include <rp_includes.h> +#include <rp_property.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** + * Builts EncryptedParts or SignedParts assertion + * @param env Pointer to environment struct + * @param node Assertion node + * @param element Assertion element + * @param is_signed boolean showing whether signing or encryption + * @returns neethi assertion created. NULL if failure. + */ + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_signed_encrypted_parts_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element, + axis2_bool_t is_signed); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_supporting_tokens.h b/neethi/include/rp_supporting_tokens.h new file mode 100644 index 0000000..6746454 --- /dev/null +++ b/neethi/include/rp_supporting_tokens.h @@ -0,0 +1,132 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SUPPORTING_TOKENS_H +#define RP_SUPPORTING_TOKENS_H + +/** @defgroup rp_supporting_tokens + * @ingroup rp_supporting_tokens + * @{ + */ +#include <rp_includes.h> +#include <rp_algorithmsuite.h> +#include <rp_signed_encrypted_parts.h> +#include <rp_signed_encrypted_elements.h> +#include <rp_property.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_supporting_tokens_t rp_supporting_tokens_t; + + AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL + rp_supporting_tokens_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_supporting_tokens_free( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + rp_supporting_tokens_get_tokens( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_add_token( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env, + rp_property_t * token); + + AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL + rp_supporting_tokens_get_algorithmsuite( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_set_algorithmsuite( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env, + rp_algorithmsuite_t * algorithmsuite); + + AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL + rp_supporting_tokens_get_signed_parts( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_set_signed_parts( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env, + rp_signed_encrypted_parts_t * signed_parts); + + AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL + rp_supporting_tokens_get_signed_elements( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_set_signed_elements( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env, + rp_signed_encrypted_elements_t * signed_elements); + + AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL + rp_supporting_tokens_get_encrypted_parts( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_set_encrypted_parts( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env, + rp_signed_encrypted_parts_t * encrypted_parts); + + AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL + rp_supporting_tokens_get_encrypted_elements( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_set_encrypted_elements( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env, + rp_signed_encrypted_elements_t * encrypted_elements); + + AXIS2_EXTERN int AXIS2_CALL + rp_supporting_tokens_get_type( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_set_type( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env, + int type); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_supporting_tokens_increment_ref( + rp_supporting_tokens_t * supporting_tokens, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_supporting_tokens_builder.h b/neethi/include/rp_supporting_tokens_builder.h new file mode 100644 index 0000000..f3df32a --- /dev/null +++ b/neethi/include/rp_supporting_tokens_builder.h @@ -0,0 +1,49 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SUPPORTING_TOKEN_BUILDER_H +#define RP_SUPPORTING_TOKEN_BUILDER_H + +/** @defgroup rp_supporting_tokens_builder + * @ingroup rp_supporting_tokens_builder + * @{ + */ + +#include <rp_supporting_tokens.h> +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <rp_username_token.h> +#include <rp_token_identifier.h> +#include <rp_algorithmsuite.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_supporting_tokens_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_symmetric_asymmetric_binding_commons.h b/neethi/include/rp_symmetric_asymmetric_binding_commons.h new file mode 100644 index 0000000..0251a1d --- /dev/null +++ b/neethi/include/rp_symmetric_asymmetric_binding_commons.h @@ -0,0 +1,117 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_ASSYMMETRIC_SYMMETRIC_BINDING_COMMONS_H +#define RP_ASSYMMETRIC_SYMMETRIC_BINDING_COMMONS_H + +/** @defgroup rp_assymmetric_symmetric_binding_commons + * @ingroup rp_assymmetric_symmetric_binding_commons + * @{ + */ + +#include <rp_includes.h> +#include <rp_binding_commons.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_symmetric_asymmetric_binding_commons_t + rp_symmetric_asymmetric_binding_commons_t; + + AXIS2_EXTERN rp_symmetric_asymmetric_binding_commons_t *AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_free( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN rp_binding_commons_t *AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_get_binding_commons( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_set_binding_commons( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env, + rp_binding_commons_t * binding_commons); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_get_signature_protection( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_set_signature_protection( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env, + axis2_bool_t signature_protection); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_get_token_protection( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_set_token_protection( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env, + axis2_bool_t token_protection); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_get_entire_headers_and_body_signatures + ( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_set_entire_headers_and_body_signatures + ( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env, + axis2_bool_t entire_headers_and_body_signatures); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_get_protection_order( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_asymmetric_binding_commons_set_protection_order( + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons, + const axutil_env_t * env, + axis2_char_t * protection_order); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_symmetric_binding.h b/neethi/include/rp_symmetric_binding.h new file mode 100644 index 0000000..05f412d --- /dev/null +++ b/neethi/include/rp_symmetric_binding.h @@ -0,0 +1,99 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SYMMETRIC_BINDING_H +#define RP_SYMMETRIC_BINDING_H + +/** @defgroup rp_symmetric_binding + * @ingroup rp_symmetric_binding + * @{ + */ + +#include <rp_includes.h> +#include <rp_symmetric_asymmetric_binding_commons.h> +#include <rp_property.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_symmetric_binding_t rp_symmetric_binding_t; + + AXIS2_EXTERN rp_symmetric_binding_t *AXIS2_CALL + rp_symmetric_binding_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_symmetric_binding_free( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN rp_symmetric_asymmetric_binding_commons_t *AXIS2_CALL + rp_symmetric_binding_get_symmetric_asymmetric_binding_commons( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_binding_set_symmetric_asymmetric_binding_commons( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env, + rp_symmetric_asymmetric_binding_commons_t * + symmetric_asymmetric_binding_commons); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_binding_set_protection_token( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env, + rp_property_t * protection_token); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_symmetric_binding_get_protection_token( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_binding_set_encryption_token( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env, + rp_property_t * encryption_token); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_symmetric_binding_get_encryption_token( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_binding_set_signature_token( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env, + rp_property_t * signature_token); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_symmetric_binding_get_signature_token( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_symmetric_binding_increment_ref( + rp_symmetric_binding_t * symmetric_binding, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_symmetric_binding_builder.h b/neethi/include/rp_symmetric_binding_builder.h new file mode 100644 index 0000000..3f5b669 --- /dev/null +++ b/neethi/include/rp_symmetric_binding_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_SYMMETRIC_BINDING_BUILDER_H +#define RP_SYMMETRIC_BINDING_BUILDER_H + +/** @defgroup rp_symmetric_binding_builder + * @ingroup rp_symmetric_binding_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_symmetric_binding.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_symmetric_binding_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_token.h b/neethi/include/rp_token.h new file mode 100644 index 0000000..eb3d84e --- /dev/null +++ b/neethi/include/rp_token.h @@ -0,0 +1,134 @@ + +/* + * 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. + */ + +#ifndef RP_GENERIC_TOKEN_H +#define RP_GENERIC_TOKEN_H + +/** @defgroup rp_token + * @ingroup rp_token + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef enum + { + DERIVEKEY_NONE =0, + DERIVEKEY_NEEDED, + DERIVEKEY_IMPLIED, + DERIVEKEY_EXPLICIT + } derive_key_type_t; + + typedef enum + { + DERIVEKEY_VERSION_SC10 =0, + DERIVEKEY_VERSION_SC13 + } derive_key_version_t; + + typedef struct rp_token_t rp_token_t; + + AXIS2_EXTERN rp_token_t *AXIS2_CALL + rp_token_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_token_free( + rp_token_t * token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_token_get_issuer( + rp_token_t * token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_set_issuer( + rp_token_t * token, + const axutil_env_t * env, + axis2_char_t * issuer); + + AXIS2_EXTERN derive_key_type_t AXIS2_CALL + rp_token_get_derivedkey_type( + rp_token_t * token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_set_derivedkey_type( + rp_token_t * token, + const axutil_env_t * env, + derive_key_type_t derivedkey); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_token_get_is_issuer_name( + rp_token_t * token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_set_is_issuer_name( + rp_token_t * token, + const axutil_env_t * env, + axis2_bool_t is_issuer_name); + + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + rp_token_get_claim( + rp_token_t * token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_set_claim( + rp_token_t * token, + const axutil_env_t * env, + axiom_node_t *claim); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_increment_ref( + rp_token_t * token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_set_derive_key_version( + rp_token_t *token, + const axutil_env_t *env, + derive_key_version_t version); + + AXIS2_EXTERN derive_key_version_t AXIS2_CALL + rp_token_get_derive_key_version( + rp_token_t *token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_set_inclusion( + rp_token_t *token, + const axutil_env_t *env, + axis2_char_t *inclusion); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_token_get_inclusion( + rp_token_t *token, + const axutil_env_t *env); + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_token_identifier.h b/neethi/include/rp_token_identifier.h new file mode 100644 index 0000000..b4d7d45 --- /dev/null +++ b/neethi/include/rp_token_identifier.h @@ -0,0 +1,46 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_TOKEN_IDENTIFIER_H +#define RP_TOKEN_IDENTIFIER_H + +/** @defgroup rp_token_identifier + * @ingroup rp_token_identifier + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <rp_username_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_token_identifier_set_token( + rp_property_t * token, + neethi_assertion_t * assertion, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_transport_binding.h b/neethi/include/rp_transport_binding.h new file mode 100644 index 0000000..ac904a6 --- /dev/null +++ b/neethi/include/rp_transport_binding.h @@ -0,0 +1,76 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_TRANSPORT_BINDING_H +#define RP_TRANSPORT_BINDING_H + +/** @defgroup rp_transport_binding + * @ingroup rp_transport_binding + * @{ + */ + +#include <rp_includes.h> +#include <rp_binding_commons.h> +#include <rp_property.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_transport_binding_t rp_transport_binding_t; + + AXIS2_EXTERN rp_transport_binding_t *AXIS2_CALL + rp_transport_binding_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_transport_binding_free( + rp_transport_binding_t * transport_binding, + const axutil_env_t * env); + + AXIS2_EXTERN rp_binding_commons_t *AXIS2_CALL + rp_transport_binding_get_binding_commons( + rp_transport_binding_t * transport_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_transport_binding_set_binding_commons( + rp_transport_binding_t * transport_binding, + const axutil_env_t * env, + rp_binding_commons_t * binding_commons); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_transport_binding_set_transport_token( + rp_transport_binding_t * transport_binding, + const axutil_env_t * env, + rp_property_t * transport_token); + + AXIS2_EXTERN rp_property_t *AXIS2_CALL + rp_transport_binding_get_transport_token( + rp_transport_binding_t * transport_binding, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_transport_binding_increment_ref( + rp_transport_binding_t * tansport_binding, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_transport_binding_builder.h b/neethi/include/rp_transport_binding_builder.h new file mode 100644 index 0000000..566b3aa --- /dev/null +++ b/neethi/include/rp_transport_binding_builder.h @@ -0,0 +1,46 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_TRANSPORT_BINDING_BUILDER_H +#define RP_TRANSPORT_BINDING_BUILDER_H + +/** @defgroup rp_transport_binding_builder + * @ingroup rp_transport_binding_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_transport_binding.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + + rp_transport_binding_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_transport_token_builder.h b/neethi/include/rp_transport_token_builder.h new file mode 100644 index 0000000..00887b4 --- /dev/null +++ b/neethi/include/rp_transport_token_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_TRANSPORT_TOKEN_BUILDER_H +#define RP_TRANSPORT_TOKEN_BUILDER_H + +/** @defgroup rp_transport_token_builder + * @ingroup rp_transport_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_https_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_transport_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_trust10.h b/neethi/include/rp_trust10.h new file mode 100644 index 0000000..d6a68bf --- /dev/null +++ b/neethi/include/rp_trust10.h @@ -0,0 +1,108 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_TRUST10_H +#define RP_TRUST10_H + +/** @defgroup trust10 + * @ingroup trust10 + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_trust10_t rp_trust10_t; + + AXIS2_EXTERN rp_trust10_t *AXIS2_CALL + rp_trust10_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_trust10_free( + rp_trust10_t * trust10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_trust10_get_must_support_client_challenge( + rp_trust10_t * trust10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_trust10_set_must_support_client_challenge( + rp_trust10_t * trust10, + const axutil_env_t * env, + axis2_bool_t must_support_client_challenge); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_trust10_get_must_support_server_challenge( + rp_trust10_t * trust10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_trust10_set_must_support_server_challenge( + rp_trust10_t * trust10, + const axutil_env_t * env, + axis2_bool_t must_support_server_challenge); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_trust10_get_require_client_entropy( + rp_trust10_t * trust10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_trust10_set_require_client_entropy( + rp_trust10_t * trust10, + const axutil_env_t * env, + axis2_bool_t require_client_entropy); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_trust10_get_require_server_entropy( + rp_trust10_t * trust10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_trust10_set_require_server_entropy( + rp_trust10_t * trust10, + const axutil_env_t * env, + axis2_bool_t require_server_entropy); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_trust10_get_must_support_issued_token( + rp_trust10_t * trust10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_trust10_set_must_support_issued_token( + rp_trust10_t * trust10, + const axutil_env_t * env, + axis2_bool_t must_support_issued_token); + + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_trust10_increment_ref( + rp_trust10_t * trust10, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_trust10_builder.h b/neethi/include/rp_trust10_builder.h new file mode 100644 index 0000000..443f343 --- /dev/null +++ b/neethi/include/rp_trust10_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_TRUST10_BUILDER_H +#define RP_TRUST10_BUILDER_H + +/** @defgroup rp_trust10_builder + * @ingroup rp_trust10_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_trust10.h> +#include <neethi_includes.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_trust10_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_username_token.h b/neethi/include/rp_username_token.h new file mode 100644 index 0000000..ce8e99f --- /dev/null +++ b/neethi/include/rp_username_token.h @@ -0,0 +1,138 @@ + +/* + * 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. + */ + +#ifndef RP_USERNAME_TOKEN_H +#define RP_USERNAME_TOKEN_H + +/** @defgroup rp_username_token + * @ingroup rp_username_token + * @{ + */ + +#include <rp_includes.h> +#include <rp_token.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef enum + { + PASSWORD_PLAIN = 0, + PASSWORD_HASH, + PASSWORD_NONE /* no password will be provided in the user name token */ + } password_type_t; + + typedef struct rp_username_token_t rp_username_token_t; + + AXIS2_EXTERN rp_username_token_t *AXIS2_CALL + rp_username_token_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_username_token_free( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_username_token_get_inclusion( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_set_inclusion( + rp_username_token_t * username_token, + const axutil_env_t * env, + axis2_char_t * inclusion); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_username_token_get_useUTprofile10( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_set_useUTprofile10( + rp_username_token_t * username_token, + const axutil_env_t * env, + axis2_bool_t useUTprofile10); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_username_token_get_useUTprofile11( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_set_useUTprofile11( + rp_username_token_t * username_token, + const axutil_env_t * env, + axis2_bool_t useUTprofile11); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_username_token_get_issuer( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_set_issuer( + rp_username_token_t * username_token, + const axutil_env_t * env, + axis2_char_t * issuer); + + AXIS2_EXTERN derive_key_type_t AXIS2_CALL + rp_username_token_get_derivedkey_type( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_set_derivedkey_type( + rp_username_token_t * username_token, + const axutil_env_t * env, + derive_key_type_t derivedkey); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_username_token_get_is_issuer_name( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_set_is_issuer_name( + rp_username_token_t * username_token, + const axutil_env_t * env, + axis2_bool_t is_issuer_name); + + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + rp_username_token_get_claim( + rp_username_token_t * username_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_set_claim( + rp_username_token_t * username_token, + const axutil_env_t * env, + axiom_node_t *claim); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_username_token_increment_ref( + rp_username_token_t * username_token, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_username_token_builder.h b/neethi/include/rp_username_token_builder.h new file mode 100644 index 0000000..fb7a268 --- /dev/null +++ b/neethi/include/rp_username_token_builder.h @@ -0,0 +1,45 @@ +/* + * 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. + */ + +#ifndef RP_USERNAME_TOKEN_BUILDER_H +#define RP_USERNAME_TOKEN_BUILDER_H + +/** @defgroup rp_username_token_builder + * @ingroup rp_username_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_username_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_username_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_wss10.h b/neethi/include/rp_wss10.h new file mode 100644 index 0000000..e06f68e --- /dev/null +++ b/neethi/include/rp_wss10.h @@ -0,0 +1,96 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_WSS10_H +#define RP_WSS10_H + +/** @defgroup wss10 + * @ingroup wss10 + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_wss10_t rp_wss10_t; + + AXIS2_EXTERN rp_wss10_t *AXIS2_CALL + rp_wss10_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_wss10_free( + rp_wss10_t * wss10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss10_get_must_support_ref_key_identifier( + rp_wss10_t * wss10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss10_set_must_support_ref_key_identifier( + rp_wss10_t * wss10, + const axutil_env_t * env, + axis2_bool_t must_support_ref_key_identifier); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss10_get_must_support_ref_issuer_serial( + rp_wss10_t * wss10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss10_set_must_support_ref_issuer_serial( + rp_wss10_t * wss10, + const axutil_env_t * env, + axis2_bool_t must_support_ref_issuer_serial); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss10_get_must_support_ref_external_uri( + rp_wss10_t * wss10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss10_set_must_support_ref_external_uri( + rp_wss10_t * wss10, + const axutil_env_t * env, + axis2_bool_t must_support_ref_external_uri); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss10_get_must_support_ref_embedded_token( + rp_wss10_t * wss10, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss10_set_must_support_ref_embedded_token( + rp_wss10_t * wss10, + const axutil_env_t * env, + axis2_bool_t must_support_ref_embedded_token); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss10_increment_ref( + rp_wss10_t * wss10, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_wss10_builder.h b/neethi/include/rp_wss10_builder.h new file mode 100644 index 0000000..388f308 --- /dev/null +++ b/neethi/include/rp_wss10_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_WSS10_BUILDER_H +#define RP_WSS10_BUILDER_H + +/** @defgroup rp_wss10_builder + * @ingroup rp_wss10_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_wss10.h> +#include <neethi_includes.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_wss10_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_wss11.h b/neethi/include/rp_wss11.h new file mode 100644 index 0000000..127867c --- /dev/null +++ b/neethi/include/rp_wss11.h @@ -0,0 +1,129 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_WSS11_H +#define RP_WSS11_H + +/** @defgroup wss11 + * @ingroup wss11 + * @{ + */ + +#include <rp_includes.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_wss11_t rp_wss11_t; + + AXIS2_EXTERN rp_wss11_t *AXIS2_CALL + rp_wss11_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_wss11_free( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss11_get_must_support_ref_key_identifier( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_set_must_support_ref_key_identifier( + rp_wss11_t * wss11, + const axutil_env_t * env, + axis2_bool_t must_support_ref_key_identifier); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss11_get_must_support_ref_issuer_serial( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_set_must_support_ref_issuer_serial( + rp_wss11_t * wss11, + const axutil_env_t * env, + axis2_bool_t must_support_ref_issuer_serial); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss11_get_must_support_ref_external_uri( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_set_must_support_ref_external_uri( + rp_wss11_t * wss11, + const axutil_env_t * env, + axis2_bool_t must_support_ref_external_uri); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss11_get_must_support_ref_embedded_token( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_set_must_support_ref_embedded_token( + rp_wss11_t * wss11, + const axutil_env_t * env, + axis2_bool_t must_support_ref_embedded_token); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss11_get_must_support_ref_thumbprint( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_set_must_support_ref_thumbprint( + rp_wss11_t * wss11, + const axutil_env_t * env, + axis2_bool_t must_support_ref_thumbprint); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_set_must_support_ref_encryptedkey( + rp_wss11_t * wss11, + const axutil_env_t * env, + axis2_bool_t must_support_ref_encryptedkey); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss11_get_must_support_ref_encryptedkey( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_set_require_signature_confirmation( + rp_wss11_t * wss11, + const axutil_env_t * env, + axis2_bool_t require_signature_confirmation); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_wss11_get_require_signature_confirmation( + rp_wss11_t * wss11, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_wss11_increment_ref( + rp_wss11_t * wss11, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_wss11_builder.h b/neethi/include/rp_wss11_builder.h new file mode 100644 index 0000000..6e83a5c --- /dev/null +++ b/neethi/include/rp_wss11_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_WSS11_BUILDER_H +#define RP_WSS11_BUILDER_H + +/** @defgroup rp_wss11_builder + * @ingroup rp_wss11_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_wss11.h> +#include <neethi_includes.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_wss11_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_x509_token.h b/neethi/include/rp_x509_token.h new file mode 100644 index 0000000..7263a15 --- /dev/null +++ b/neethi/include/rp_x509_token.h @@ -0,0 +1,142 @@ + +/* + * 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. + */ + +#ifndef RP_X509_TOKEN_H +#define RP_X509_TOKEN_H + +/** @defgroup rp_x509_token + * @ingroup rp_x509_token + * @{ + */ + +#include <rp_includes.h> +#include <rp_token.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct rp_x509_token_t rp_x509_token_t; + + AXIS2_EXTERN rp_x509_token_t *AXIS2_CALL + rp_x509_token_create( + const axutil_env_t * env); + + AXIS2_EXTERN void AXIS2_CALL + rp_x509_token_free( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_x509_token_get_inclusion( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_inclusion( + rp_x509_token_t * x509_token, + const axutil_env_t * env, + axis2_char_t * inclusion); + + AXIS2_EXTERN derive_key_type_t AXIS2_CALL + rp_x509_token_get_derivedkey( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_derivedkey( + rp_x509_token_t * x509_token, + const axutil_env_t * env, + derive_key_type_t derivedkeys); + + AXIS2_EXTERN derive_key_version_t AXIS2_CALL + rp_x509_token_get_derivedkey_version( + rp_x509_token_t *x509_token, + const axutil_env_t *env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_derivedkey_version( + rp_x509_token_t *x509_token, + const axutil_env_t *env, + derive_key_version_t version); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_x509_token_get_require_key_identifier_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_require_key_identifier_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env, + axis2_bool_t require_key_identifier_reference); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_x509_token_get_require_issuer_serial_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_require_issuer_serial_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env, + axis2_bool_t require_issuer_serial_reference); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_x509_token_get_require_embedded_token_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_require_embedded_token_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env, + axis2_bool_t require_embedded_token_reference); + + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + rp_x509_token_get_require_thumb_print_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_require_thumb_print_reference( + rp_x509_token_t * x509_token, + const axutil_env_t * env, + axis2_bool_t require_thumb_print_reference); + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + rp_x509_token_get_token_version_and_type( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_set_token_version_and_type( + rp_x509_token_t * x509_token, + const axutil_env_t * env, + axis2_char_t * token_version_and_type); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + rp_x509_token_increment_ref( + rp_x509_token_t * x509_token, + const axutil_env_t * env); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/neethi/include/rp_x509_token_builder.h b/neethi/include/rp_x509_token_builder.h new file mode 100644 index 0000000..ca5d11e --- /dev/null +++ b/neethi/include/rp_x509_token_builder.h @@ -0,0 +1,45 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed 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. + */ + +#ifndef RP_X509_TOKEN_BUILDER_H +#define RP_X509_TOKEN_BUILDER_H + +/** @defgroup rp_x509_token_builder + * @ingroup rp_x509_token_builder + * @{ + */ + +#include <rp_includes.h> +#include <rp_property.h> +#include <rp_x509_token.h> +#include <neethi_assertion.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + + AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL + rp_x509_token_builder_build( + const axutil_env_t * env, + axiom_node_t * node, + axiom_element_t * element); + +#ifdef __cplusplus +} +#endif +#endif |