Moving axis svn, part of TLP move INFRA-2441

git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68

239 files changed, 24751 insertions, 0 deletions

diff --git a/neethi/AUTHORS b/neethi/AUTHORS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/neethi/AUTHORS
diff --git a/neethi/COPYING b/neethi/COPYING
new file mode 100644
index 0000000..6b0b127
--- /dev/null
+++ b/neethi/COPYING
@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
+
diff --git a/neethi/ChangeLog b/neethi/ChangeLog
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/neethi/ChangeLog
diff --git a/neethi/INSTALL b/neethi/INSTALL
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/neethi/INSTALL
diff --git a/neethi/Makefile.am b/neethi/Makefile.am
new file mode 100644
index 0000000..32865c7
--- /dev/null
+++ b/neethi/Makefile.am
@@ -0,0 +1,3 @@
+SUBDIRS = src test
+includedir=$(prefix)/include/axis2-1.6.0
+include_HEADERS=$(top_builddir)/include/*.h
diff --git a/neethi/NEWS b/neethi/NEWS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/neethi/NEWS
diff --git a/neethi/README b/neethi/README
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/neethi/README
diff --git a/neethi/autogen.sh b/neethi/autogen.sh
new file mode 100755
index 0000000..1800ea5
--- /dev/null
+++ b/neethi/autogen.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+
+echo -n 'Running libtoolize...'
+if [ `uname -s` = Darwin ]
+then
+    LIBTOOLIZE=glibtoolize
+else
+    LIBTOOLIZE=libtoolize
+fi
+
+if $LIBTOOLIZE --force > /dev/null 2>&1; then
+
+    echo 'done.'
+else
+    echo 'failed.'
+    exit 1
+fi
+
+echo -n 'Running aclocal...'
+if aclocal > /dev/null 2>&1; then
+	echo 'done.'
+else
+	echo 'failed.'
+	exit 1
+fi
+
+echo -n 'Running autoheader...'
+if autoheader > /dev/null 2>&1; then
+	echo 'done.'
+else
+	echo 'failed.'
+	exit 1
+fi
+
+echo -n 'Running autoconf...'
+if autoconf > /dev/null 2>&1; then
+	echo 'done.'
+else
+	echo 'failed.'
+	exit 1
+fi
+
+echo -n 'Running automake...'
+if automake --add-missing > /dev/null 2>&1; then
+	echo 'done.'
+else
+	echo 'failed.'
+	exit 1
+fi
+
+echo 'done'
diff --git a/neethi/configure.ac b/neethi/configure.ac
new file mode 100644
index 0000000..f3a317c
--- /dev/null
+++ b/neethi/configure.ac
@@ -0,0 +1,73 @@
+dnl run autogen.sh to generate the configure script.
+
+AC_PREREQ(2.59)
+
+AC_INIT(neethi-src, 1.6.0)
+AC_CANONICAL_SYSTEM
+AM_CONFIG_HEADER(config.h)
+dnl AM_INIT_AUTOMAKE([tar-ustar])
+AM_INIT_AUTOMAKE
+m4_ifdef([_A][M_PROG_TAR],[_A][M_SET_OPTION([tar-ustar])])
+AC_PREFIX_DEFAULT(/usr/local/neethi)
+
+dnl Checks for programs.
+AC_PROG_CC
+AC_PROG_CXX
+AC_PROG_CPP
+AC_PROG_LIBTOOL
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+
+dnl check for flavours of varargs macros (test from GLib)
+AC_MSG_CHECKING(for ISO C99 varargs macros in C)
+AC_TRY_COMPILE([],[
+int a(int p1, int p2, int p3);
+#define call_a(...) a(1,__VA_ARGS__)
+call_a(2,3);
+],axis2c_have_iso_c_varargs=yes,axis2c_have_iso_c_varargs=no)
+AC_MSG_RESULT($axis2c_have_iso_c_varargs)
+
+dnl Checks for libraries.
+AC_CHECK_LIB(dl, dlopen)
+
+#CFLAGS="$CFLAGS -ansi -Wall -D_LARGEFILE64_SOURCE -Wno-implicit-function-declaration"
+CFLAGS="$CFLAGS -D_LARGEFILE64_SOURCE"
+if test "$GCC" = "yes"; then
+    CFLAGS="$CFLAGS -ansi -Wall -Werror -Wno-implicit-function-declaration "
+fi
+
+
+dnl Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([stdio.h stdlib.h string.h])
+AC_CHECK_HEADERS([sys/socket.h])
+dnl This is a check to see if we are running MacOS X
+dnl It may be better to do a Darwin check
+AC_CHECK_HEADER([sys/appleapiopts.h],
+               [AC_DEFINE([IS_MACOSX],[1],[Define to 1 if compiling on MacOS X])],
+               [])
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+dnl AC_C_CONST
+
+dnl Checks for library functions.
+dnl AC_FUNC_MALLOC
+dnl AC_FUNC_REALLOC
+#AC_CHECK_FUNCS([memmove])
+
+VERSION_NO="6:0:6"
+
+AC_SUBST(VERSION_NO)
+
+
+AC_CONFIG_FILES([Makefile \
+    src/Makefile \
+    src/secpolicy/Makefile \
+    src/secpolicy/model/Makefile \
+    src/secpolicy/builder/Makefile \
+    src/rmpolicy/Makefile \
+    test/Makefile
+    ])
+    
+AC_OUTPUT
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
diff --git a/neethi/src/Makefile.am b/neethi/src/Makefile.am
new file mode 100644
index 0000000..12bff83
--- /dev/null
+++ b/neethi/src/Makefile.am
@@ -0,0 +1,53 @@
+SUBDIRS = secpolicy rmpolicy
+lib_LTLIBRARIES=libneethi.la
+
+libneethi_la_SOURCES= all.c   \
+				assertion.c \
+				engine.c \
+				exactlyone.c \
+				operator.c \
+				policy.c \
+				reference.c \
+				registry.c \
+				assertion_builder.c \
+				mtom_assertion_checker.c \
+				util.c
+
+libneethi_la_LIBADD  = ../../axiom/src/om/libaxis2_axiom.la \
+			../../util/src/libaxutil.la \
+			secpolicy/builder/librp_builder.la \
+			secpolicy/model/librp_model.la \
+			rmpolicy/librm_policy.la
+
+#libneethi_LIBADD=$(top_builddir)/src/core/description/libaxis2_description.la \
+#                    $(top_builddir)/src/core/receivers/libaxis2_receivers.la \
+#					$(top_builddir)/src/core/deployment/libaxis2_deployment.la \
+#					$(top_builddir)/src/core/context/libaxis2_context.la \
+#					$(top_builddir)/src/core/addr/libaxis2_addr.la \
+#					$(top_builddir)/src/core/clientapi/libaxis2_clientapi.la \
+#					$(top_builddir)/src/core/phaseresolver/libaxis2_phaseresolver.la \
+#					$(top_builddir)/src/core/util/libaxis2_core_utils.la \
+#					$(top_builddir)/src/core/transport/http/common/libaxis2_http_common.la \
+#					$(top_builddir)/src/core/transport/http/util/libaxis2_http_util.la \
+#					$(top_builddir)/util/src/libaxutil.la \
+#					$(top_builddir)/axiom/src/om/libaxis2_axiom.la 
+
+
+libneethi_la_LDFLAGS = -version-info $(VERSION_NO)
+
+INCLUDES = -I$(top_builddir)/include \
+		-I ../../util/include \
+		-I ../../axiom/include \
+		-I ../../include
+
+#            -I$(top_builddir)/src/wsdl \
+#            -I$(top_builddir)/src/core/description \
+#            -I$(top_builddir)/src/core/engine \
+#            -I$(top_builddir)/src/core/phaseresolver \
+#            -I$(top_builddir)/src/core/deployment \
+#            -I$(top_builddir)/src/core/context \
+#            -I$(top_builddir)/src/core/util \
+#            -I$(top_builddir)/src/core/clientapi \
+#            -I$(top_builddir)/util/include \
+#            -I$(top_builddir)/axiom/include
+
diff --git a/neethi/src/all.c b/neethi/src/all.c
new file mode 100644
index 0000000..780cd3f
--- /dev/null
+++ b/neethi/src/all.c
@@ -0,0 +1,183 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_all.h>
+
+struct neethi_all_t
+{
+    axutil_array_list_t *policy_components;
+};
+
+AXIS2_EXTERN neethi_all_t *AXIS2_CALL
+neethi_all_create(
+    const axutil_env_t *env)
+{
+    neethi_all_t *neethi_all = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    neethi_all = (neethi_all_t *)AXIS2_MALLOC(env->allocator, sizeof(neethi_all_t));
+
+    if(neethi_all == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_all->policy_components = NULL;
+
+    neethi_all->policy_components = axutil_array_list_create(env, 0);
+    if(!(neethi_all->policy_components))
+    {
+        neethi_all_free(neethi_all, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    return neethi_all;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+neethi_all_free(
+    neethi_all_t *neethi_all,
+    const axutil_env_t *env)
+{
+    if(neethi_all)
+    {
+        if(neethi_all->policy_components)
+        {
+            int i = 0;
+            int size = 0;
+
+            size = axutil_array_list_size(neethi_all->policy_components, env);
+
+            for(i = 0; i < size; i++)
+            {
+                neethi_operator_t *operator = NULL;
+                operator = (neethi_operator_t *)axutil_array_list_get(
+                    neethi_all->policy_components, env, i);
+                if(operator)
+                {
+                    neethi_operator_free(operator, env);
+                    operator = NULL;
+                }
+                operator = NULL;
+            }
+            axutil_array_list_free(neethi_all->policy_components, env);
+            neethi_all->policy_components = NULL;
+        }
+        AXIS2_FREE(env->allocator, neethi_all);
+        neethi_all = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+neethi_all_get_policy_components(
+    neethi_all_t *neethi_all,
+    const axutil_env_t *env)
+{
+    return neethi_all->policy_components;
+}
+
+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)
+{
+
+    int size = axutil_array_list_size(arraylist, env);
+    int i = 0;
+
+    if(axutil_array_list_ensure_capacity(all->policy_components, env, size + 1) != AXIS2_SUCCESS)
+        return AXIS2_FAILURE;
+
+    for(i = 0; i < size; i++)
+    {
+        void *value = NULL;
+        value = axutil_array_list_get(arraylist, env, i);
+        neethi_operator_increment_ref((neethi_operator_t *)value, env);
+        axutil_array_list_add(all->policy_components, env, value);
+    }
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_all_add_operator(
+    neethi_all_t *neethi_all,
+    const axutil_env_t *env,
+    neethi_operator_t *operator)
+{
+    neethi_operator_increment_ref(operator, env);
+    axutil_array_list_add(neethi_all->policy_components, env, operator);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+neethi_all_is_empty(
+    neethi_all_t *all,
+    const axutil_env_t *env)
+{
+    return axutil_array_list_is_empty(all->policy_components, 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)
+{
+    axiom_node_t *all_node = NULL;
+    axiom_element_t *all_ele = NULL;
+    axiom_namespace_t *policy_ns = NULL;
+    axutil_array_list_t *components = NULL;
+
+    policy_ns = axiom_namespace_create(env, NEETHI_NAMESPACE, NEETHI_PREFIX);
+    all_ele = axiom_element_create(env, parent, NEETHI_ALL, policy_ns, &all_node);
+    if(!all_node)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "Neethi 'all' node creation failed. Cannot serialize 'all' assertion");
+        return AXIS2_FAILURE;
+    }
+
+    components = neethi_all_get_policy_components(neethi_all, env);
+    if(components)
+    {
+        axis2_status_t status = AXIS2_FAILURE;
+        int i = 0;
+        for(i = 0; i < axutil_array_list_size(components, env); i++)
+        {
+            neethi_operator_t *operator = NULL;
+            operator = (neethi_operator_t *)axutil_array_list_get(components, env, i);
+            if(operator)
+            {
+                status = neethi_operator_serialize(operator, env, all_node);
+                if(status != AXIS2_SUCCESS)
+                {
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Neethi operator serialization failed. Cannot serialize 'all' assertion");
+                    return AXIS2_FAILURE;
+                }
+            }
+        }
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/assertion.c b/neethi/src/assertion.c
new file mode 100644
index 0000000..29c70be
--- /dev/null
+++ b/neethi/src/assertion.c
@@ -0,0 +1,424 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_assertion.h>
+#include <axiom_util.h>
+#include <rp_x509_token.h>
+#include <rp_property.h>
+#include <rp_layout.h>
+#include <rp_algorithmsuite.h>
+#include <rp_wss10.h>
+#include <rp_wss11.h>
+#include <rp_trust10.h>
+#include <rp_supporting_tokens.h>
+#include <rp_username_token.h>
+#include <rp_asymmetric_binding.h>
+#include <rp_rampart_config.h>
+#include <rp_signed_encrypted_parts.h>
+#include <rp_symmetric_binding.h>
+#include <rp_transport_binding.h>
+#include <rp_saml_token.h>
+#include <rp_issued_token.h>
+
+struct neethi_assertion_t
+{
+    void *value;
+    neethi_assertion_type_t type;
+    axutil_array_list_t *policy_components;
+    axiom_element_t *element;
+    axiom_node_t *node;
+    axis2_bool_t is_optional;
+    AXIS2_FREE_VOID_ARG free_func;
+};
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+neethi_assertion_create(
+    const axutil_env_t *env)
+{
+    neethi_assertion_t *neethi_assertion = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    neethi_assertion = (neethi_assertion_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(neethi_assertion_t));
+
+    if(neethi_assertion == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_assertion->policy_components = NULL;
+
+    neethi_assertion->policy_components = axutil_array_list_create(env, 0);
+    if(!(neethi_assertion->policy_components))
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_assertion->value = NULL;
+    neethi_assertion->type = ASSERTION_TYPE_UNKNOWN;
+    neethi_assertion->element = NULL;
+    neethi_assertion->is_optional = AXIS2_FALSE;
+    neethi_assertion->node = NULL;
+    neethi_assertion->free_func = 0;
+
+    return neethi_assertion;
+}
+
+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)
+{
+    neethi_assertion_t *neethi_assertion = NULL;
+    neethi_assertion = (neethi_assertion_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(neethi_assertion_t));
+
+    if(!neethi_assertion)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Neethi assertion creation failed. Out of memory");
+        return NULL;
+    }
+
+    neethi_assertion->policy_components = NULL;
+    neethi_assertion->policy_components = axutil_array_list_create(env, 0);
+    if(!(neethi_assertion->policy_components))
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "Neethi assertion policy components creation failed.");
+        return NULL;
+    }
+
+    /* This ref count is for asertions which are represented from a struct.
+     * These assertion structs are more probably referenced from some other
+     * struct. So we need to increment the ref count in order to prevent
+     * unnecessary memory freeing */
+
+    if(type == ASSERTION_TYPE_X509_TOKEN)
+    {
+        rp_x509_token_increment_ref((rp_x509_token_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_SECURITY_CONTEXT_TOKEN)
+    {
+        rp_security_context_token_increment_ref((rp_security_context_token_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_INITIATOR_TOKEN)
+    {
+        rp_property_increment_ref((rp_property_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_RECIPIENT_TOKEN)
+    {
+        rp_property_increment_ref((rp_property_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_PROTECTION_TOKEN)
+    {
+        rp_property_increment_ref((rp_property_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_ENCRYPTION_TOKEN)
+    {
+        rp_property_increment_ref((rp_property_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_TRANSPORT_TOKEN)
+    {
+        rp_property_increment_ref((rp_property_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_SIGNATURE_TOKEN)
+    {
+        rp_property_increment_ref((rp_property_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_LAYOUT)
+    {
+        rp_layout_increment_ref((rp_layout_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_ALGORITHM_SUITE)
+    {
+        rp_algorithmsuite_increment_ref((rp_algorithmsuite_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_WSS10)
+    {
+        rp_wss10_increment_ref((rp_wss10_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_WSS11)
+    {
+        rp_wss11_increment_ref((rp_wss11_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_TRUST10)
+    {
+        rp_trust10_increment_ref((rp_trust10_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_SUPPORTING_TOKENS)
+    {
+        rp_supporting_tokens_increment_ref((rp_supporting_tokens_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_USERNAME_TOKEN)
+    {
+        rp_username_token_increment_ref((rp_username_token_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_ASSYMMETRIC_BINDING)
+    {
+        rp_asymmetric_binding_increment_ref((rp_asymmetric_binding_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_SYMMETRIC_BINDING)
+    {
+        rp_symmetric_binding_increment_ref((rp_symmetric_binding_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_TRANSPORT_BINDING)
+    {
+        rp_transport_binding_increment_ref((rp_transport_binding_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS)
+    {
+        rp_signed_encrypted_parts_increment_ref((rp_signed_encrypted_parts_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_RAMPART_CONFIG)
+    {
+        rp_rampart_config_increment_ref((rp_rampart_config_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_ISSUED_TOKEN)
+    {
+        rp_issued_token_increment_ref((rp_issued_token_t *)value, env);
+    }
+    else if(type == ASSERTION_TYPE_SAML_TOKEN)
+    {
+        rp_saml_token_increment_ref((rp_saml_token_t *)value, env);
+    }
+
+    neethi_assertion->value = value;
+    neethi_assertion->type = type;
+    neethi_assertion->element = NULL;
+    neethi_assertion->is_optional = AXIS2_FALSE;
+    neethi_assertion->node = NULL;
+    neethi_assertion->free_func = free_func;
+
+    return neethi_assertion;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+neethi_assertion_free(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    if(neethi_assertion)
+    {
+        if(neethi_assertion->policy_components)
+        {
+            int i = 0;
+            for(i = 0; i < axutil_array_list_size(neethi_assertion->policy_components, env); i++)
+            {
+                neethi_operator_t *operator = NULL;
+                operator = (neethi_operator_t *)axutil_array_list_get(
+                    neethi_assertion->policy_components, env, i);
+                if(operator)
+                    neethi_operator_free(operator, env);
+
+                operator = NULL;
+            }
+            axutil_array_list_free(neethi_assertion->policy_components, env);
+            neethi_assertion->policy_components = NULL;
+        }
+        if(neethi_assertion->value)
+        {
+            if(neethi_assertion->free_func)
+            {
+                neethi_assertion->free_func(neethi_assertion->value, env);
+            }
+        }
+        AXIS2_FREE(env->allocator, neethi_assertion);
+        neethi_assertion = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN neethi_assertion_type_t AXIS2_CALL
+neethi_assertion_get_type(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    return neethi_assertion->type;
+}
+
+AXIS2_EXTERN void *AXIS2_CALL
+neethi_assertion_get_value(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    return neethi_assertion->value;
+}
+
+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)
+{
+    neethi_assertion->type = type;
+    if(type == ASSERTION_TYPE_X509_TOKEN)
+    {
+        rp_x509_token_increment_ref((rp_x509_token_t *)value, env);
+    }
+    neethi_assertion->value = (void *)value;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+neethi_assertion_get_element(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return neethi_assertion->element;
+}
+
+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)
+{
+    neethi_assertion->element = element;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+neethi_assertion_get_node(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    return neethi_assertion->node;
+}
+
+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)
+{
+    if(neethi_assertion->node)
+    {
+        axiom_node_free_tree(neethi_assertion->node, env);
+        neethi_assertion->node = NULL;
+    }
+
+    if(node)
+    {
+        neethi_assertion->node = axiom_util_clone_node(env, node);
+    }
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+neethi_assertion_get_is_optional(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    return neethi_assertion->is_optional;
+}
+
+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)
+{
+    neethi_assertion->is_optional = is_optional;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+neethi_assertion_get_policy_components(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    return neethi_assertion->policy_components;
+}
+
+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)
+{
+
+    int size = axutil_array_list_size(arraylist, env);
+    int i = 0;
+
+    if(axutil_array_list_ensure_capacity(neethi_assertion->policy_components, env, size + 1)
+        != AXIS2_SUCCESS)
+        return AXIS2_FAILURE;
+
+    for(i = 0; i < size; i++)
+    {
+        void *value = NULL;
+        value = axutil_array_list_get(arraylist, env, i);
+        neethi_operator_increment_ref((neethi_operator_t *)value, env);
+        axutil_array_list_add(neethi_assertion->policy_components, env, value);
+    }
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_assertion_add_operator(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env,
+    neethi_operator_t *operator)
+{
+    neethi_operator_increment_ref(operator, env);
+    axutil_array_list_add(neethi_assertion->policy_components, env, operator);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+neethi_assertion_is_empty(
+    neethi_assertion_t *neethi_assertion,
+    const axutil_env_t *env)
+{
+    return axutil_array_list_is_empty(neethi_assertion->policy_components, env);
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_assertion_serialize(
+    neethi_assertion_t *assertion,
+    axiom_node_t *parent,
+    const axutil_env_t *env)
+{
+    axiom_node_t *node = NULL;
+    if(assertion->node)
+    {
+        node = axiom_util_clone_node(env, assertion->node);
+    }
+
+    if(!node)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "assertion node creation failed. Cannot serialize assertion");
+        return AXIS2_FAILURE;
+    }
+
+    axiom_node_add_child(parent, env, node);
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/assertion_builder.c b/neethi/src/assertion_builder.c
new file mode 100644
index 0000000..e6f4064
--- /dev/null
+++ b/neethi/src/assertion_builder.c
@@ -0,0 +1,513 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_assertion_builder.h>
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+neethi_assertion_builder_build(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    axis2_char_t *localname = NULL;
+    axis2_char_t *ns = NULL;
+    axutil_qname_t *node_qname = NULL;
+
+    localname = axiom_element_get_localname(element, env);
+    if(!localname)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get localname from element.");
+        return NULL;
+    }
+
+    node_qname = axiom_element_get_qname(element, env, node);
+    if(!node_qname)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get qname from element %s.",
+            localname);
+        return NULL;
+    }
+
+    ns = axutil_qname_get_uri(node_qname, env);
+    if(!ns)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get namespace from element %s.",
+            localname);
+        return NULL;
+    }
+
+    if(!(axutil_strcmp(ns, RP_SP_NS_11) && axutil_strcmp(ns, RP_SP_NS_12)))
+    {
+        /* if namespace is WS-SecurityPolicy Namespace */
+        if(!axutil_strcmp(localname, RP_TRANSPORT_BINDING))
+        {
+            return rp_transport_binding_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_ASYMMETRIC_BINDING))
+        {
+            return rp_asymmetric_binding_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_SYMMETRIC_BINDING))
+        {
+            return rp_symmetric_binding_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_TRANSPORT_TOKEN))
+        {
+            return rp_transport_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_RECIPIENT_TOKEN))
+        {
+            return rp_recipient_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_INITIATOR_TOKEN))
+        {
+            return rp_initiator_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_PROTECTION_TOKEN))
+        {
+            return rp_protection_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_ENCRYPTION_TOKEN))
+        {
+            return rp_encryption_token_builder_build(env, node, element);
+        }
+
+        else if(!axutil_strcmp(localname, RP_SIGNATURE_TOKEN))
+        {
+            return rp_signature_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_X509_TOKEN))
+        {
+            return rp_x509_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_SECURITY_CONTEXT_TOKEN))
+        {
+            return rp_security_context_token_builder_build(env, node, element, ns, AXIS2_FALSE);
+        }
+        else if(!axutil_strcmp(localname, RP_SECURE_CONVERSATION_TOKEN))
+        {
+            return rp_security_context_token_builder_build(env, node, element, ns, AXIS2_TRUE);
+        }
+        else if(!axutil_strcmp(localname, RP_ENCRYPT_BEFORE_SIGNING))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_ENCRYPT_BEFORE_SIGNING);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_SIGN_BEFORE_ENCRYPTING))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_SIGN_BEFORE_ENCRYPTING);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_ENCRYPT_SIGNATURE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_ENCRYPT_SIGNATURE);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_PROTECT_TOKENS))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_PROTECT_TOKENS);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_ONLY_SIGN_ENTIRE_HEADERS_AND_BODY))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_ONLY_SIGN_ENTIRE_HEADERS_AND_BODY);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_KEY_IDENTIFIRE_REFERENCE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_REQUIRE_KEY_IDENTIFIRE_REFERENCE);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_ISSUER_SERIAL_REFERENCE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_REQUIRE_ISSUER_SERIAL_REFERENCE);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_EMBEDDED_TOKEN_REFERENCE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_REQUIRE_EMBEDDED_TOKEN_REFERENCE);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_THUMBPRINT_REFERENCE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_REQUIRE_THUMBPRINT_REFERENCE);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_X509_V1_TOKEN_10))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_X509_V1_TOKEN_10);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_X509_V3_TOKEN_10))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_X509_V3_TOKEN_10);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_ALGORITHM_SUITE))
+        {
+            return rp_algorithmsuite_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_LAYOUT))
+        {
+            return rp_layout_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_USERNAME_TOKEN))
+        {
+            return rp_username_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_SIGNED_SUPPORTING_TOKENS))
+        {
+            return rp_supporting_tokens_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_SUPPORTING_TOKENS))
+        {
+            return rp_supporting_tokens_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_ENDORSING_SUPPORTING_TOKENS))
+        {
+            return rp_supporting_tokens_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_SIGNED_ENDORSING_SUPPORTING_TOKENS))
+        {
+            return rp_supporting_tokens_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_WSS10))
+        {
+            return rp_wss10_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_WSS11))
+        {
+            return rp_wss11_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_TRUST10))
+        {
+            return rp_trust10_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_TRUST13))
+        {
+            /* we can still use rp_trust10 structures */
+            return rp_trust10_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_INCLUDE_TIMESTAMP))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_INCLUDE_TIMESTAMP);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_HTTPS_TOKEN))
+        {
+            return rp_https_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_USERNAME_TOKEN_10))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_USERNAME_TOKEN_10);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_USERNAME_TOKEN_11))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_USERNAME_TOKEN_11);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_REF_KEY_IDENTIFIER))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_REF_KEY_IDENTIFIER);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_REF_ISSUER_SERIAL))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_REF_ISSUER_SERIAL);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_REF_EXTERNAL_URI))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_REF_EXTERNAL_URI);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_REF_EMBEDDED_TOKEN))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_REF_EMBEDDED_TOKEN);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_SIGNED_PARTS))
+        {
+            return rp_signed_encrypted_parts_builder_build(env, node, element, AXIS2_TRUE);
+        }
+        else if(!axutil_strcmp(localname, RP_ENCRYPTED_PARTS))
+        {
+            return rp_signed_encrypted_parts_builder_build(env, node, element, AXIS2_FALSE);
+        }
+        else if(!axutil_strcmp(localname, RP_BOOTSTRAP_POLICY))
+        {
+            return rp_bootstrap_policy_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_REF_THUMBPRINT))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_REF_THUMBPRINT);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_REF_ENCRYPTED_KEY))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_REF_ENCRYPTED_KEY);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_SIGNATURE_CONFIRMATION))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_REQUIRE_SIGNATURE_CONFIRMATION);
+            return assertion;
+        }
+
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_CLIENT_CHALLENGE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_CLIENT_CHALLENGE);
+            return assertion;
+        }
+
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_SERVER_CHALLENGE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_SERVER_CHALLENGE);
+            return assertion;
+        }
+
+        else if(!axutil_strcmp(localname, RP_REQUIRE_CLIENT_ENTROPY))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_REQUIRE_CLIENT_ENTROPY);
+            return assertion;
+        }
+
+        else if(!axutil_strcmp(localname, RP_REQUIRE_SERVER_ENTROPHY))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_REQUIRE_SERVER_ENTROPHY);
+            return assertion;
+        }
+
+        else if(!axutil_strcmp(localname, RP_MUST_SUPPORT_ISSUED_TOKENS))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_MUST_SUPPORT_ISSUED_TOKENS);
+            return assertion;
+        }
+
+        else if(!axutil_strcmp(localname, RP_REQUIRE_DERIVED_KEYS))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            if(!axutil_strcmp(ns, RP_SP_NS_11))
+            {
+                /* derived key should be as defined in WS-SecConversation 1.0 */
+                neethi_assertion_set_value(assertion, env, NULL,
+                    ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10);
+            }
+            else
+            {
+                /* derived key should be as defined in WS-SecConversation 1.3 */
+                neethi_assertion_set_value(assertion, env, NULL,
+                    ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC13);
+            }
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_EXTERNAL_URI_REFERENCE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_REQUIRE_EXTERNAL_URI);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_SC10_SECURITY_CONTEXT_TOKEN))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_SC10_SECURITY_CONTEXT_TOKEN);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_SC13_SECURITY_CONTEXT_TOKEN))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_SC13_SECURITY_CONTEXT_TOKEN);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_ISSUER))
+        {
+            neethi_assertion_t *assertion = NULL;
+            axis2_char_t *issuer = NULL;
+
+            issuer = axiom_element_get_text(element, env, node);
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, issuer, ASSERTION_TYPE_ISSUER);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_EXTERNAL_REFERENCE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_REQUIRE_EXTERNAL_REFERENCE);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_REQUIRE_INTERNAL_REFERENCE))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_REQUIRE_INTERNAL_REFERENCE);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_ISSUED_TOKEN))
+        {
+            return rp_issued_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_SAML_TOKEN))
+        {
+            return rp_saml_token_builder_build(env, node, element);
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_SAML_V10_TOKEN_V10))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_SAML_V10_TOKEN_V10);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_SAML_V10_TOKEN_V11))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_SAML_V10_TOKEN_V11);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_SAML_V11_TOKEN_V10))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_SAML_V11_TOKEN_V10);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_SAML_V11_TOKEN_V11))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_SAML_V11_TOKEN_V11);
+            return assertion;
+        }
+        else if(!axutil_strcmp(localname, RP_WSS_SAML_V20_TOKEN_V11))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL, ASSERTION_TYPE_WSS_SAML_V20_TOKEN_V11);
+            return assertion;
+        }
+    }
+    else if(!axutil_strcmp(ns, RP_RAMPART_NS))
+    {
+        /* if namespace is Rampart Namespace */
+        if(!axutil_strcmp(localname, RP_RAMPART_CONFIG))
+        {
+            return rp_rampart_config_builder_build(env, node, element);
+        }
+    }
+    else if(!axutil_strcmp(ns, AXIS2_MTOM_POLICY_NS))
+    {
+        if(!axutil_strcmp(localname, AXIS2_OPTIMIZED_MIME_SERIALIZATION))
+        {
+            neethi_assertion_t *assertion = NULL;
+            assertion = neethi_assertion_create(env);
+            neethi_assertion_set_value(assertion, env, NULL,
+                ASSERTION_TYPE_OPTIMIZED_MIME_SERIALIZATION);
+            return assertion;
+        }
+    }
+    else if((!axutil_strcmp(ns, AXIS2_RM_POLICY_10_NS)) || (!axutil_strcmp(ns,
+        AXIS2_RM_POLICY_11_NS)))
+    {
+        if(!axutil_strcmp(localname, AXIS2_RM_RMASSERTION))
+        {
+            return axis2_rm_assertion_builder_build(env, node, element);
+        }
+    }
+
+    /* This assertion cannot be processed */
+    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_UNKNOWN_ASSERTION, AXIS2_FAILURE);
+    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Unknown Assertion %s with namespace %s",
+        localname, ns);
+    return NULL;
+}
diff --git a/neethi/src/engine.c b/neethi/src/engine.c
new file mode 100644
index 0000000..b925cea
--- /dev/null
+++ b/neethi/src/engine.c
@@ -0,0 +1,1390 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_engine.h>
+#include <neethi_assertion_builder.h>
+#include <axiom_attribute.h>
+
+/*Private functions*/
+
+static neethi_all_t *
+neethi_engine_get_operator_all(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element);
+
+static neethi_exactlyone_t *
+neethi_engine_get_operator_exactlyone(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element);
+
+static neethi_reference_t *
+neethi_engine_get_operator_reference(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element);
+
+static neethi_policy_t *
+neethi_engine_get_operator_neethi_policy(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element);
+
+static axis2_status_t
+neethi_engine_process_operation_element(
+    const axutil_env_t *env,
+    neethi_operator_t *neethi_operator,
+    axiom_node_t *node,
+    axiom_element_t *element);
+
+static axis2_status_t
+neethi_engine_add_policy_component(
+    const axutil_env_t *env,
+    neethi_operator_t *container_operator,
+    neethi_operator_t *component);
+
+static axis2_bool_t
+neethi_engine_operator_is_empty(
+    neethi_operator_t *operator,
+    const axutil_env_t *env);
+
+static neethi_exactlyone_t *
+neethi_engine_compute_resultant_component(
+    axutil_array_list_t *normalized_inner_components,
+    neethi_operator_type_t type,
+    const axutil_env_t *env);
+
+static axutil_array_list_t *
+neethi_engine_operator_get_components(
+    neethi_operator_t *operator,
+    const axutil_env_t *env);
+
+static neethi_exactlyone_t *
+neethi_engine_normalize_operator(
+    neethi_operator_t *operator,
+    neethi_registry_t *registry,
+    axis2_bool_t deep,
+    const axutil_env_t *env);
+
+static neethi_exactlyone_t *
+neethi_engine_get_cross_product(
+    neethi_exactlyone_t *exactlyone1,
+    neethi_exactlyone_t *exactlyone2,
+    const axutil_env_t *env);
+
+static void
+neethi_engine_clear_element_attributes(
+    axutil_hash_t *attr_hash,
+    const axutil_env_t *env);
+
+/*Implementations*/
+
+/*This is the function which is called from outside*/
+
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_engine_get_policy(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    /* This function will be called recursively */
+
+    return neethi_engine_get_operator_neethi_policy(env, node, element);
+}
+
+static neethi_all_t *
+neethi_engine_get_operator_all(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    neethi_all_t *all = NULL;
+    neethi_operator_t *neethi_operator = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+    all = neethi_all_create(env);
+
+    if(!all)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_operator = neethi_operator_create(env);
+    if(!neethi_operator)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_operator_set_value(neethi_operator, env, all, OPERATOR_TYPE_ALL);
+
+    status = neethi_engine_process_operation_element(env, neethi_operator, node, element);
+
+    neethi_operator_set_value_null(neethi_operator, env);
+    neethi_operator_free(neethi_operator, env);
+    neethi_operator = NULL;
+
+    if(status != AXIS2_SUCCESS)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_ALL_CREATION_FAILED, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] All creation failed");
+        neethi_all_free(all, env);
+        all = NULL;
+        return NULL;
+    }
+    return all;
+}
+
+static neethi_exactlyone_t *
+neethi_engine_get_operator_exactlyone(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_operator_t *neethi_operator = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+
+    exactlyone = neethi_exactlyone_create(env);
+
+    if(!exactlyone)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+
+        return NULL;
+    }
+    neethi_operator = neethi_operator_create(env);
+    if(!neethi_operator)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+
+        return NULL;
+    }
+    neethi_operator_set_value(neethi_operator, env, exactlyone, OPERATOR_TYPE_EXACTLYONE);
+    status = neethi_engine_process_operation_element(env, neethi_operator, node, element);
+
+    neethi_operator_set_value_null(neethi_operator, env);
+    neethi_operator_free(neethi_operator, env);
+    neethi_operator = NULL;
+
+    if(status != AXIS2_SUCCESS)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_EXACTLYONE_CREATION_FAILED, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Exactlyone creation failed.");
+        neethi_exactlyone_free(exactlyone, env);
+        exactlyone = NULL;
+        return NULL;
+    }
+
+    return exactlyone;
+}
+
+neethi_reference_t *
+neethi_engine_get_operator_reference(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    neethi_reference_t *reference = NULL;
+    axutil_qname_t *qname = NULL;
+    axis2_char_t *attribute_value = NULL;
+
+    reference = neethi_reference_create(env);
+
+    if(!reference)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+
+        return NULL;
+    }
+    qname = axutil_qname_create(env, NEETHI_URI, NULL, NULL);
+
+    if(!qname)
+    {
+        return NULL;
+    }
+
+    attribute_value = axiom_element_get_attribute_value(element, env, qname);
+    if(attribute_value)
+    {
+        neethi_reference_set_uri(reference, env, attribute_value);
+    }
+    return reference;
+}
+
+/* This function will be called when we encounter a wsp:Policy
+ * element */
+
+static neethi_policy_t *
+neethi_engine_get_operator_neethi_policy(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_operator_t *neethi_operator = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+
+    /* Creates a policy struct */
+
+    neethi_policy = neethi_policy_create(env);
+
+    if(!neethi_policy)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+
+    /* Then we wrap it in a neethi_operator */
+
+    neethi_operator = neethi_operator_create(env);
+    if(!neethi_operator)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_operator_set_value(neethi_operator, env, neethi_policy, OPERATOR_TYPE_POLICY);
+
+    /* This function will do all the processing and build the 
+     * policy object model */
+
+    status = neethi_engine_process_operation_element(env, neethi_operator, node, element);
+
+    /* To prevent freeing the policy object from the operator
+     * we set it to null. This object will be freed from a parent 
+     * or from an outsider who creates a policy object */
+
+    neethi_operator_set_value_null(neethi_operator, env);
+    neethi_operator_free(neethi_operator, env);
+    neethi_operator = NULL;
+
+    if(status != AXIS2_SUCCESS)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_POLICY_CREATION_FAILED, AXIS2_FAILURE);
+
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Policy creation failed.");
+        neethi_policy_free(neethi_policy, env);
+        neethi_policy = NULL;
+        return NULL;
+    }
+    return neethi_policy;
+}
+
+/* This function will construct the policy objecy model by 
+ * filling the component array_list inside the passing 
+ * policy operator */
+
+static axis2_status_t
+neethi_engine_process_operation_element(
+    const axutil_env_t *env,
+    neethi_operator_t *neethi_operator,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+
+    neethi_operator_type_t type;
+    axiom_element_t *child_element = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_children_iterator_t *children_iter = NULL;
+    void *value = NULL;
+
+    type = neethi_operator_get_type(neethi_operator, env);
+    value = neethi_operator_get_value(neethi_operator, env);
+
+    if(type == OPERATOR_TYPE_POLICY)
+    {
+        /* wsp:Policy element can have any number of attributes
+         * we will store them in a hash from the uri and localname */
+
+        axutil_hash_t *attributes = axiom_element_extract_attributes(element, env, node);
+
+        if(attributes)
+        {
+            axutil_hash_index_t *hi = NULL;
+
+            /* When creating the policy object we created the hash */
+
+            axutil_hash_t *ht = neethi_policy_get_attributes((neethi_policy_t *)value, env);
+
+            if(!ht)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Policy hash map creation failed.");
+                return AXIS2_FAILURE;
+            }
+
+            for(hi = axutil_hash_first(attributes, env); hi; hi = axutil_hash_next(env, hi))
+            {
+                axis2_char_t *key = NULL;
+                void *val = NULL;
+                axutil_qname_t *qname = NULL;
+                axis2_char_t *attr_val = NULL;
+                axiom_namespace_t *ns = NULL;
+                axis2_char_t *ns_uri = NULL;
+                axiom_attribute_t *om_attr = NULL;
+
+                axutil_hash_this(hi, NULL, NULL, &val);
+                if(val)
+                {
+                    om_attr = (axiom_attribute_t *)val;
+                    ns = axiom_attribute_get_namespace(om_attr, env);
+                    if(ns)
+                    {
+                        ns_uri = axiom_namespace_get_uri(ns, env);
+                    }
+
+                    qname = axutil_qname_create(env, axiom_attribute_get_localname(om_attr, env),
+                        ns_uri, NULL);
+                    if(qname)
+                    {
+                        key = axutil_qname_to_string(qname, env);
+                        if(key)
+                        {
+                            attr_val = axiom_attribute_get_value(om_attr, env);
+                            if(attr_val)
+                            {
+                                /* axutil_qname_free will free the returned key 
+                                 * of the qname so will duplicate it when storing */
+
+                                axutil_hash_set(ht, axutil_strdup(env, key), AXIS2_HASH_KEY_STRING,
+                                    axutil_strdup(env, attr_val));
+                            }
+                        }
+                        axutil_qname_free(qname, env);
+                    }
+                }
+            }
+            /* axiom_element_extract_attributes method will always returns 
+             * a cloned copy, so we need to free it after we have done with it */
+
+            neethi_engine_clear_element_attributes(attributes, env);
+            attributes = NULL;
+        }
+    }
+
+    children_iter = axiom_element_get_children(element, env, node);
+    if(children_iter)
+    {
+        while(axiom_children_iterator_has_next(children_iter, env))
+        {
+            /* Extract the element and check the namespace. If the namespace 
+             * is in ws_policy then we call the relevent operator builder 
+             * otherwise we will call the assertion_builder */
+
+            child_node = axiom_children_iterator_next(children_iter, env);
+            if(child_node)
+            {
+                if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+                {
+                    child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+                    if(child_element)
+                    {
+                        axiom_namespace_t *namespace = NULL;
+                        axis2_char_t *uri = NULL;
+                        axis2_char_t *local_name = NULL;
+                        neethi_operator_t *operator = NULL;
+                        local_name = axiom_element_get_localname(child_element, env);
+
+                        namespace = axiom_element_get_namespace(child_element, env, child_node);
+                        if(!namespace)
+                        {
+                            AXIS2_ERROR_SET(env->error,
+                                AXIS2_ERROR_NEETHI_ELEMENT_WITH_NO_NAMESPACE, AXIS2_FAILURE);
+                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                "[neethi] Element with no namespace");
+                            return AXIS2_FAILURE;
+                        }
+                        uri = axiom_namespace_get_uri(namespace, env);
+                        if(!uri)
+                        {
+                            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_EMPTY_NAMESPACE_URI,
+                                AXIS2_FAILURE);
+                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                "[neethi] Invalid Empty namespace uri.");
+                            return AXIS2_FAILURE;
+                        }
+                        if((axutil_strcmp(uri, NEETHI_NAMESPACE) == 0) || (axutil_strcmp(uri,
+                            NEETHI_POLICY_15_NAMESPACE) == 0))
+                        {
+                            /* Looking at the localname we will call the relevent 
+                             * operator function. After that the newly created 
+                             * object is wrapped in a neethi_operator and stored in 
+                             * the parent's component list */
+
+                            if(axutil_strcmp(local_name, NEETHI_POLICY) == 0)
+                            {
+                                neethi_policy_t *neethi_policy = NULL;
+                                neethi_policy = neethi_engine_get_operator_neethi_policy(env,
+                                    child_node, child_element);
+                                if(neethi_policy)
+                                {
+                                    operator = neethi_operator_create(env);
+                                    neethi_operator_set_value(operator, env, neethi_policy,
+                                        OPERATOR_TYPE_POLICY);
+                                    neethi_engine_add_policy_component(env, neethi_operator,
+                                        operator);
+                                }
+                                else
+                                {
+                                    AXIS2_ERROR_SET(env->error,
+                                        AXIS2_ERROR_NEETHI_POLICY_CREATION_FAILED_FROM_ELEMENT,
+                                        AXIS2_FAILURE);
+                                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                        "[neethi] Policy creation failed from element.");
+                                    return AXIS2_FAILURE;
+                                }
+                            }
+                            else if(axutil_strcmp(local_name, NEETHI_ALL) == 0)
+                            {
+                                neethi_all_t *all = NULL;
+                                all
+                                    = neethi_engine_get_operator_all(env, child_node, child_element);
+                                if(all)
+                                {
+                                    operator = neethi_operator_create(env);
+                                    neethi_operator_set_value(operator, env, all, OPERATOR_TYPE_ALL);
+                                    neethi_engine_add_policy_component(env, neethi_operator,
+                                        operator);
+                                }
+                                else
+                                {
+                                    AXIS2_ERROR_SET(env->error,
+                                        AXIS2_ERROR_NEETHI_ALL_CREATION_FAILED_FROM_ELEMENT,
+                                        AXIS2_FAILURE);
+                                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                        "[neethi] All creation failed from element.");
+                                    return AXIS2_FAILURE;
+                                }
+                            }
+                            else if(axutil_strcmp(local_name, NEETHI_EXACTLYONE) == 0)
+                            {
+                                neethi_exactlyone_t *exactlyone = NULL;
+                                exactlyone = neethi_engine_get_operator_exactlyone(env, child_node,
+                                    child_element);
+                                if(exactlyone)
+                                {
+                                    operator = neethi_operator_create(env);
+                                    neethi_operator_set_value(operator, env, exactlyone,
+                                        OPERATOR_TYPE_EXACTLYONE);
+                                    neethi_engine_add_policy_component(env, neethi_operator,
+                                        operator);
+                                }
+                                else
+                                {
+                                    AXIS2_ERROR_SET(env->error,
+                                        AXIS2_ERROR_NEETHI_EXACTLYONE_CREATION_FAILED_FROM_ELEMENT,
+                                        AXIS2_FAILURE);
+                                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                        "[neethi] Exactlyone creation failed from element.");
+                                    return AXIS2_FAILURE;
+                                }
+                            }
+                            else if(axutil_strcmp(local_name, NEETHI_REFERENCE) == 0)
+                            {
+                                neethi_reference_t *reference = NULL;
+                                reference = neethi_engine_get_operator_reference(env, child_node,
+                                    child_element);
+                                if(reference)
+                                {
+                                    operator = neethi_operator_create(env);
+                                    neethi_operator_set_value(operator, env, reference,
+                                        OPERATOR_TYPE_REFERENCE);
+                                    neethi_engine_add_policy_component(env, neethi_operator,
+                                        operator);
+                                }
+                                else
+                                {
+                                    AXIS2_ERROR_SET(env->error,
+                                        AXIS2_ERROR_NEETHI_REFERENCE_CREATION_FAILED_FROM_ELEMENT,
+                                        AXIS2_FAILURE);
+                                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                        "[neethi] Reference cretion failed from element.");
+                                    return AXIS2_FAILURE;
+                                }
+                            }
+                        }
+
+                        else
+                        {
+                            /* This is an assertion in a different domain. Assertion builder
+                             * should be called and that will call the relevent assertion builder 
+                             * after looking at the localname and the namespace */
+
+                            neethi_assertion_t *assertion = NULL;
+                            assertion = neethi_assertion_builder_build(env, child_node,
+                                child_element);
+                            if(assertion)
+                            {
+                                operator = neethi_operator_create(env);
+                                neethi_operator_set_value(operator, env, assertion,
+                                    OPERATOR_TYPE_ASSERTION);
+                                neethi_engine_add_policy_component(env, neethi_operator, operator);
+                                neethi_assertion_set_node(assertion, env, child_node);
+                            }
+                            else
+                            {
+                                AXIS2_ERROR_SET(env->error,
+                                    AXIS2_ERROR_NEETHI_ASSERTION_CREATION_FAILED_FROM_ELEMENT,
+                                    AXIS2_FAILURE);
+                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                    "[neethi] Assertion creation failed from element.");
+                                return AXIS2_FAILURE;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return AXIS2_SUCCESS;
+    }
+    else
+        return AXIS2_FAILURE;
+}
+
+/* After looking at the operator_type this function will 
+ * call the relevent neethi operator's add operator 
+ * function */
+
+static axis2_status_t
+neethi_engine_add_policy_component(
+    const axutil_env_t *env,
+    neethi_operator_t *container_operator,
+    neethi_operator_t *component)
+{
+
+    neethi_operator_type_t type;
+    void *value = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    type = neethi_operator_get_type(container_operator, env);
+    value = neethi_operator_get_value(container_operator, env);
+
+    if(value)
+    {
+        switch(type)
+        {
+            case OPERATOR_TYPE_POLICY:
+                neethi_policy = (neethi_policy_t *)value;
+                neethi_policy_add_operator(neethi_policy, env, component);
+                break;
+
+            case OPERATOR_TYPE_ALL:
+                all = (neethi_all_t *)value;
+                neethi_all_add_operator(all, env, component);
+                break;
+
+            case OPERATOR_TYPE_EXACTLYONE:
+                exactlyone = (neethi_exactlyone_t *)value;
+                neethi_exactlyone_add_operator(exactlyone, env, component);
+                break;
+
+            case OPERATOR_TYPE_UNKNOWN:
+                return AXIS2_FAILURE;
+                break;
+
+            case OPERATOR_TYPE_ASSERTION:
+                assertion = (neethi_assertion_t *)value;
+                neethi_assertion_add_operator(assertion, env, component);
+                break;
+
+            case OPERATOR_TYPE_REFERENCE:
+                break;
+        }
+        return AXIS2_SUCCESS;
+    }
+    else
+        return AXIS2_FAILURE;
+}
+
+/***************************************/
+
+/*This function is only for testing*
+ *Remove it later*/
+void
+check_neethi_policy(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    axutil_array_list_t *list = NULL;
+    neethi_operator_t *op = NULL;
+    neethi_operator_type_t type;
+
+    list = neethi_policy_get_policy_components(neethi_policy, env);
+
+    if(axutil_array_list_size(list, env) > 1)
+    {
+        return;
+    }
+    op = (neethi_operator_t *)axutil_array_list_get(list, env, 0);
+    type = neethi_operator_get_type(op, env);
+    if(type == OPERATOR_TYPE_EXACTLYONE)
+    {
+        void *value = neethi_operator_get_value(op, env);
+        if(value)
+        {
+            return;
+        }
+    }
+    else
+    {
+        return;
+    }
+}
+
+/************************************************/
+/*
+
+ Following function will normalize accorading to the
+ WS-Policy spec. Normalize policy is in the following
+ format.
+
+ <wsp:Policy>
+ <wsp:ExactlyOne>
+ ( <wsp:All> ( <Assertion …> … </Assertion> )* </wsp:All> )*
+ </wsp:ExactlyOne>
+ </wsp:Policy>
+
+ */
+
+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)
+{
+    /* In the first call we pass the registry as null.*/
+
+    return neethi_engine_normalize(env, neethi_policy, NULL, deep);
+}
+
+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)
+{
+    neethi_policy_t *resultant_neethi_policy = NULL;
+    neethi_operator_t *operator = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    axis2_char_t *policy_name = NULL;
+    axis2_char_t *policy_id = NULL;
+
+    /* Normalize policy will be contained in the new policy
+     * created below */
+
+    resultant_neethi_policy = neethi_policy_create(env);
+    if(!resultant_neethi_policy)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+
+    policy_name = neethi_policy_get_name(neethi_policy, env);
+    if(policy_name)
+    {
+        neethi_policy_set_name(resultant_neethi_policy, env, policy_name);
+    }
+    policy_id = neethi_policy_get_id(neethi_policy, env);
+    if(policy_id)
+    {
+        neethi_policy_set_id(resultant_neethi_policy, env, policy_id);
+    }
+
+    operator = neethi_operator_create(env);
+    if(!operator)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+
+    neethi_operator_set_value(operator, env, neethi_policy, OPERATOR_TYPE_POLICY);
+
+    /* When we call the normalization it should always return an exactlyone as the 
+     * out put. */
+
+    exactlyone = neethi_engine_normalize_operator(operator, registry, deep, env);
+
+    /* We are frreing the operator used to wrap the object */
+
+    neethi_operator_set_value_null(operator, env);
+    neethi_operator_free(operator, env);
+    operator = NULL;
+
+    /* This exactlyone is set as the first component of the 
+     * normalized policy */
+
+    if(exactlyone)
+    {
+        component = neethi_operator_create(env);
+        neethi_operator_set_value(component, env, exactlyone, OPERATOR_TYPE_EXACTLYONE);
+        neethi_policy_add_operator(resultant_neethi_policy, env, component);
+
+        return resultant_neethi_policy;
+    }
+    else
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_NORMALIZATION_FAILED, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Normalization failed.");
+        return NULL;
+    }
+}
+
+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)
+{
+
+    neethi_exactlyone_t *exactlyone1 = NULL;
+    neethi_exactlyone_t *exactlyone2 = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_operator_t *component = NULL;
+
+    exactlyone1 = neethi_policy_get_exactlyone(neethi_policy1, env);
+    exactlyone2 = neethi_policy_get_exactlyone(neethi_policy2, env);
+
+    if(!exactlyone1 || !exactlyone2)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_WRONG_INPUT_FOR_MERGE, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Wrong input for merge.");
+        return NULL;
+    }
+    exactlyone = neethi_engine_get_cross_product(exactlyone1, exactlyone2, env);
+    if(exactlyone)
+    {
+        neethi_policy = neethi_policy_create(env);
+        component = neethi_operator_create(env);
+        if(!neethi_policy || !component)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+            return NULL;
+        }
+        neethi_operator_set_value(component, env, exactlyone, OPERATOR_TYPE_EXACTLYONE);
+        neethi_policy_add_operator(neethi_policy, env, component);
+        return neethi_policy;
+    }
+    else
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_CROSS_PRODUCT_FAILED, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cross product failed.");
+        return NULL;
+    }
+}
+
+static axis2_bool_t
+neethi_engine_operator_is_empty(
+    neethi_operator_t *operator,
+    const axutil_env_t *env)
+{
+
+    neethi_operator_type_t type;
+    void *value = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    type = neethi_operator_get_type(operator, env);
+    value = neethi_operator_get_value(operator, env);
+
+    if(value)
+    {
+        switch(type)
+        {
+            case OPERATOR_TYPE_POLICY:
+                neethi_policy = (neethi_policy_t *)value;
+                return neethi_policy_is_empty(neethi_policy, env);
+                break;
+
+            case OPERATOR_TYPE_ALL:
+                all = (neethi_all_t *)value;
+                return neethi_all_is_empty(all, env);
+                break;
+
+            case OPERATOR_TYPE_EXACTLYONE:
+                exactlyone = (neethi_exactlyone_t *)value;
+                return neethi_exactlyone_is_empty(exactlyone, env);
+                break;
+
+            case OPERATOR_TYPE_UNKNOWN:
+                return AXIS2_FALSE;
+                break;
+
+            case OPERATOR_TYPE_ASSERTION:
+                assertion = (neethi_assertion_t *)value;
+                return neethi_assertion_is_empty(assertion, env);
+                break;
+
+            case OPERATOR_TYPE_REFERENCE:
+                break;
+
+        }
+        return AXIS2_FALSE;
+    }
+    else
+        return AXIS2_FALSE;
+}
+
+static axutil_array_list_t *
+neethi_engine_operator_get_components(
+    neethi_operator_t *operator,
+    const axutil_env_t *env)
+{
+
+    neethi_operator_type_t type;
+    void *value = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    type = neethi_operator_get_type(operator, env);
+    value = neethi_operator_get_value(operator, env);
+
+    if(value)
+    {
+        switch(type)
+        {
+            case OPERATOR_TYPE_POLICY:
+                neethi_policy = (neethi_policy_t *)value;
+                return neethi_policy_get_policy_components(neethi_policy, env);
+                break;
+
+            case OPERATOR_TYPE_ALL:
+                all = (neethi_all_t *)value;
+                return neethi_all_get_policy_components(all, env);
+                break;
+
+            case OPERATOR_TYPE_EXACTLYONE:
+                exactlyone = (neethi_exactlyone_t *)value;
+                return neethi_exactlyone_get_policy_components(exactlyone, env);
+                break;
+
+            case OPERATOR_TYPE_UNKNOWN:
+                return NULL;
+                break;
+
+            case OPERATOR_TYPE_ASSERTION:
+                assertion = (neethi_assertion_t *)value;
+                return neethi_assertion_get_policy_components(assertion, env);
+                break;
+
+            case OPERATOR_TYPE_REFERENCE:
+                break;
+        }
+    }
+
+    return NULL;
+}
+
+static neethi_exactlyone_t *
+neethi_engine_normalize_operator(
+    neethi_operator_t *operator,
+    neethi_registry_t *registry,
+    axis2_bool_t deep,
+    const axutil_env_t *env)
+{
+    axutil_array_list_t *child_component_list = NULL;
+    neethi_operator_t *child_component = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    int i = 0;
+
+    neethi_operator_type_t type = neethi_operator_get_type(operator, env);
+
+    if(neethi_engine_operator_is_empty(operator, env))
+    {
+        /* If this is an empty operator we just add 
+         * an exactlyone and all */
+
+        neethi_exactlyone_t *exactlyone = NULL;
+        exactlyone = neethi_exactlyone_create(env);
+        if(!exactlyone)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+            return NULL;
+        }
+        if(type != OPERATOR_TYPE_EXACTLYONE)
+        {
+            neethi_all_t *all = NULL;
+            neethi_operator_t *component = NULL;
+            all = neethi_all_create(env);
+            component = neethi_operator_create(env);
+            if(!all || !component)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                return NULL;
+            }
+            neethi_operator_set_value(component, env, all, OPERATOR_TYPE_ALL);
+            neethi_exactlyone_add_operator(exactlyone, env, component);
+        }
+        return exactlyone;
+    }
+
+    child_component_list = axutil_array_list_create(env, 0);
+    arraylist = neethi_engine_operator_get_components(operator, env);
+
+    /* Here we are recursively normalize each and every component */
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        neethi_operator_type_t component_type;
+        child_component = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        component_type = neethi_operator_get_type(child_component, env);
+
+        if(component_type == OPERATOR_TYPE_ASSERTION)
+        {
+            /*Assertion normalization part comes here */
+            if(deep)
+            {
+                return NULL;
+            }
+            else
+            {
+                neethi_exactlyone_t *exactlyone = NULL;
+                neethi_all_t *all = NULL;
+                neethi_operator_t *op = NULL;
+
+                exactlyone = neethi_exactlyone_create(env);
+                all = neethi_all_create(env);
+                op = neethi_operator_create(env);
+
+                if(!all || !op || !exactlyone)
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                    return NULL;
+                }
+
+                /* We wrap everything inside an exactlyone */
+
+                neethi_all_add_operator(all, env, child_component);
+                neethi_operator_set_value(op, env, all, OPERATOR_TYPE_ALL);
+                neethi_exactlyone_add_operator(exactlyone, env, op);
+                axutil_array_list_add(child_component_list, env, exactlyone);
+            }
+        }
+        else if(component_type == OPERATOR_TYPE_POLICY)
+        {
+            neethi_policy_t *neethi_policy = NULL;
+            neethi_all_t *all = NULL;
+            axutil_array_list_t *children = NULL;
+            neethi_operator_t *to_normalize = NULL;
+            neethi_exactlyone_t *exactlyone = NULL;
+
+            all = neethi_all_create(env);
+            if(!all)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                return NULL;
+            }
+            neethi_policy = (neethi_policy_t *)neethi_operator_get_value(child_component, env);
+            if(neethi_policy)
+            {
+                children = neethi_policy_get_policy_components(neethi_policy, env);
+                if(children)
+                {
+                    neethi_all_add_policy_components(all, children, env);
+                    to_normalize = neethi_operator_create(env);
+                    if(!to_normalize)
+                    {
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                        return NULL;
+                    }
+                    neethi_operator_set_value(to_normalize, env, all, OPERATOR_TYPE_ALL);
+                    exactlyone
+                        = neethi_engine_normalize_operator(to_normalize, registry, deep, env);
+                    if(exactlyone)
+                    {
+                        axutil_array_list_add(child_component_list, env, exactlyone);
+                    }
+                }
+                else
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_NO_CHILDREN_POLICY_COMPONENTS,
+                        AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "[neethi] No children policy components");
+                    return NULL;
+                }
+            }
+        }
+
+        else if(component_type == OPERATOR_TYPE_REFERENCE)
+        {
+
+            /* If the operator is a policy reference we will 
+             * extract the relevent policy from the uri and 
+             * normalize as we are doing for a neethi_policy 
+             * object */
+
+            neethi_reference_t *policy_ref = NULL;
+            axis2_char_t *uri = NULL;
+            neethi_policy_t *policy = NULL;
+            neethi_all_t *all = NULL;
+            axutil_array_list_t *children = NULL;
+            neethi_operator_t *to_normalize = NULL;
+            neethi_exactlyone_t *exactlyone = NULL;
+
+            policy_ref = (neethi_reference_t *)neethi_operator_get_value(child_component, env);
+            uri = neethi_reference_get_uri(policy_ref, env);
+            if(!uri)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_URI_NOT_SPECIFIED, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Uri not specified");
+                return NULL;
+            }
+
+            if(!registry)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "[neethi] Cannot resolve the reference.Registry Not provided");
+                return NULL;
+            }
+
+            policy = neethi_registry_lookup(registry, env, uri);
+            if(!policy)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_NO_ENTRY_FOR_THE_GIVEN_URI,
+                    AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] No entry for the given uri");
+                return NULL;
+            }
+            neethi_operator_set_value(child_component, env, policy, OPERATOR_TYPE_POLICY);
+
+            all = neethi_all_create(env);
+            if(!all)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                return NULL;
+            }
+
+            policy = (neethi_policy_t *)neethi_operator_get_value(child_component, env);
+            if(policy)
+            {
+                children = neethi_policy_get_policy_components(policy, env);
+                if(children)
+                {
+                    neethi_all_add_policy_components(all, children, env);
+                    to_normalize = neethi_operator_create(env);
+                    if(!to_normalize)
+                    {
+                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                        return NULL;
+                    }
+                    neethi_operator_set_value(to_normalize, env, all, OPERATOR_TYPE_ALL);
+                    exactlyone
+                        = neethi_engine_normalize_operator(to_normalize, registry, deep, env);
+                    if(exactlyone)
+                    {
+                        axutil_array_list_add(child_component_list, env, exactlyone);
+                    }
+                }
+                else
+                {
+                    AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_NO_CHILDREN_POLICY_COMPONENTS,
+                        AXIS2_FAILURE);
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "[neethi] No children policy components");
+                    return NULL;
+                }
+            }
+        }
+        else
+        {
+            neethi_exactlyone_t *exactlyone = NULL;
+            exactlyone = neethi_engine_normalize_operator(child_component, registry, deep, env);
+            if(exactlyone)
+            {
+                axutil_array_list_add(child_component_list, env, exactlyone);
+            }
+        }
+    }
+
+    /* So at this point we have set of exactlyones in the array_list, So we will 
+     * compute one exactlyone out of those after the following call */
+
+    return neethi_engine_compute_resultant_component(child_component_list, type, env);
+}
+
+/* This function will return a single exactlyone from all the 
+ * components in the list */
+
+static neethi_exactlyone_t *
+neethi_engine_compute_resultant_component(
+    axutil_array_list_t * normalized_inner_components,
+    neethi_operator_type_t type,
+    const axutil_env_t * env)
+{
+    neethi_exactlyone_t *exactlyone = NULL;
+    int size = 0;
+
+    if(normalized_inner_components)
+    {
+        size = axutil_array_list_size(normalized_inner_components, env);
+    }
+
+    if(type == OPERATOR_TYPE_EXACTLYONE)
+    {
+        /* If the operator is an exactlyone then we get all the components
+         * in the exatlyones and add them to a newly created exactlyone */
+
+        int i = 0;
+        neethi_exactlyone_t *inner_exactlyone = NULL;
+        exactlyone = neethi_exactlyone_create(env);
+
+        for(i = 0; i < size; i++)
+        {
+            inner_exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(
+                normalized_inner_components, env, i);
+            if(inner_exactlyone)
+            {
+                neethi_exactlyone_add_policy_components(exactlyone,
+                    neethi_exactlyone_get_policy_components(inner_exactlyone, env), env);
+            }
+            else
+            {
+                AXIS2_ERROR_SET(env->error,
+                    AXIS2_ERROR_NEETHI_EXACTLYONE_NOT_FOUND_IN_NORMALIZED_POLICY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "[neethi] Exactlyone not found in normalized policy");
+                return NULL;
+            }
+        }
+    }
+    else if(type == OPERATOR_TYPE_POLICY || type == OPERATOR_TYPE_ALL)
+    {
+        /* Here arry_list contains one exactlyone means this operator 
+         * is already normalized. So we will return that. Otherwise we 
+         * will get the crossproduct. */
+
+        if(size > 1)
+        {
+            /* Get the first one and do the cross product with other 
+             * components */
+
+            int i = 0;
+            exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(normalized_inner_components,
+                env, 0);
+            if(!exactlyone)
+            {
+                AXIS2_ERROR_SET(env->error,
+                    AXIS2_ERROR_NEETHI_EXACTLYONE_NOT_FOUND_IN_NORMALIZED_POLICY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "[neethi] Exactlyone not found in normalized policy");
+                return NULL;
+            }
+            if(!neethi_exactlyone_is_empty(exactlyone, env))
+            {
+                neethi_exactlyone_t *current_exactlyone = NULL;
+                i = 1;
+                for(i = 1; i < size; i++)
+                {
+                    current_exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(
+                        normalized_inner_components, env, i);
+                    if(!current_exactlyone)
+                    {
+                        AXIS2_ERROR_SET(env->error,
+                            AXIS2_ERROR_NEETHI_EXACTLYONE_NOT_FOUND_IN_NORMALIZED_POLICY,
+                            AXIS2_FAILURE);
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "[neethi] Exactlyone not found in normalized policy");
+                        return NULL;
+                    }
+                    if(neethi_exactlyone_is_empty(current_exactlyone, env))
+                    {
+                        exactlyone = current_exactlyone;
+                        break;
+                    }
+                    else
+                    {
+                        neethi_exactlyone_t *temp = NULL;
+                        neethi_exactlyone_t *temp1 = NULL;
+                        temp = exactlyone;
+                        temp1 = current_exactlyone;
+                        exactlyone = neethi_engine_get_cross_product(exactlyone,
+                            current_exactlyone, env);
+                        neethi_exactlyone_free(temp, env);
+                        neethi_exactlyone_free(temp1, env);
+                        temp = NULL;
+                        temp1 = NULL;
+                    }
+                }
+            }
+            else
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_EXACTLYONE_IS_EMPTY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Exactlyone is Empty");
+                return NULL;
+            }
+        }
+        else
+        {
+            exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(normalized_inner_components,
+                env, 0);
+        }
+    }
+    axutil_array_list_free(normalized_inner_components, env);
+    normalized_inner_components = NULL;
+
+    return exactlyone;
+}
+
+/* The cross product will return all the different combinations 
+ * of alternatives and put them into one exactlyone */
+
+static neethi_exactlyone_t *
+neethi_engine_get_cross_product(
+    neethi_exactlyone_t *exactlyone1,
+    neethi_exactlyone_t *exactlyone2,
+    const axutil_env_t *env)
+{
+    neethi_exactlyone_t *cross_product = NULL;
+    neethi_all_t *cross_product_all = NULL;
+    neethi_all_t *current_all1 = NULL;
+    neethi_all_t *current_all2 = NULL;
+    axutil_array_list_t *array_list1 = NULL;
+    axutil_array_list_t *array_list2 = NULL;
+    neethi_operator_t *component = NULL;
+    int i = 0;
+    int j = 0;
+
+    cross_product = neethi_exactlyone_create(env);
+    if(!cross_product)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    array_list1 = neethi_exactlyone_get_policy_components(exactlyone1, env);
+    array_list2 = neethi_exactlyone_get_policy_components(exactlyone2, env);
+
+    if(!array_list1 || !array_list2)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NEETHI_NO_CHILDREN_POLICY_COMPONENTS, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] No children policy components");
+        return NULL;
+    }
+
+    for(i = 0; i < axutil_array_list_size(array_list1, env); i++)
+    {
+        current_all1 = (neethi_all_t *)neethi_operator_get_value(
+            (neethi_operator_t *)axutil_array_list_get(array_list1, env, i), env);
+
+        if(!current_all1)
+        {
+            AXIS2_ERROR_SET(env->error,
+                AXIS2_ERROR_NEETHI_ALL_NOT_FOUND_WHILE_GETTING_CROSS_PRODUCT, AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                "[neethi] All not found while getting cross product");
+            return NULL;
+        }
+
+        for(j = 0; j < axutil_array_list_size(array_list2, env); j++)
+        {
+            current_all2 = (neethi_all_t *)neethi_operator_get_value(
+                (neethi_operator_t *)axutil_array_list_get(array_list2, env, j), env);
+
+            if(!current_all2)
+            {
+                AXIS2_ERROR_SET(env->error,
+                    AXIS2_ERROR_NEETHI_ALL_NOT_FOUND_WHILE_GETTING_CROSS_PRODUCT, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "[neethi] All not found while getting cross product");
+                return NULL;
+            }
+
+            cross_product_all = neethi_all_create(env);
+            if(!cross_product_all)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                return NULL;
+            }
+            neethi_all_add_policy_components(cross_product_all, neethi_all_get_policy_components(
+                current_all1, env), env);
+
+            neethi_all_add_policy_components(cross_product_all, neethi_all_get_policy_components(
+                current_all2, env), env);
+
+            component = neethi_operator_create(env);
+            if(!component)
+            {
+                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+                return NULL;
+            }
+            neethi_operator_set_value(component, env, cross_product_all, OPERATOR_TYPE_ALL);
+            neethi_exactlyone_add_operator(cross_product, env, component);
+        }
+    }
+    return cross_product;
+}
+
+/*These functions are for serializing a policy object*/
+
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+neethi_engine_serialize(
+    neethi_policy_t *policy,
+    const axutil_env_t *env)
+{
+
+    return neethi_policy_serialize(policy, NULL, env);
+}
+
+static void
+neethi_engine_clear_element_attributes(
+    axutil_hash_t *attr_hash,
+    const axutil_env_t *env)
+{
+    axutil_hash_index_t *hi = NULL;
+
+    for(hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
+    {
+        void *val = NULL;
+        axutil_hash_this(hi, NULL, NULL, &val);
+        if(val)
+        {
+            axiom_attribute_free((axiom_attribute_t *)val, env);
+            val = NULL;
+        }
+    }
+    axutil_hash_free(attr_hash, env);
+    attr_hash = NULL;
+
+    return;
+}
diff --git a/neethi/src/exactlyone.c b/neethi/src/exactlyone.c
new file mode 100644
index 0000000..ad94fa2
--- /dev/null
+++ b/neethi/src/exactlyone.c
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_exactlyone.h>
+
+struct neethi_exactlyone_t
+{
+    axutil_array_list_t *policy_components;
+};
+
+AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL
+neethi_exactlyone_create(
+    const axutil_env_t *env)
+{
+    neethi_exactlyone_t *neethi_exactlyone = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    neethi_exactlyone = (neethi_exactlyone_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(neethi_exactlyone_t));
+
+    if(neethi_exactlyone == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_exactlyone->policy_components = NULL;
+
+    neethi_exactlyone->policy_components = axutil_array_list_create(env, 0);
+    if(!(neethi_exactlyone->policy_components))
+    {
+        neethi_exactlyone_free(neethi_exactlyone, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    return neethi_exactlyone;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+neethi_exactlyone_free(
+    neethi_exactlyone_t *neethi_exactlyone,
+    const axutil_env_t *env)
+{
+    if(neethi_exactlyone)
+    {
+        if(neethi_exactlyone->policy_components)
+        {
+            int i = 0;
+            int size = 0;
+
+            size = axutil_array_list_size(neethi_exactlyone->policy_components, env);
+
+            for(i = 0; i < size; i++)
+            {
+                neethi_operator_t *operator = NULL;
+                operator = (neethi_operator_t *)axutil_array_list_get(
+                    neethi_exactlyone->policy_components, env, i);
+                if(operator)
+                {
+                    neethi_operator_free(operator, env);
+                    operator = NULL;
+                }
+            }
+            axutil_array_list_free(neethi_exactlyone->policy_components, env);
+            neethi_exactlyone->policy_components = NULL;
+        }
+        AXIS2_FREE(env->allocator, neethi_exactlyone);
+        neethi_exactlyone = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+neethi_exactlyone_get_policy_components(
+    neethi_exactlyone_t *neethi_exactlyone,
+    const axutil_env_t *env)
+{
+    return neethi_exactlyone->policy_components;
+}
+
+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)
+{
+
+    int size = axutil_array_list_size(arraylist, env);
+    int i = 0;
+
+    if(axutil_array_list_ensure_capacity(exactlyone->policy_components, env, size + 1)
+        != AXIS2_SUCCESS)
+    {
+        return AXIS2_FAILURE;
+    }
+
+    for(i = 0; i < size; i++)
+    {
+        void *value = NULL;
+        value = axutil_array_list_get(arraylist, env, i);
+        neethi_operator_increment_ref((neethi_operator_t *)value, env);
+        axutil_array_list_add(exactlyone->policy_components, env, value);
+    }
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_exactlyone_add_operator(
+    neethi_exactlyone_t *neethi_exactlyone,
+    const axutil_env_t *env,
+    neethi_operator_t *operator)
+{
+    neethi_operator_increment_ref(operator, env);
+    axutil_array_list_add(neethi_exactlyone->policy_components, env, operator);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+neethi_exactlyone_is_empty(
+    neethi_exactlyone_t *exactlyone,
+    const axutil_env_t *env)
+{
+    return axutil_array_list_is_empty(exactlyone->policy_components, 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)
+{
+    axiom_node_t *exactlyone_node = NULL;
+    axiom_element_t *exactlyone_ele = NULL;
+    axiom_namespace_t *policy_ns = NULL;
+    axutil_array_list_t *components = NULL;
+
+    policy_ns = axiom_namespace_create(env, NEETHI_NAMESPACE, NEETHI_PREFIX);
+    exactlyone_ele = axiom_element_create(env, parent, NEETHI_EXACTLYONE, policy_ns,
+        &exactlyone_node);
+    if(!exactlyone_node)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "Cannot create 'ExactlyOne' node. Serialization of 'ExactlyOne' assertion failed");
+        return AXIS2_FAILURE;
+    }
+
+    components = neethi_exactlyone_get_policy_components(neethi_exactlyone, env);
+    if(components)
+    {
+        axis2_status_t status = AXIS2_FAILURE;
+        int i = 0;
+        for(i = 0; i < axutil_array_list_size(components, env); i++)
+        {
+            neethi_operator_t *operator = NULL;
+            operator = (neethi_operator_t *)axutil_array_list_get(components, env, i);
+            if(operator)
+            {
+                status = neethi_operator_serialize(operator, env, exactlyone_node);
+                if(status != AXIS2_SUCCESS)
+                {
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Neethi operator serialization failed. "
+                            "Cannot serialize 'ExactlyOne' assertion");
+                    return AXIS2_FAILURE;
+                }
+            }
+        }
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/mtom_assertion_checker.c b/neethi/src/mtom_assertion_checker.c
new file mode 100644
index 0000000..77e5ff0
--- /dev/null
+++ b/neethi/src/mtom_assertion_checker.c
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_operator.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+#include <neethi_assertion.h>
+#include <neethi_mtom_assertion_checker.h>
+
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+neethi_is_mtom_required(
+    const axutil_env_t *env,
+    neethi_policy_t *policy)
+{
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+    neethi_operator_t *operator = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+    int i = 0;
+
+    normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+
+    if(normalized_policy)
+    {
+        alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+    }
+
+    component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+    all = (neethi_all_t *)neethi_operator_get_value(component, env);
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        /*if (value)
+         {*/
+        if(type == ASSERTION_TYPE_OPTIMIZED_MIME_SERIALIZATION)
+        {
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+            return AXIS2_TRUE;
+        }
+        /*}*/
+    }
+    neethi_policy_free(normalized_policy, env);
+    normalized_policy = NULL;
+
+    return AXIS2_FALSE;
+}
diff --git a/neethi/src/operator.c b/neethi/src/operator.c
new file mode 100644
index 0000000..68554dc
--- /dev/null
+++ b/neethi/src/operator.c
@@ -0,0 +1,216 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_reference.h>
+#include <neethi_assertion.h>
+
+struct neethi_operator_t
+{
+    /* This may be a policy, all, exatlyone, reference
+     * or an assertion */
+    void *value;
+
+    /* The type */
+    neethi_operator_type_t type;
+
+    /* Ref count to prevent double frees*/
+    int ref;
+};
+
+AXIS2_EXTERN neethi_operator_t *AXIS2_CALL
+neethi_operator_create(
+    const axutil_env_t *env)
+{
+    neethi_operator_t *neethi_operator = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    neethi_operator = (neethi_operator_t *)AXIS2_MALLOC(env->allocator, sizeof(neethi_operator_t));
+
+    if(neethi_operator == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_operator->value = NULL;
+    neethi_operator->type = OPERATOR_TYPE_UNKNOWN;
+    neethi_operator->ref = 0;
+    return neethi_operator;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+neethi_operator_free(
+    neethi_operator_t *neethi_operator,
+    const axutil_env_t *env)
+{
+    if(neethi_operator)
+    {
+        if(--(neethi_operator->ref) > 0)
+        {
+            return;
+        }
+
+        if(neethi_operator->value)
+        {
+            switch(neethi_operator->type)
+            {
+                case OPERATOR_TYPE_POLICY:
+                    neethi_policy_free((neethi_policy_t *)neethi_operator->value, env);
+                    neethi_operator->value = NULL;
+                    break;
+
+                case OPERATOR_TYPE_ALL:
+                    neethi_all_free((neethi_all_t *)neethi_operator->value, env);
+                    neethi_operator->value = NULL;
+                    break;
+
+                case OPERATOR_TYPE_EXACTLYONE:
+                    neethi_exactlyone_free((neethi_exactlyone_t *)neethi_operator-> value, env);
+                    neethi_operator->value = NULL;
+                    break;
+
+                case OPERATOR_TYPE_REFERENCE:
+                    neethi_reference_free((neethi_reference_t *)neethi_operator-> value, env);
+                    neethi_operator->value = NULL;
+                    break;
+
+                case OPERATOR_TYPE_ASSERTION:
+                    neethi_assertion_free((neethi_assertion_t *)neethi_operator-> value, env);
+                    neethi_operator->value = NULL;
+                    break;
+
+                case OPERATOR_TYPE_UNKNOWN:
+                    break;
+            }
+        }
+        AXIS2_FREE(env->allocator, neethi_operator);
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN neethi_operator_type_t AXIS2_CALL
+neethi_operator_get_type(
+    neethi_operator_t *neethi_operator,
+    const axutil_env_t *env)
+{
+    return neethi_operator->type;
+}
+
+AXIS2_EXTERN void *AXIS2_CALL
+neethi_operator_get_value(
+    neethi_operator_t *neethi_operator,
+    const axutil_env_t *env)
+{
+    return neethi_operator->value;
+}
+
+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)
+{
+    neethi_operator->type = type;
+    neethi_operator->value = (void *)value;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_operator_serialize(
+    neethi_operator_t *neethi_operator,
+    const axutil_env_t *env,
+    axiom_node_t *parent)
+{
+    neethi_policy_t *policy = NULL;
+    neethi_all_t *all = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_reference_t *reference = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    if(neethi_operator->value)
+    {
+        switch(neethi_operator->type)
+        {
+            case OPERATOR_TYPE_POLICY:
+                policy = (neethi_policy_t *)neethi_operator_get_value(neethi_operator, env);
+                if(!neethi_policy_serialize(policy, parent, env))
+                {
+                    return AXIS2_FAILURE;
+                }
+                else
+                {
+                    return AXIS2_SUCCESS;
+                }
+                break;
+
+            case OPERATOR_TYPE_ALL:
+                all = (neethi_all_t *)neethi_operator_get_value(neethi_operator, env);
+                return neethi_all_serialize(all, parent, env);
+                break;
+
+            case OPERATOR_TYPE_EXACTLYONE:
+                exactlyone = (neethi_exactlyone_t *)neethi_operator_get_value(neethi_operator, env);
+                return neethi_exactlyone_serialize(exactlyone, parent, env);
+                break;
+
+            case OPERATOR_TYPE_REFERENCE:
+                reference = (neethi_reference_t *)neethi_operator_get_value(neethi_operator, env);
+                return neethi_reference_serialize(reference, parent, env);
+                break;
+
+            case OPERATOR_TYPE_ASSERTION:
+                assertion = (neethi_assertion_t *)neethi_operator_get_value(neethi_operator, env);
+                return neethi_assertion_serialize(assertion, parent, env);
+                break;
+
+            case OPERATOR_TYPE_UNKNOWN:
+                break;
+        }
+        return AXIS2_SUCCESS;
+    }
+    else
+        return AXIS2_FAILURE;
+}
+
+/* We need this method to prevent freeing the value of operator, because some times we wrap certain
+ * policy operators inside neethi_operator in order to call some functions.See engine.c in neethi
+ * for more info */
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_operator_set_value_null(
+    neethi_operator_t *neethi_operator,
+    const axutil_env_t *env)
+{
+    neethi_operator->value = NULL;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_operator_increment_ref(
+    neethi_operator_t *operator,
+    const axutil_env_t *env)
+{
+    operator-> ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/policy.c b/neethi/src/policy.c
new file mode 100644
index 0000000..af08222
--- /dev/null
+++ b/neethi/src/policy.c
@@ -0,0 +1,446 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_policy.h>
+#include <neethi_engine.h>
+#include <axiom_attribute.h>
+
+struct neethi_policy_t
+{
+    /* Contains the child components */
+    axutil_array_list_t *policy_components;
+
+    /* A wsp:Policy element can have any number of attributes
+     * This has will store those */
+    axutil_hash_t *attributes;
+
+    /* This is the node containing the policy */
+    axiom_node_t *root_node;
+};
+
+static void
+neethi_policy_clear_attributes(
+    axutil_hash_t *attributes,
+    const axutil_env_t *env);
+
+/* Creates a neethi_policy object */
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_policy_create(
+    const axutil_env_t * env)
+{
+    neethi_policy_t *neethi_policy = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    neethi_policy = (neethi_policy_t *)AXIS2_MALLOC(env->allocator, sizeof(neethi_policy_t));
+
+    if(neethi_policy == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_policy->policy_components = NULL;
+
+    neethi_policy->policy_components = axutil_array_list_create(env, 0);
+    if(!(neethi_policy->policy_components))
+    {
+        neethi_policy_free(neethi_policy, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_policy->attributes = axutil_hash_make(env);
+    neethi_policy->root_node = NULL;
+
+    return neethi_policy;
+}
+
+/* Deallocate the memory for the neethi_policy object */
+AXIS2_EXTERN void AXIS2_CALL
+neethi_policy_free(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    if(neethi_policy)
+    {
+        /* We first remove the component list */
+
+        if(neethi_policy->policy_components)
+        {
+            int i = 0;
+            int size = 0;
+
+            size = axutil_array_list_size(neethi_policy->policy_components, env);
+
+            for(i = 0; i < size; i++)
+            {
+                neethi_operator_t *operator = NULL;
+                operator = (neethi_operator_t *)axutil_array_list_get(
+                    neethi_policy->policy_components, env, i);
+                if(operator)
+                {
+                    neethi_operator_free(operator, env);
+                }
+                operator = NULL;
+            }
+            axutil_array_list_free(neethi_policy->policy_components, env);
+            neethi_policy->policy_components = NULL;
+        }
+        if(neethi_policy->attributes)
+        {
+            neethi_policy_clear_attributes(neethi_policy->attributes, env);
+            neethi_policy->attributes = NULL;
+        }
+        if(neethi_policy->root_node)
+        {
+            axiom_node_free_tree(neethi_policy->root_node, env);
+            neethi_policy->root_node = NULL;
+        }
+        AXIS2_FREE(env->allocator, neethi_policy);
+        neethi_policy = NULL;
+    }
+    return;
+}
+
+/* This will free the attribute hash and its content.*/
+static void
+neethi_policy_clear_attributes(
+    axutil_hash_t *attributes,
+    const axutil_env_t *env)
+{
+    if(attributes)
+    {
+        axutil_hash_index_t *hi = NULL;
+        void *val = NULL;
+        const void *key = NULL;
+
+        for(hi = axutil_hash_first(attributes, env); hi; hi = axutil_hash_next(env, hi))
+        {
+            axutil_hash_this(hi, &key, NULL, &val);
+
+            if(key)
+            {
+                AXIS2_FREE(env->allocator, (axis2_char_t *)key);
+                key = NULL;
+            }
+
+            if(val)
+            {
+                AXIS2_FREE(env->allocator, (axis2_char_t *)val);
+                val = NULL;
+            }
+        }
+        axutil_hash_free(attributes, env);
+        attributes = NULL;
+    }
+}
+/* Implementations */
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+neethi_policy_get_policy_components(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    return neethi_policy->policy_components;
+}
+
+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)
+{
+    int size = axutil_array_list_size(arraylist, env);
+    int i = 0;
+
+    if(axutil_array_list_ensure_capacity(neethi_policy->policy_components, env, size + 1)
+        != AXIS2_SUCCESS)
+    {
+        return AXIS2_FAILURE;
+    }
+
+    for(i = 0; i < size; i++)
+    {
+        void *value = NULL;
+        value = axutil_array_list_get(arraylist, env, i);
+        /* The ref count is incremented in order to prevent double frees.*/
+        neethi_operator_increment_ref((neethi_operator_t *)value, env);
+        axutil_array_list_add(neethi_policy->policy_components, env, value);
+    }
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_policy_add_operator(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env,
+    neethi_operator_t *operator)
+{
+    neethi_operator_increment_ref(operator, env);
+    axutil_array_list_add(neethi_policy->policy_components, env, operator);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+neethi_policy_is_empty(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    return axutil_array_list_is_empty(neethi_policy->policy_components, env);
+}
+
+/* A normalized policy always has just one child and it is an exactlyone
+ * first child. So this method */
+AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL
+neethi_policy_get_exactlyone(
+    neethi_policy_t *normalized_neethi_policy,
+    const axutil_env_t *env)
+{
+    neethi_exactlyone_t *exactlyone = NULL;
+    axutil_array_list_t *list = NULL;
+
+    list = neethi_policy_get_policy_components(normalized_neethi_policy, env);
+    if(list)
+    {
+        if(axutil_array_list_size(list, env) == 1)
+        {
+            neethi_operator_t *op = NULL;
+            op = (neethi_operator_t *)axutil_array_list_get(list, env, 0);
+            if(!op)
+            {
+                return NULL;
+            }
+            if(neethi_operator_get_type(op, env) != OPERATOR_TYPE_EXACTLYONE)
+            {
+                return NULL;
+            }
+            exactlyone = (neethi_exactlyone_t *)neethi_operator_get_value(op, env);
+            return exactlyone;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+/* This function is called for a normalized policy So it will return the components of the only
+ * child. That should be an exactlyone The children of that exactlyone are all.*/
+AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
+neethi_policy_get_alternatives(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    neethi_exactlyone_t *exactlyone = NULL;
+    exactlyone = neethi_policy_get_exactlyone(neethi_policy, env);
+    if(!exactlyone)
+        return NULL;
+
+    return neethi_exactlyone_get_policy_components(exactlyone, env);
+
+}
+
+/* This will return any attribute which has the local name of Name */
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+neethi_policy_get_name(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    if(neethi_policy->attributes)
+    {
+        axutil_qname_t *qname = NULL;
+        axis2_char_t *name = NULL;
+        qname = axutil_qname_create(env, NEETHI_NAME, NULL, NULL);
+
+        if(qname)
+        {
+            axis2_char_t *key = axutil_qname_to_string(qname, env);
+            if(key)
+            {
+                name = (axis2_char_t *)axutil_hash_get(neethi_policy->attributes, key,
+                    AXIS2_HASH_KEY_STRING);
+            }
+            axutil_qname_free(qname, env);
+            qname = NULL;
+            return name;
+        }
+        else
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+/* This method will return the attribute value of wsu:Id if there are any such attributes */
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+neethi_policy_get_id(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    if(neethi_policy->attributes)
+    {
+        axis2_char_t *id = NULL;
+        axutil_qname_t *qname = NULL;
+        qname = axutil_qname_create(env, NEETHI_ID, NEETHI_WSU_NS, NULL);
+
+        if(qname)
+        {
+            axis2_char_t *key = axutil_qname_to_string(qname, env);
+            if(key)
+            {
+                id = (axis2_char_t *)axutil_hash_get(neethi_policy->attributes, key,
+                    AXIS2_HASH_KEY_STRING);
+            }
+            axutil_qname_free(qname, env);
+            qname = NULL;
+            return id;
+        }
+        else
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+/* When we encounter an attribute with wsu:Id we will store it in the hash. We are not
+ * considering the prefix. Just the namespace and the local_name. */
+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)
+{
+    axutil_qname_t *qname = NULL;
+    axis2_char_t *key = NULL;
+
+    qname = axutil_qname_create(env, NEETHI_ID, NEETHI_WSU_NS, NULL);
+
+    if(qname)
+    {
+        key = axutil_qname_to_string(qname, env);
+        if(key)
+        {
+            axutil_hash_set(neethi_policy->attributes, axutil_strdup(env, key),
+                AXIS2_HASH_KEY_STRING, axutil_strdup(env, id));
+        }
+        axutil_qname_free(qname, env);
+        return AXIS2_SUCCESS;
+    }
+    else
+    {
+        return AXIS2_FAILURE;
+    }
+}
+
+/* When we encounter an attribute with Name we will store it in the hash. This has no Namespace.*/
+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)
+{
+    axutil_qname_t *qname = NULL;
+    axis2_char_t *key = NULL;
+
+    qname = axutil_qname_create(env, NEETHI_NAME, NULL, NULL);
+
+    if(qname)
+    {
+        key = axutil_qname_to_string(qname, env);
+        if(key)
+        {
+            axutil_hash_set(neethi_policy->attributes, axutil_strdup(env, key),
+                AXIS2_HASH_KEY_STRING, axutil_strdup(env, name));
+        }
+        axutil_qname_free(qname, env);
+        return AXIS2_SUCCESS;
+    }
+    else
+    {
+        return AXIS2_FAILURE;
+    }
+}
+
+AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
+neethi_policy_get_attributes(
+    neethi_policy_t *neethi_policy,
+    const axutil_env_t *env)
+{
+    return neethi_policy->attributes;
+}
+
+/*This function is for serializing*/
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+neethi_policy_serialize(
+    neethi_policy_t *neethi_policy,
+    axiom_node_t *parent,
+    const axutil_env_t *env)
+{
+    axiom_node_t *policy_node = NULL;
+    axiom_element_t *policy_ele = NULL;
+    axiom_namespace_t *policy_ns = NULL;
+    axutil_array_list_t *components = NULL;
+
+    policy_ns = axiom_namespace_create(env, NEETHI_NAMESPACE, NEETHI_PREFIX);
+    policy_ele = axiom_element_create(env, parent, NEETHI_POLICY, policy_ns, &policy_node);
+    if(!policy_ele)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "Cannot create policy node. Policy serialization failed");
+        return NULL;
+    }
+
+    components = neethi_policy_get_policy_components(neethi_policy, env);
+    if(components)
+    {
+        int i = 0;
+        axis2_status_t status = AXIS2_FAILURE;
+        for(i = 0; i < axutil_array_list_size(components, env); ++i)
+        {
+            neethi_operator_t *operator = NULL;
+            operator = (neethi_operator_t *)axutil_array_list_get(components, env, i);
+            if(operator)
+            {
+                status = neethi_operator_serialize(operator, env, policy_node);
+                if(status != AXIS2_SUCCESS)
+                {
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Neethi operator serialization failed.");
+                    return NULL;
+                }
+            }
+        }
+    }
+    return policy_node;
+}
+
+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)
+{
+    policy->root_node = root_node;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/reference.c b/neethi/src/reference.c
new file mode 100644
index 0000000..8b52a26
--- /dev/null
+++ b/neethi/src/reference.c
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_reference.h>
+
+struct neethi_reference_t
+{
+    axis2_char_t *uri;
+};
+
+AXIS2_EXTERN neethi_reference_t *AXIS2_CALL
+neethi_reference_create(
+    const axutil_env_t *env)
+{
+    neethi_reference_t *neethi_reference = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    neethi_reference = (neethi_reference_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(neethi_reference_t));
+
+    if(neethi_reference == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_reference->uri = NULL;
+
+    return neethi_reference;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+neethi_reference_free(
+    neethi_reference_t *neethi_reference,
+    const axutil_env_t *env)
+{
+    if(neethi_reference)
+    {
+        AXIS2_FREE(env->allocator, neethi_reference);
+        neethi_reference = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+neethi_reference_get_uri(
+    neethi_reference_t *neethi_reference,
+    const axutil_env_t *env)
+{
+    return neethi_reference->uri;
+}
+
+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)
+{
+    neethi_reference->uri = uri;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+neethi_reference_serialize(
+    neethi_reference_t *neethi_reference,
+    axiom_node_t *parent,
+    const axutil_env_t *env)
+{
+    axiom_node_t *ref_node = NULL;
+    axiom_element_t *ref_ele = NULL;
+    axiom_namespace_t *policy_ns = NULL;
+    axiom_attribute_t *att_uri = NULL;
+
+    policy_ns = axiom_namespace_create(env, NEETHI_NAMESPACE, NEETHI_PREFIX);
+    ref_ele = axiom_element_create(env, parent, NEETHI_REFERENCE, policy_ns, &ref_node);
+    if(!ref_node)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "'reference' node creation failed. Cannot serialize 'reference' assertion");
+        return AXIS2_FAILURE;
+    }
+
+    att_uri = axiom_attribute_create(env, NEETHI_URI, neethi_reference->uri, NULL);
+    axiom_element_add_attribute(ref_ele, env, att_uri, ref_node);
+
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/registry.c b/neethi/src/registry.c
new file mode 100644
index 0000000..4ba0851
--- /dev/null
+++ b/neethi/src/registry.c
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <neethi_registry.h>
+
+struct neethi_registry_t
+{
+    axutil_hash_t *registry;
+    neethi_registry_t *parent;
+};
+
+AXIS2_EXTERN neethi_registry_t *AXIS2_CALL
+neethi_registry_create(
+    const axutil_env_t *env)
+{
+    neethi_registry_t *neethi_registry = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    neethi_registry = (neethi_registry_t *)AXIS2_MALLOC(env->allocator, sizeof(neethi_registry_t));
+
+    if(neethi_registry == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_registry->registry = NULL;
+
+    neethi_registry->registry = axutil_hash_make(env);
+    if(!(neethi_registry->registry))
+    {
+        neethi_registry_free(neethi_registry, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    neethi_registry->parent = NULL;
+
+    return neethi_registry;
+}
+
+AXIS2_EXTERN neethi_registry_t *AXIS2_CALL
+neethi_registry_create_with_parent(
+    const axutil_env_t *env,
+    neethi_registry_t *parent)
+{
+    neethi_registry_t *neethi_registry = NULL;
+
+    neethi_registry = neethi_registry_create(env);
+    if(!neethi_registry)
+        return NULL;
+
+    neethi_registry->parent = parent;
+    return neethi_registry;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+neethi_registry_free(
+    neethi_registry_t *neethi_registry,
+    const axutil_env_t *env)
+{
+    if(neethi_registry->registry)
+    {
+        axutil_hash_index_t *hi = NULL;
+        void *val = NULL;
+        for(hi = axutil_hash_first(neethi_registry->registry, env); hi; hi = axutil_hash_next(env,
+            hi))
+        {
+            neethi_policy_t *neethi_policy = NULL;
+            axutil_hash_this(hi, NULL, NULL, &val);
+            neethi_policy = (neethi_policy_t *)val;
+            if(neethi_policy)
+                neethi_policy_free(neethi_policy, env);
+            val = NULL;
+            neethi_policy = NULL;
+
+        }
+        axutil_hash_free(neethi_registry->registry, env);
+    }
+    if(neethi_registry->parent)
+    {
+        neethi_registry->parent = NULL;
+    }
+    AXIS2_FREE(env->allocator, neethi_registry);
+}
+
+/* Implementations */
+
+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)
+{
+    axutil_hash_set(neethi_registry->registry, key, AXIS2_HASH_KEY_STRING, value);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_registry_lookup(
+    neethi_registry_t *neethi_registry,
+    const axutil_env_t *env,
+    axis2_char_t *key)
+{
+    neethi_policy_t *policy = NULL;
+
+    policy = (neethi_policy_t *)axutil_hash_get(neethi_registry->registry, key,
+        AXIS2_HASH_KEY_STRING);
+
+    if(!policy && neethi_registry->parent)
+    {
+        return neethi_registry_lookup(neethi_registry->parent, env, key);
+    }
+    return policy;
+}
diff --git a/neethi/src/rmpolicy/Makefile.am b/neethi/src/rmpolicy/Makefile.am
new file mode 100644
index 0000000..1b46d73
--- /dev/null
+++ b/neethi/src/rmpolicy/Makefile.am
@@ -0,0 +1,13 @@
+TESTS =
+
+noinst_LTLIBRARIES = librm_policy.la
+
+librm_policy_la_SOURCES = rm_assertion.c rm_assertion_builder.c
+
+librm_policy_la_LIBADD  = ../../../util/src/libaxutil.la
+
+INCLUDES = -I$(top_builddir)/include \
+			-I ../../include \
+			-I ../../../util/include \
+	        -I ../../../axiom/include \
+    	    -I ../../../include
diff --git a/neethi/src/rmpolicy/rm_assertion.c b/neethi/src/rmpolicy/rm_assertion.c
new file mode 100644
index 0000000..42f0fd4
--- /dev/null
+++ b/neethi/src/rmpolicy/rm_assertion.c
@@ -0,0 +1,511 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_rm_assertion.h>
+#include <neethi_assertion.h>
+#include <neethi_all.h>
+
+struct axis2_rm_assertion_t
+{
+    /* RM Policy 1.1 assertions */
+    axis2_bool_t is_sequence_str;
+    axis2_bool_t is_sequence_transport_security;
+    axis2_bool_t is_exactly_once;
+    axis2_bool_t is_atleast_once;
+    axis2_bool_t is_atmost_once;
+    axis2_bool_t is_inorder;
+
+    /* RM Policy 1.0 assertions */
+    axis2_char_t *inactivity_timeout;
+    axis2_char_t *retrans_interval;
+    axis2_char_t *ack_interval;
+    axis2_bool_t is_exp_backoff;
+
+    /* Sandesha2 specific assrtions */
+    axis2_char_t *storage_mgr;
+    axis2_char_t *message_types_to_drop;
+    axis2_char_t *max_retrans_count;
+    axis2_char_t *sender_sleep_time;
+    axis2_char_t *invoker_sleep_time;
+    axis2_char_t *polling_wait_time;
+    axis2_char_t *terminate_delay;
+    axis2_char_t *sandesha2_db;
+    axis2_char_t *spec_version;
+};
+
+AXIS2_EXTERN axis2_rm_assertion_t *AXIS2_CALL
+axis2_rm_assertion_create(
+    const axutil_env_t * env)
+{
+    axis2_rm_assertion_t *rm_assertion;
+
+    rm_assertion = (axis2_rm_assertion_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(axis2_rm_assertion_t));
+
+    if(rm_assertion == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    rm_assertion->is_sequence_str = AXIS2_FALSE;
+    rm_assertion->is_sequence_transport_security = AXIS2_FALSE;
+    rm_assertion->is_exactly_once = AXIS2_TRUE;
+    rm_assertion->is_atleast_once = AXIS2_FALSE;
+    rm_assertion->is_atmost_once = AXIS2_FALSE;
+    rm_assertion->is_inorder = AXIS2_FALSE;
+
+    /* RM Policy 1.0 assertions */
+    rm_assertion->inactivity_timeout = NULL;
+    rm_assertion->retrans_interval = NULL;
+    rm_assertion->ack_interval = NULL;
+    rm_assertion->is_exp_backoff = AXIS2_FALSE;
+
+    /* Sandesha2 specific assrtions */
+    rm_assertion->storage_mgr = NULL;
+    rm_assertion->message_types_to_drop = NULL;
+    rm_assertion->max_retrans_count = NULL;
+    rm_assertion->sender_sleep_time = NULL;
+    rm_assertion->invoker_sleep_time = NULL;
+    rm_assertion->polling_wait_time = NULL;
+    rm_assertion->terminate_delay = NULL;
+    rm_assertion->sandesha2_db = NULL;
+    rm_assertion->spec_version = NULL;
+
+    return rm_assertion;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+axis2_rm_assertion_free(
+    axis2_rm_assertion_t * rm_assertion,
+    const axutil_env_t * env)
+{
+    if(rm_assertion)
+    {
+        AXIS2_FREE(env->allocator, rm_assertion);
+        rm_assertion = NULL;
+    }
+
+    return;
+}
+
+/* Implementations.
+ * Following functions are getters and setters 
+ * for rm_assertion struct */
+
+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)
+{
+    return rm_assertion->is_sequence_str;
+}
+
+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)
+{
+    rm_assertion->is_sequence_str = is_sequence_str;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->is_sequence_transport_security;
+}
+
+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)
+{
+    rm_assertion->is_sequence_transport_security = is_sequence_transport_security;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->is_exactly_once;
+}
+
+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)
+{
+    rm_assertion->is_exactly_once = is_exactly_once;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->is_atleast_once;
+}
+
+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)
+{
+    rm_assertion->is_atleast_once = is_atleast_once;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->is_atmost_once;
+}
+
+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)
+{
+    rm_assertion->is_atmost_once = is_atmost_once;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+axis2_rm_assertion_get_is_inorder(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->is_inorder;
+}
+
+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)
+{
+    rm_assertion->is_inorder = is_inorder;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axis2_rm_assertion_get_inactivity_timeout(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->inactivity_timeout;
+}
+
+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)
+{
+    rm_assertion->inactivity_timeout = inactivity_timeout;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axis2_rm_assertion_get_retrans_interval(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->retrans_interval;
+}
+
+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)
+{
+    rm_assertion->retrans_interval = retrans_interval;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axis2_rm_assertion_get_ack_interval(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->ack_interval;
+}
+
+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)
+{
+    rm_assertion->ack_interval = ack_interval;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->is_exp_backoff;
+}
+
+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)
+{
+    rm_assertion->is_exp_backoff = is_exp_backoff;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axis2_rm_assertion_get_storage_mgr(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->storage_mgr;
+}
+
+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)
+{
+    rm_assertion->storage_mgr = storage_mgr;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->message_types_to_drop;
+}
+
+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)
+{
+    rm_assertion->message_types_to_drop = message_types_to_drop;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->max_retrans_count;
+}
+
+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)
+{
+    rm_assertion->max_retrans_count = max_retrans_count;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->sender_sleep_time;
+}
+
+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)
+{
+    rm_assertion->sender_sleep_time = sender_sleep_time;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->invoker_sleep_time;
+}
+
+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)
+{
+    rm_assertion->invoker_sleep_time = invoker_sleep_time;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rm_assertion->polling_wait_time;
+}
+
+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)
+{
+    rm_assertion->polling_wait_time = polling_wait_time;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axis2_rm_assertion_get_terminate_delay(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->terminate_delay;
+}
+
+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)
+{
+    rm_assertion->terminate_delay = terminate_delay;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axis2_rm_assertion_get_sandesha2_db(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->sandesha2_db;
+}
+
+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)
+{
+    rm_assertion->sandesha2_db = sandesha2_db;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axis2_rm_assertion_get_spec_version(
+    axis2_rm_assertion_t *rm_assertion,
+    const axutil_env_t * env)
+{
+    return rm_assertion->spec_version;
+}
+
+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)
+{
+    rm_assertion->spec_version = spec_version;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_rm_assertion_t* AXIS2_CALL
+axis2_rm_assertion_get_from_policy(
+    const axutil_env_t *env,
+    neethi_policy_t *policy)
+{
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_operator_t *operator = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+    int i = 0;
+
+    alternatives = neethi_policy_get_alternatives(policy, env);
+
+    component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+    all = (neethi_all_t *)neethi_operator_get_value(component, env);
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_RM_ASSERTION)
+            {
+                return (axis2_rm_assertion_t *)value;
+            }
+        }
+    }
+
+    return NULL;
+}
+
diff --git a/neethi/src/rmpolicy/rm_assertion_builder.c b/neethi/src/rmpolicy/rm_assertion_builder.c
new file mode 100644
index 0000000..9b92fd7
--- /dev/null
+++ b/neethi/src/rmpolicy/rm_assertion_builder.c
@@ -0,0 +1,562 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_rm_assertion_builder.h>
+
+/*private functions*/
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_process_sandesha2_assertions(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *node,
+    axiom_element_t *element);
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_populate_for_10(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *rm_assertion_node,
+    axiom_element_t *rm_assertion_element);
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_populate_for_11(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *rm_assertion_node,
+    axiom_element_t *rm_assertion_element);
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_process_delivery_assuarance(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *da_node,
+    axiom_element_t *da_element);
+
+/* This functions retrives a rm_assertion axiom_node 
+ * which may be 1.0 or 1.1 and return a rm_assertion
+ * struct */
+
+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)
+{
+    axis2_rm_assertion_t *rm_assertion = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+    axiom_children_iterator_t *children_iter = NULL;
+    neethi_assertion_t *assertion = NULL;
+    axis2_char_t *ns = NULL;
+    axutil_qname_t *node_qname = NULL;
+
+    node_qname = axiom_element_get_qname(rm_assertion_ele, env, rm_assertion_node);
+    if(!node_qname)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get qname from element");
+        return NULL;
+    }
+
+    ns = axutil_qname_get_uri(node_qname, env);
+    if(!ns)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get namespace from element.");
+        return NULL;
+    }
+
+    rm_assertion = axis2_rm_assertion_create(env);
+    if(!rm_assertion)
+    {
+        return NULL;
+    }
+
+    /* First we check whether this is in 1.0 or 1.1 
+     * namespace. Then we called the appropriate builder */
+
+    children_iter = axiom_element_get_children(rm_assertion_ele, env, rm_assertion_node);
+
+    if(!axutil_strcmp(ns, AXIS2_RM_POLICY_10_NS))
+    {
+        status = axis2_rm_assertion_builder_populate_for_10(env, rm_assertion, rm_assertion_node,
+            rm_assertion_ele);
+
+        axiom_children_iterator_reset(children_iter, env);
+
+    }
+    else if(!axutil_strcmp(ns, AXIS2_RM_POLICY_11_NS))
+    {
+        status = axis2_rm_assertion_builder_populate_for_11(env, rm_assertion, rm_assertion_node,
+            rm_assertion_ele);
+    }
+
+    if(status == AXIS2_FAILURE)
+    {
+        axis2_rm_assertion_free(rm_assertion, env);
+        rm_assertion = NULL;
+        return NULL;
+    }
+
+    /*children_iter = axiom_element_get_children(rm_assertion_ele, env, rm_assertion_node);*/
+    if(children_iter)
+    {
+        while(axiom_children_iterator_has_next(children_iter, env))
+        {
+            axiom_node_t *node = NULL;
+            axiom_element_t *ele = NULL;
+            axis2_char_t *local_name = NULL;
+            axutil_qname_t *node_qname = NULL;
+
+            node = axiom_children_iterator_next(children_iter, env);
+            if(node)
+            {
+                if(axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
+                {
+                    ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+                    node_qname = axiom_element_get_qname(ele, env, node);
+                    if(!node_qname)
+                    {
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "[neethi] Cannot get qname from element %s.", local_name);
+                        return NULL;
+                    }
+                    ns = axutil_qname_get_uri(node_qname, env);
+                    if(!ns)
+                    {
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "[neethi] Cannot get namespace from element %s.", local_name);
+                        return NULL;
+                    }
+                    if(!axutil_strcmp(ns, AXIS2_SANDESHA2_NS))
+                    {
+                        status = axis2_rm_assertion_builder_process_sandesha2_assertions(env,
+                            rm_assertion, node, ele);
+                        if(status == AXIS2_FAILURE)
+                        {
+                            axis2_rm_assertion_free(rm_assertion, env);
+                            rm_assertion = NULL;
+                            return NULL;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assertion = neethi_assertion_create_with_args(env,
+        (AXIS2_FREE_VOID_ARG)axis2_rm_assertion_free, rm_assertion, ASSERTION_TYPE_RM_ASSERTION);
+    return assertion;
+}
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_populate_for_10(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *rm_assertion_node,
+    axiom_element_t *rm_assertion_element)
+{
+    axiom_children_iterator_t *children_iter = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    /* In rm 1.0 it is just child elements which inside 
+     * rm_assertion contains all the properties. */
+    
+    status = axis2_rm_assertion_set_spec_version(rm_assertion, env, RM_SPEC_VERSION_1_0);
+
+    children_iter = axiom_element_get_children(rm_assertion_element, env, rm_assertion_node);
+    if(children_iter)
+    {
+        while(axiom_children_iterator_has_next(children_iter, env))
+        {
+            axiom_node_t *node = NULL;
+            axiom_element_t *ele = NULL;
+            axis2_char_t *local_name = NULL;
+            node = axiom_children_iterator_next(children_iter, env);
+            if(node)
+            {
+                if(axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
+                {
+                    ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+                    if(ele)
+                    {
+                        axutil_qname_t *node_qname = NULL;
+                        axis2_char_t *ns = NULL;
+                        node_qname = axiom_element_get_qname(ele, env, node);
+                        if(!node)
+                        {
+                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                "[neethi] Cannot get qname from element");
+                            return AXIS2_FAILURE;
+                        }
+
+                        ns = axutil_qname_get_uri(node_qname, env);
+                        if(!ns)
+                        {
+                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                "[neethi] Cannot get namespace from element.");
+                            return AXIS2_FAILURE;
+                        }
+
+                        if(axutil_strcmp(ns, AXIS2_RM_POLICY_10_NS))
+                        {
+                            continue;
+                        }
+
+                        local_name = axiom_element_get_localname(ele, env);
+                        if(local_name)
+                        {
+
+                            if(!axutil_strcmp(local_name, AXIS2_RM_INACTIVITY_TIMEOUT))
+                            {
+                                axis2_char_t *inactivity_timeout = NULL;
+                                axutil_qname_t *qname = NULL;
+
+                                qname = axutil_qname_create(env, "Milliseconds", NULL, NULL);
+
+                                inactivity_timeout = axiom_element_get_attribute_value(ele, env,
+                                    qname);
+                                if(qname)
+                                {
+                                    axutil_qname_free(qname, env);
+                                    qname = NULL;
+                                }
+                                status = axis2_rm_assertion_set_inactivity_timeout(rm_assertion,
+                                    env, inactivity_timeout);
+                            }
+                            else if(!axutil_strcmp(local_name,
+                                AXIS2_RM_BASE_RETRANSMISSION_INTERVAL))
+                            {
+                                axis2_char_t *rti = NULL;
+                                axutil_qname_t *qname = NULL;
+                                qname = axutil_qname_create(env, "Milliseconds", NULL, NULL);
+
+                                rti = axiom_element_get_attribute_value(ele, env, qname);
+                                if(qname)
+                                {
+                                    axutil_qname_free(qname, env);
+                                    qname = NULL;
+                                }
+                                status = axis2_rm_assertion_set_retrans_interval(rm_assertion, env,
+                                    rti);
+                            }
+                            else if(!axutil_strcmp(local_name, AXIS2_RM_EXPONENTIAL_BACK_OFF))
+                            {
+                                status = axis2_rm_assertion_set_is_exp_backoff(rm_assertion, env,
+                                    AXIS2_TRUE);
+                            }
+                            else if(!axutil_strcmp(local_name, AXIS2_RM_ACKNOWLEDGEMENT_INTERVAL))
+                            {
+                                axis2_char_t *ack_interval = NULL;
+                                axutil_qname_t *qname = NULL;
+
+                                qname = axutil_qname_create(env, "Milliseconds", NULL, NULL);
+
+                                ack_interval = axiom_element_get_attribute_value(ele, env, qname);
+                                if(qname)
+                                {
+                                    axutil_qname_free(qname, env);
+                                    qname = NULL;
+                                }
+                                status = axis2_rm_assertion_set_ack_interval(rm_assertion, env,
+                                    ack_interval);
+                            }
+                            else
+                            {
+                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                    "[neethi] Unknown Assertion %s ", local_name);
+                                return AXIS2_FAILURE;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return status;
+}
+
+/* In rm 1.1 rm_assertion contains a policy element as 
+ * a child element. We are not creating a policy object 
+ * for policy element. Becasue then the processing become 
+ * complex.So we just parse the axiom model */
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_populate_for_11(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *rm_assertion_node,
+    axiom_element_t *rm_assertion_element)
+{
+    axiom_children_iterator_t *children_iter = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    
+    status = axis2_rm_assertion_set_spec_version(rm_assertion, env, RM_SPEC_VERSION_1_1);
+
+    child_node = axiom_node_get_first_element(rm_assertion_node, env);
+    if(child_node)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            children_iter = axiom_element_get_children(child_element, env, child_node);
+            if(children_iter)
+            {
+                while(axiom_children_iterator_has_next(children_iter, env))
+                {
+                    axiom_node_t *node = NULL;
+                    axiom_element_t *ele = NULL;
+                    axis2_char_t *local_name = NULL;
+                    node = axiom_children_iterator_next(children_iter, env);
+                    if(node)
+                    {
+                        if(axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
+                        {
+                            ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+                            if(ele)
+                            {
+                                axutil_qname_t *node_qname = NULL;
+                                axis2_char_t *ns = NULL;
+                                node_qname = axiom_element_get_qname(ele, env, node);
+                                if(!node)
+                                {
+                                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                        "[neethi] Cannot get qname from element");
+                                    return AXIS2_FAILURE;
+                                }
+
+                                ns = axutil_qname_get_uri(node_qname, env);
+                                if(!ns)
+                                {
+                                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                        "[neethi] Cannot get namespace from element.");
+                                    return AXIS2_FAILURE;
+                                }
+
+                                if(axutil_strcmp(ns, AXIS2_RM_POLICY_11_NS))
+                                {
+                                    continue;
+                                }
+                                local_name = axiom_element_get_localname(ele, env);
+                                if(local_name)
+                                {
+                                    if(!axutil_strcmp(local_name, AXIS2_RM_SEQUENCE_STR))
+                                    {
+                                        status = axis2_rm_assertion_set_is_sequence_str(
+                                            rm_assertion, env, AXIS2_TRUE);
+                                    }
+                                    else if(!axutil_strcmp(local_name,
+                                        AXIS2_RM_SEQUENCE_TRANSPORT_SECURITY))
+                                    {
+                                        status
+                                            = axis2_rm_assertion_set_is_sequence_transport_security(
+                                                rm_assertion, env, AXIS2_TRUE);
+                                    }
+                                    else if(!axutil_strcmp(local_name, AXIS2_RM_DELIVERY_ASSURANCE))
+                                    {
+                                        status
+                                            = axis2_rm_assertion_builder_process_delivery_assuarance(
+                                                env, rm_assertion, node, ele);
+                                    }
+                                    else
+                                    {
+                                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                            "[neethi] Unknown Assertion %s ", local_name);
+                                        return AXIS2_FAILURE;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return status;
+}
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_process_delivery_assuarance(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *da_node,
+    axiom_element_t *da_element)
+{
+    axiom_children_iterator_t *children_iter = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+
+    child_node = axiom_node_get_first_element(da_node, env);
+    if(child_node)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            children_iter = axiom_element_get_children(child_element, env, child_node);
+            if(children_iter)
+            {
+                while(axiom_children_iterator_has_next(children_iter, env))
+                {
+                    axiom_node_t *node = NULL;
+                    axiom_element_t *ele = NULL;
+                    axis2_char_t *local_name = NULL;
+                    node = axiom_children_iterator_next(children_iter, env);
+                    if(node)
+                    {
+                        if(axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
+                        {
+                            ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+                            if(ele)
+                            {
+                                local_name = axiom_element_get_localname(ele, env);
+                                if(local_name)
+                                {
+                                    if(!axutil_strcmp(local_name, AXIS2_RM_EXACTLY_ONCE))
+                                    {
+                                        status = axis2_rm_assertion_set_is_exactly_once(
+                                            rm_assertion, env, AXIS2_TRUE);
+                                    }
+                                    else if(!axutil_strcmp(local_name, AXIS2_RM_AT_LEAST_ONCE))
+                                    {
+                                        status = axis2_rm_assertion_set_is_atleast_once(
+                                            rm_assertion, env, AXIS2_TRUE);
+                                    }
+                                    else if(!axutil_strcmp(local_name, AXIS2_RM_AT_MOST_ONCE))
+                                    {
+                                        status = axis2_rm_assertion_set_is_atmost_once(
+                                            rm_assertion, env, AXIS2_TRUE);
+                                    }
+                                    else if(!axutil_strcmp(local_name, AXIS2_RM_IN_ORDER))
+                                    {
+                                        status = axis2_rm_assertion_set_is_inorder(rm_assertion,
+                                            env, AXIS2_TRUE);
+                                    }
+                                    else
+                                    {
+                                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                            "[neethi] Unknown Assertion %s ", local_name);
+                                        return AXIS2_FAILURE;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return status;
+}
+
+static axis2_status_t AXIS2_CALL
+axis2_rm_assertion_builder_process_sandesha2_assertions(
+    const axutil_env_t *env,
+    axis2_rm_assertion_t *rm_assertion,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    axis2_status_t status = AXIS2_FAILURE;
+    axis2_char_t *local_name = NULL;
+
+    if(element)
+    {
+        local_name = axiom_element_get_localname(element, env);
+        if(local_name)
+        {
+            if(!axutil_strcmp(local_name, AXIS2_RM_BASE_RETRANSMISSION_INTERVAL))
+            {
+                axis2_char_t *rti = NULL;
+                rti = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_retrans_interval(rm_assertion, env, rti);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_INACTIVITY_TIMEOUT))
+            {
+                axis2_char_t *inactivity_timeout = NULL;
+                inactivity_timeout = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_inactivity_timeout(rm_assertion, env,
+                    inactivity_timeout);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_ACKNOWLEDGEMENT_INTERVAL))
+            {
+                axis2_char_t *ack_interval = NULL;
+                ack_interval = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_ack_interval(rm_assertion, env, ack_interval);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_STORAGE_MANAGER))
+            {
+                axis2_char_t *storage_mgr = NULL;
+                storage_mgr = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_storage_mgr(rm_assertion, env, storage_mgr);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_SANDESHA2_DB))
+            {
+                axis2_char_t *sandesha2_db = NULL;
+                sandesha2_db = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_sandesha2_db(rm_assertion, env, sandesha2_db);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_MESSAGE_TYPES_TO_DROP))
+            {
+                axis2_char_t *message_types_to_drop = NULL;
+                message_types_to_drop = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_message_types_to_drop(rm_assertion, env,
+                    message_types_to_drop);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_MAX_RETRANS_COUNT))
+            {
+                axis2_char_t *retrans_count = NULL;
+                retrans_count = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_max_retrans_count(rm_assertion, env, retrans_count);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_SENDER_SLEEP_TIME))
+            {
+                axis2_char_t *sender_sleep_time = NULL;
+                sender_sleep_time = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_sender_sleep_time(rm_assertion, env,
+                    sender_sleep_time);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_INVOKER_SLEEP_TIME))
+            {
+                axis2_char_t *invoker_sleep_time = NULL;
+                invoker_sleep_time = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_invoker_sleep_time(rm_assertion, env,
+                    invoker_sleep_time);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_POLLING_WAIT_TIME))
+            {
+                axis2_char_t *polling_wait_time = NULL;
+                polling_wait_time = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_polling_wait_time(rm_assertion, env,
+                    polling_wait_time);
+            }
+            else if(!axutil_strcmp(local_name, AXIS2_RM_TERMINATE_DELAY))
+            {
+                axis2_char_t *terminate_delay = NULL;
+                terminate_delay = axiom_element_get_text(element, env, node);
+                return axis2_rm_assertion_set_terminate_delay(rm_assertion, env, terminate_delay);
+            }
+            else
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Unknown Assertion %s ",
+                    local_name);
+                return AXIS2_FAILURE;
+            }
+        }
+    }
+    return status;
+}
+
diff --git a/neethi/src/samples/test1.xml b/neethi/src/samples/test1.xml
new file mode 100644
index 0000000..6cf1539
--- /dev/null
+++ b/neethi/src/samples/test1.xml
@@ -0,0 +1,4 @@
+
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne />
+</wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test10.xml b/neethi/src/samples/test10.xml
new file mode 100644
index 0000000..0c16d15
--- /dev/null
+++ b/neethi/src/samples/test10.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1E --><wsp:ExactlyOne /></wsp:Policy>
diff --git a/neethi/src/samples/test11.xml b/neethi/src/samples/test11.xml
new file mode 100644
index 0000000..453688a
--- /dev/null
+++ b/neethi/src/samples/test11.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1F --><wsp:All /></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test12.xml b/neethi/src/samples/test12.xml
new file mode 100644
index 0000000..322d865
--- /dev/null
+++ b/neethi/src/samples/test12.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext" ><!-- 1G --><wsp:All><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken><sec:Integrity><sec:MessageParts Dialect="http://schemas.xmlsoap.org/ws/2002/12/wsse#soap" >wsp:Body()</sec:MessageParts></sec:Integrity><sec:SecurityHeader MustPrepend="true" MustManifestEncryption="true" /></wsp:All></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test13.xml b/neethi/src/samples/test13.xml
new file mode 100644
index 0000000..7817caf
--- /dev/null
+++ b/neethi/src/samples/test13.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1H --><wsp:All><wsp:Policy /></wsp:All></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test14.xml b/neethi/src/samples/test14.xml
new file mode 100644
index 0000000..00dcab5
--- /dev/null
+++ b/neethi/src/samples/test14.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1I --><wsp:All><wsp:All /></wsp:All></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test15.xml b/neethi/src/samples/test15.xml
new file mode 100644
index 0000000..d8b2e20
--- /dev/null
+++ b/neethi/src/samples/test15.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1J --><wsp:All><wsp:ExactlyOne /></wsp:All></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test16.xml b/neethi/src/samples/test16.xml
new file mode 100644
index 0000000..7304862
--- /dev/null
+++ b/neethi/src/samples/test16.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1K --><wsp:ExactlyOne /></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test17.xml b/neethi/src/samples/test17.xml
new file mode 100644
index 0000000..fc995b1
--- /dev/null
+++ b/neethi/src/samples/test17.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext" ><!-- 1L --><wsp:ExactlyOne><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken><sec:SecurityToken><sec:TokenType>sec:Kerberosv5TGT</sec:TokenType></sec:SecurityToken><sec:SecurityToken><sec:TokenType>sec:Kerberosv5ST</sec:TokenType></sec:SecurityToken></wsp:ExactlyOne></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test18.xml b/neethi/src/samples/test18.xml
new file mode 100644
index 0000000..0c6f9dc
--- /dev/null
+++ b/neethi/src/samples/test18.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><wsp:ExactlyOne><wsp:Policy /></wsp:ExactlyOne></wsp:Policy>
diff --git a/neethi/src/samples/test19.xml b/neethi/src/samples/test19.xml
new file mode 100644
index 0000000..243054a
--- /dev/null
+++ b/neethi/src/samples/test19.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1N --><wsp:ExactlyOne><wsp:All /></wsp:ExactlyOne></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test2.xml b/neethi/src/samples/test2.xml
new file mode 100644
index 0000000..13d7a1b
--- /dev/null
+++ b/neethi/src/samples/test2.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"><wsp:ExactlyOne><wsp:All /></wsp:ExactlyOne></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test20.xml b/neethi/src/samples/test20.xml
new file mode 100644
index 0000000..be83fae
--- /dev/null
+++ b/neethi/src/samples/test20.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><wsp:ExactlyOne><wsp:ExactlyOne /></wsp:ExactlyOne></wsp:Policy>
diff --git a/neethi/src/samples/test21.xml b/neethi/src/samples/test21.xml
new file mode 100644
index 0000000..aecc311
--- /dev/null
+++ b/neethi/src/samples/test21.xml
@@ -0,0 +1,10 @@
+
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext"><!-- 2 -->
+	<sec:SecurityToken>
+		<sec:TokenType>sec:X509v3</sec:TokenType>
+	</sec:SecurityToken>
+	<sec:SecurityHeader wsp:Optional="true" MustPrepend="true" MustManifestEncryption="true"/>
+	<sec:Integrity wsp:Optional="false">
+		<sec:MessageParts Dialect="http://schemas.xmlsoap.org/ws/2002/12/wsse#soap">wsp:Body()</sec:MessageParts>
+	</sec:Integrity>
+</wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test22.xml b/neethi/src/samples/test22.xml
new file mode 100644
index 0000000..8942352
--- /dev/null
+++ b/neethi/src/samples/test22.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext"><!-- 2A --><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test23.xml b/neethi/src/samples/test23.xml
new file mode 100644
index 0000000..e0c1bf8
--- /dev/null
+++ b/neethi/src/samples/test23.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext"><!-- 2B --><sec:SecurityHeader wsp:Optional="true" MustPrepend="true" MustManifestEncryption="true" /></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test24.xml b/neethi/src/samples/test24.xml
new file mode 100644
index 0000000..2aa5b09
--- /dev/null
+++ b/neethi/src/samples/test24.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext"><!-- 2C --><sec:Integrity wsp:Optional="false"><sec:MessageParts Dialect="http://schemas.xmlsoap.org/ws/2002/12/wsse#soap" >wsp:Body()</sec:MessageParts></sec:Integrity></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test25.xml b/neethi/src/samples/test25.xml
new file mode 100644
index 0000000..378051d
--- /dev/null
+++ b/neethi/src/samples/test25.xml
@@ -0,0 +1,7 @@
+<wsp:Policy 

+	xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" 

+	xmlns:tst="http://sample.org/Assertions">

+  <tst:A wsp:Optional="true">A</tst:A>

+  <tst:B wsp:Optional="true">B</tst:B>

+  <tst:C wsp:Optional="true">C</tst:C>  

+</wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test3.xml b/neethi/src/samples/test3.xml
new file mode 100644
index 0000000..a3bc427
--- /dev/null
+++ b/neethi/src/samples/test3.xml
@@ -0,0 +1,20 @@
+
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sec:SecurityToken>
+				<sec:TokenType>sec:X509v3</sec:TokenType>
+			</sec:SecurityToken>
+		</wsp:All>
+		<wsp:All>
+			<sec:SecurityToken>
+				<sec:TokenType>sec:X509v3</sec:TokenType>
+			</sec:SecurityToken>
+		</wsp:All>
+		<wsp:All>
+			<sec:SecurityToken>
+				<sec:TokenType>sec:Kerberosv5TGT</sec:TokenType>
+			</sec:SecurityToken>
+		</wsp:All>
+	</wsp:ExactlyOne>
+</wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test4.xml b/neethi/src/samples/test4.xml
new file mode 100644
index 0000000..a6af9f4
--- /dev/null
+++ b/neethi/src/samples/test4.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext"><wsp:ExactlyOne><wsp:All><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken></wsp:All><wsp:All><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken><sec:SecurityHeader MustPrepend="true" /></wsp:All></wsp:ExactlyOne></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test5.xml b/neethi/src/samples/test5.xml
new file mode 100644
index 0000000..7c72aff
--- /dev/null
+++ b/neethi/src/samples/test5.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext"><wsp:ExactlyOne><wsp:All><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken><sec:SecurityHeader MustPrepend="true" /></wsp:All><wsp:All><sec:SecurityToken><sec:TokenType>sec:Kerberosv5TGT</sec:TokenType></sec:SecurityToken><sec:SecurityHeader MustPrepend="true" /></wsp:All></wsp:ExactlyOne></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test6.xml b/neethi/src/samples/test6.xml
new file mode 100644
index 0000000..4003b62
--- /dev/null
+++ b/neethi/src/samples/test6.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1A --></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test7.xml b/neethi/src/samples/test7.xml
new file mode 100644
index 0000000..cee2f03
--- /dev/null
+++ b/neethi/src/samples/test7.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:sec="http://schemas.xmlsoap.org/ws/2002/12/secext"><!-- 1B --><sec:SecurityToken><sec:TokenType>sec:X509v3</sec:TokenType></sec:SecurityToken><sec:Integrity><sec:MessageParts Dialect="http://schemas.xmlsoap.org/ws/2002/12/wsse#soap" >wsp:Body()</sec:MessageParts></sec:Integrity><sec:SecurityHeader MustPrepend="true" MustManifestEncryption="true" /></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test8.xml b/neethi/src/samples/test8.xml
new file mode 100644
index 0000000..31d9377
--- /dev/null
+++ b/neethi/src/samples/test8.xml
@@ -0,0 +1,4 @@
+
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"><!-- 1C -->
+	<wsp:Policy />
+</wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/samples/test9.xml b/neethi/src/samples/test9.xml
new file mode 100644
index 0000000..9f57428
--- /dev/null
+++ b/neethi/src/samples/test9.xml
@@ -0,0 +1 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" ><!-- 1D --><wsp:All /></wsp:Policy>
\ No newline at end of file
diff --git a/neethi/src/secpolicy/Makefile.am b/neethi/src/secpolicy/Makefile.am
new file mode 100644
index 0000000..28fd650
--- /dev/null
+++ b/neethi/src/secpolicy/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = model builder 
diff --git a/neethi/src/secpolicy/builder/Makefile.am b/neethi/src/secpolicy/builder/Makefile.am
new file mode 100644
index 0000000..d189e16
--- /dev/null
+++ b/neethi/src/secpolicy/builder/Makefile.am
@@ -0,0 +1,25 @@
+TESTS =
+
+noinst_LTLIBRARIES = librp_builder.la
+
+librp_builder_la_SOURCES = algorithmsuite_builder.c \
+						   layout_builder.c \
+						   supporting_tokens_builder.c \
+						   transport_binding_builder.c username_token_builder.c \
+						   wss10_builder.c transport_token_builder.c \
+						   token_identifier.c https_token_builder.c rampart_config_builder.c \
+						   asymmetric_binding_builder.c x509_token_builder.c initiator_token_builder.c \
+						   recipient_token_builder.c signed_encrypted_parts_builder.c secpolicy_builder.c \
+						   symmetric_binding_builder.c protection_token_builder.c signature_token_builder.c \
+						   encryption_token_builder.c wss11_builder.c trust10_builder.c \
+						   bootstrap_policy_builder.c security_context_token_builder.c \
+						   issued_token_builder.c saml_token_builder.c
+
+librp_builder_la_LIBADD  = ../../../../axiom/src/om/libaxis2_axiom.la \
+				../../../../util/src/libaxutil.la
+
+INCLUDES = -I$(top_builddir)/include \
+			-I ../../../include \
+			-I ../../../../util/include \
+            -I ../../../../axiom/include \
+            -I ../../../../include
diff --git a/neethi/src/secpolicy/builder/algorithmsuite_builder.c b/neethi/src/secpolicy/builder/algorithmsuite_builder.c
new file mode 100644
index 0000000..3f42baf
--- /dev/null
+++ b/neethi/src/secpolicy/builder/algorithmsuite_builder.c
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_algorithmsuite_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+rp_algorithmsuite_builder_build(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    rp_algorithmsuite_t *algorithmsuite = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_node_t *algo_node = NULL;
+    axiom_element_t *algo_element = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    algorithmsuite = rp_algorithmsuite_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+
+    if(child_node)
+    {
+        algo_node = axiom_node_get_first_element(child_node, env);
+        if(!algo_node)
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(algo_node, env) == AXIOM_ELEMENT)
+    {
+        algo_element = (axiom_element_t *)axiom_node_get_data_element(algo_node, env);
+        if(algo_element)
+        {
+            axis2_status_t status = AXIS2_FAILURE;
+            axis2_char_t *algosuite_string = NULL;
+
+            algosuite_string = axiom_element_get_localname(algo_element, env);
+            if(!algosuite_string)
+            {
+                return NULL;
+            }
+            status = rp_algorithmsuite_set_algosuite(algorithmsuite, env, algosuite_string);
+            if(AXIS2_FAILURE == status)
+            {
+                return NULL;
+            }
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_algorithmsuite_free, algorithmsuite,
+                ASSERTION_TYPE_ALGORITHM_SUITE);
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
diff --git a/neethi/src/secpolicy/builder/asymmetric_binding_builder.c b/neethi/src/secpolicy/builder/asymmetric_binding_builder.c
new file mode 100644
index 0000000..3a2f889
--- /dev/null
+++ b/neethi/src/secpolicy/builder/asymmetric_binding_builder.c
@@ -0,0 +1,234 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_asymmetric_binding_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+asymmetric_binding_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_asymmetric_binding_t *asymmetric_binding);
+
+/***********************************/
+
+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)
+{
+    rp_asymmetric_binding_t *asymmetric_binding = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    asymmetric_binding = rp_asymmetric_binding_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            asymmetric_binding_process_alternatives(env, all, asymmetric_binding);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_asymmetric_binding_free, asymmetric_binding,
+                ASSERTION_TYPE_ASSYMMETRIC_BINDING);
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+asymmetric_binding_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_asymmetric_binding_t * asymmetric_binding)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+    rp_binding_commons_t *commons = NULL;
+    rp_symmetric_asymmetric_binding_commons_t *as_commons = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+    commons = rp_binding_commons_create(env);
+    as_commons = rp_symmetric_asymmetric_binding_commons_create(env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_INITIATOR_TOKEN)
+        {
+            rp_property_t *initiator_token = NULL;
+            initiator_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
+            if(initiator_token)
+            {
+                rp_asymmetric_binding_set_initiator_token(asymmetric_binding, env, initiator_token);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_RECIPIENT_TOKEN)
+        {
+            rp_property_t *recipient_token = NULL;
+            recipient_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
+            if(recipient_token)
+            {
+                rp_asymmetric_binding_set_recipient_token(asymmetric_binding, env, recipient_token);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_ALGORITHM_SUITE)
+        {
+            rp_algorithmsuite_t *algorithmsuite = NULL;
+            algorithmsuite = (rp_algorithmsuite_t *)neethi_assertion_get_value(assertion, env);
+            if(algorithmsuite)
+            {
+                rp_binding_commons_set_algorithmsuite(commons, env, algorithmsuite);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_INCLUDE_TIMESTAMP)
+        {
+            rp_binding_commons_set_include_timestamp(commons, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_LAYOUT)
+        {
+            rp_layout_t *layout = NULL;
+            layout = (rp_layout_t *)neethi_assertion_get_value(assertion, env);
+            if(layout)
+            {
+                rp_binding_commons_set_layout(commons, env, layout);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_ENCRYPT_BEFORE_SIGNING)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_protection_order(as_commons, env,
+                RP_ENCRYPT_BEFORE_SIGNING);
+        }
+        else if(type == ASSERTION_TYPE_SIGN_BEFORE_ENCRYPTING)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_protection_order(as_commons, env,
+                RP_SIGN_BEFORE_ENCRYPTING);
+        }
+        else if(type == ASSERTION_TYPE_ENCRYPT_SIGNATURE)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_signature_protection(as_commons, env,
+                AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_PROTECT_TOKENS)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_token_protection(as_commons, env,
+                AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_ONLY_SIGN_ENTIRE_HEADERS_AND_BODY)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_entire_headers_and_body_signatures(
+                as_commons, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_SUPPORTING_TOKENS)
+        {
+            rp_supporting_tokens_t *supporting_tokens = NULL;
+            supporting_tokens
+                = (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion, env);
+            if(supporting_tokens)
+            {
+                rp_property_type_t type;
+                type = rp_supporting_tokens_get_type(supporting_tokens, env);
+                if(type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_signed_supporting_tokens(commons, env, supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_signed_endorsing_supporting_tokens(commons, env,
+                        supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_supporting_tokens(commons, env, supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_endorsing_supporting_tokens(commons, env,
+                        supporting_tokens);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    rp_symmetric_asymmetric_binding_commons_set_binding_commons(as_commons, env, commons);
+    rp_asymmetric_binding_set_symmetric_asymmetric_binding_commons(asymmetric_binding, env,
+        as_commons);
+
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/bootstrap_policy_builder.c b/neethi/src/secpolicy/builder/bootstrap_policy_builder.c
new file mode 100644
index 0000000..df8c23e
--- /dev/null
+++ b/neethi/src/secpolicy/builder/bootstrap_policy_builder.c
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_bootstrap_policy_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+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)
+{
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            assertion = neethi_assertion_create_with_args(env, NULL, /*this policy should not be deleted*/
+            policy, ASSERTION_TYPE_BOOTSTRAP_POLICY);
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
diff --git a/neethi/src/secpolicy/builder/encryption_token_builder.c b/neethi/src/secpolicy/builder/encryption_token_builder.c
new file mode 100644
index 0000000..5896ac3
--- /dev/null
+++ b/neethi/src/secpolicy/builder/encryption_token_builder.c
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_encryption_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+encryption_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *encryption_token);
+
+/***********************************/
+
+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)
+{
+    rp_property_t *encryption_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    encryption_token = rp_property_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            encryption_token_process_alternatives(env, all, encryption_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_property_free, encryption_token,
+                ASSERTION_TYPE_ENCRYPTION_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+encryption_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *encryption_token)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_X509_TOKEN)
+            {
+                rp_x509_token_t *x509_token = NULL;
+                x509_token = (rp_x509_token_t *)neethi_assertion_get_value(assertion, env);
+                if(x509_token)
+                {
+                    rp_property_set_value(encryption_token, env, x509_token, RP_PROPERTY_X509_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_ISSUED_TOKEN)
+            {
+                rp_issued_token_t *issued_token = NULL;
+                issued_token = (rp_issued_token_t *)neethi_assertion_get_value(assertion, env);
+                if(issued_token)
+                {
+                    rp_property_set_value(encryption_token, env, issued_token,
+                        RP_PROPERTY_ISSUED_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_SAML_TOKEN)
+            {
+                rp_saml_token_t *saml_token = NULL;
+                saml_token = (rp_saml_token_t *)neethi_assertion_get_value(assertion, env);
+                if(saml_token)
+                {
+                    rp_property_set_value(encryption_token, env, saml_token, RP_PROPERTY_SAML_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_SECURITY_CONTEXT_TOKEN)
+            {
+                rp_security_context_token_t *security_context_token = NULL;
+                security_context_token = (rp_security_context_token_t *)neethi_assertion_get_value(
+                    assertion, env);
+
+                if(security_context_token)
+                {
+                    rp_property_set_value(encryption_token, env, security_context_token,
+                        RP_PROPERTY_SECURITY_CONTEXT_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/https_token_builder.c b/neethi/src/secpolicy/builder/https_token_builder.c
new file mode 100644
index 0000000..9406d19
--- /dev/null
+++ b/neethi/src/secpolicy/builder/https_token_builder.c
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_https_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+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)
+{
+    rp_https_token_t *https_token = NULL;
+    neethi_assertion_t *assertion = NULL;
+    axis2_char_t *value = NULL;
+
+    https_token = rp_https_token_create(env);
+
+    value = axiom_element_get_attribute_value_by_name(element, env, RP_REQUIRE_CLIENT_CERTIFICATE);
+
+    if(value)
+    {
+        if(axutil_strcmp(value, "true") == 0)
+        {
+            rp_https_token_set_require_client_certificate(https_token, env, AXIS2_TRUE);
+        }
+        else if(axutil_strcmp(value, "false") == 0)
+        {
+            rp_https_token_set_require_client_certificate(https_token, env, AXIS2_FALSE);
+        }
+        else
+            return NULL;
+    }
+
+    assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_https_token_free,
+        https_token, ASSERTION_TYPE_HTTPS_TOKEN);
+    return assertion;
+}
diff --git a/neethi/src/secpolicy/builder/initiator_token_builder.c b/neethi/src/secpolicy/builder/initiator_token_builder.c
new file mode 100644
index 0000000..28b6497
--- /dev/null
+++ b/neethi/src/secpolicy/builder/initiator_token_builder.c
@@ -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.
+ */
+
+#include <rp_initiator_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+initiator_token_process_alternatives(
+    const axutil_env_t * env,
+    neethi_all_t * all,
+    rp_property_t * initiator_token);
+
+/***********************************/
+
+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)
+{
+    rp_property_t *initiator_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    initiator_token = rp_property_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            initiator_token_process_alternatives(env, all, initiator_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_property_free, initiator_token,
+                ASSERTION_TYPE_INITIATOR_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+initiator_token_process_alternatives(
+    const axutil_env_t * env,
+    neethi_all_t * all,
+    rp_property_t * initiator_token)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_X509_TOKEN)
+            {
+                rp_x509_token_t *x509_token = NULL;
+                x509_token = (rp_x509_token_t *)neethi_assertion_get_value(assertion, env);
+                if(x509_token)
+                {
+                    rp_property_set_value(initiator_token, env, x509_token, RP_PROPERTY_X509_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/issued_token_builder.c b/neethi/src/secpolicy/builder/issued_token_builder.c
new file mode 100644
index 0000000..2cfc09f
--- /dev/null
+++ b/neethi/src/secpolicy/builder/issued_token_builder.c
@@ -0,0 +1,164 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_issued_token_builder.h>
+
+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)
+{
+    rp_issued_token_t *issued_token = NULL;
+    neethi_policy_t *policy = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+    neethi_all_t *all = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    axis2_char_t *inclusion_value = NULL;
+    axutil_qname_t *qname = NULL;
+    axiom_node_t *issuer_node = NULL;
+    axiom_element_t *issuer_ele = NULL;
+    axiom_element_t *issuer_first_child_ele = NULL;
+    axiom_node_t *issuer_first_child_node = NULL;
+    axiom_node_t *req_sec_tok_template_node = NULL;
+    axiom_element_t *req_sec_tok_template_ele = NULL;
+    axiom_node_t *policy_node = NULL;
+    axiom_element_t *policy_ele = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    issued_token = rp_issued_token_create(env);
+    qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_11, RP_SP_PREFIX);
+    inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+    axutil_qname_free(qname, env);
+    qname = NULL;
+
+    if(!inclusion_value)
+    {
+        /* we can try whether WS-SP1.2 specific inclusion value */
+        qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_12, RP_SP_PREFIX);
+        inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+        axutil_qname_free(qname, env);
+        qname = NULL;
+    }
+
+    if(inclusion_value)
+    {
+        rp_issued_token_set_inclusion(issued_token, env, inclusion_value);
+    }
+
+    qname = axutil_qname_create(env, RP_ISSUER, RP_SP_NS_11, RP_SP_PREFIX);
+    issuer_ele = axiom_element_get_first_child_with_qname(element, env, qname, node, &issuer_node);
+    if(issuer_ele)
+    {
+        issuer_first_child_ele = axiom_element_get_first_element(issuer_ele, env, issuer_node,
+            &issuer_first_child_node);
+        if(issuer_first_child_ele)
+        {
+            rp_issued_token_set_issuer_epr(issued_token, env, issuer_first_child_node);
+        }
+    }
+    axutil_qname_free(qname, env);
+    qname = NULL;
+
+    qname = axutil_qname_create(env, RP_REQUEST_SEC_TOKEN_TEMPLATE, RP_SP_NS_11, RP_SP_PREFIX);
+    req_sec_tok_template_ele = axiom_element_get_first_child_with_qname(element, env, qname, node,
+        &req_sec_tok_template_node);
+    if(req_sec_tok_template_ele)
+    {
+        rp_issued_token_set_requested_sec_token_template(issued_token, env,
+            req_sec_tok_template_node);
+    }
+    else
+    {
+        return NULL;
+    }
+
+    axutil_qname_free(qname, env);
+    qname = NULL;
+
+    qname = axutil_qname_create(env, RP_POLICY, RP_POLICY_NS, RP_POLICY_PREFIX);
+    policy_ele = axiom_element_get_first_child_with_qname(element, env, qname, node, &policy_node);
+    if(policy_ele)
+    {
+        policy = neethi_engine_get_policy(env, policy_node, policy_ele);
+        if(!policy)
+        {
+            return NULL;
+        }
+        normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+        neethi_policy_free(policy, env);
+        policy = NULL;
+        alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+        component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+        all = (neethi_all_t *)neethi_operator_get_value(component, env);
+        if(AXIS2_FAILURE == rp_issued_token_builder_process_alternatives(env, all, issued_token))
+            return NULL;
+        assertion = neethi_assertion_create_with_args(env,
+            (AXIS2_FREE_VOID_ARG)rp_issued_token_free, issued_token, ASSERTION_TYPE_ISSUED_TOKEN);
+
+        neethi_policy_free(normalized_policy, env);
+        normalized_policy = NULL;
+
+        return assertion;
+    }
+
+    assertion = neethi_assertion_create(env);
+    neethi_assertion_set_value(assertion, env, issued_token, ASSERTION_TYPE_ISSUED_TOKEN);
+
+    return assertion;
+}
+
+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)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10)
+        {
+            rp_issued_token_set_derivedkeys(issued_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_EXTERNAL_REFERENCE)
+        {
+            rp_issued_token_set_require_exernal_reference(issued_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_INTERNAL_REFERENCE)
+        {
+            rp_issued_token_set_require_internal_reference(issued_token, env, AXIS2_TRUE);
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
+
diff --git a/neethi/src/secpolicy/builder/layout_builder.c b/neethi/src/secpolicy/builder/layout_builder.c
new file mode 100644
index 0000000..9be9ad9
--- /dev/null
+++ b/neethi/src/secpolicy/builder/layout_builder.c
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_layout_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+rp_layout_builder_build(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    rp_layout_t *layout = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_node_t *layout_node = NULL;
+    axiom_element_t *layout_element = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    layout = rp_layout_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+
+    if(child_node)
+    {
+        layout_node = axiom_node_get_first_element(child_node, env);
+        if(!layout_node)
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(layout_node, env) == AXIOM_ELEMENT)
+    {
+        layout_element = (axiom_element_t *)axiom_node_get_data_element(layout_node, env);
+        if(layout_element)
+        {
+            axis2_char_t *local_name = NULL;
+
+            local_name = axiom_element_get_localname(layout_element, env);
+            if(!local_name)
+                return NULL;
+            rp_layout_set_value(layout, env, local_name);
+            assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_layout_free,
+                layout, ASSERTION_TYPE_LAYOUT);
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
diff --git a/neethi/src/secpolicy/builder/protection_token_builder.c b/neethi/src/secpolicy/builder/protection_token_builder.c
new file mode 100644
index 0000000..8ea02f2
--- /dev/null
+++ b/neethi/src/secpolicy/builder/protection_token_builder.c
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_protection_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+protection_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *protection_token);
+
+/***********************************/
+
+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)
+{
+    rp_property_t *protection_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    protection_token = rp_property_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            protection_token_process_alternatives(env, all, protection_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_property_free, protection_token,
+                ASSERTION_TYPE_PROTECTION_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+protection_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *protection_token)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_X509_TOKEN)
+            {
+                rp_x509_token_t *x509_token = NULL;
+                x509_token = (rp_x509_token_t *)neethi_assertion_get_value(assertion, env);
+                if(x509_token)
+                {
+                    rp_property_set_value(protection_token, env, x509_token, RP_PROPERTY_X509_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_ISSUED_TOKEN)
+            {
+                rp_issued_token_t *issued_token = NULL;
+                issued_token = (rp_issued_token_t *)neethi_assertion_get_value(assertion, env);
+                if(issued_token)
+                {
+                    rp_property_set_value(protection_token, env, issued_token,
+                        RP_PROPERTY_ISSUED_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_SAML_TOKEN)
+            {
+                rp_saml_token_t *saml_token = NULL;
+                saml_token = (rp_saml_token_t *)neethi_assertion_get_value(assertion, env);
+                if(saml_token)
+                {
+                    rp_property_set_value(protection_token, env, saml_token, RP_PROPERTY_SAML_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_SECURITY_CONTEXT_TOKEN)
+            {
+                rp_security_context_token_t *security_context_token = NULL;
+                security_context_token = (rp_security_context_token_t *)neethi_assertion_get_value(
+                    assertion, env);
+
+                if(security_context_token)
+                {
+                    rp_property_set_value(protection_token, env, security_context_token,
+                        RP_PROPERTY_SECURITY_CONTEXT_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/rampart_config_builder.c b/neethi/src/secpolicy/builder/rampart_config_builder.c
new file mode 100644
index 0000000..1c569b3
--- /dev/null
+++ b/neethi/src/secpolicy/builder/rampart_config_builder.c
@@ -0,0 +1,213 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_rampart_config_builder.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+rp_rampart_config_builder_populate(
+    const axutil_env_t *env,
+    rp_rampart_config_t *rampart_config,
+    axiom_node_t *node,
+    axiom_element_t *element,
+    axis2_char_t *local_name);
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+rp_rampart_config_builder_build(
+    const axutil_env_t *env,
+    axiom_node_t *config,
+    axiom_element_t *config_ele)
+{
+    rp_rampart_config_t *rampart_config = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+    axiom_children_iterator_t *children_iter = NULL;
+    neethi_assertion_t *assertion = NULL;
+
+    rampart_config = rp_rampart_config_create(env);
+    if(!rampart_config)
+    {
+        return NULL;
+    }
+
+    children_iter = axiom_element_get_children(config_ele, env, config);
+    if(children_iter)
+    {
+        while(axiom_children_iterator_has_next(children_iter, env))
+        {
+            axiom_node_t *node = NULL;
+            axiom_element_t *ele = NULL;
+            axis2_char_t *local_name = NULL;
+            node = axiom_children_iterator_next(children_iter, env);
+            if(node)
+            {
+                if(axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
+                {
+                    ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+                    if(ele)
+                    {
+                        local_name = axiom_element_get_localname(ele, env);
+                        if(local_name)
+                        {
+                            status = rp_rampart_config_builder_populate(env, rampart_config, node,
+                                ele, local_name);
+                            if(status != AXIS2_SUCCESS)
+                            {
+                                return NULL;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_rampart_config_free,
+        rampart_config, ASSERTION_TYPE_RAMPART_CONFIG);
+    return assertion;
+}
+
+axis2_status_t AXIS2_CALL
+rp_rampart_config_builder_populate(
+    const axutil_env_t *env,
+    rp_rampart_config_t *rampart_config,
+    axiom_node_t *node,
+    axiom_element_t *element,
+    axis2_char_t *local_name)
+{
+    axis2_char_t *ns = NULL;
+    axutil_qname_t *node_qname = NULL;
+
+    node_qname = axiom_element_get_qname(element, env, node);
+    if(!node_qname)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get qname from element %s.",
+            local_name);
+        return AXIS2_FAILURE;
+    }
+
+    ns = axutil_qname_get_uri(node_qname, env);
+    if(!ns)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get namespace from element %s.",
+            local_name);
+        return AXIS2_FAILURE;
+    }
+
+    if(!axutil_strcmp(ns, RP_RAMPART_NS))
+    {
+        if(!axutil_strcmp(local_name, RP_USER))
+        {
+            axis2_char_t *user = NULL;
+            user = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_user(rampart_config, env, user);
+        }
+        else if(!axutil_strcmp(local_name, RP_ENCRYPTION_USER))
+        {
+            axis2_char_t *encryption_user = NULL;
+            encryption_user = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_encryption_user(rampart_config, env, encryption_user);
+        }
+        else if(!axutil_strcmp(local_name, RP_PASSWORD_CALLBACK_CLASS))
+        {
+            axis2_char_t *password_callback_class = NULL;
+            password_callback_class = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_password_callback_class(rampart_config, env,
+                password_callback_class);
+        }
+        else if(!axutil_strcmp(local_name, RP_AUTHN_MODULE_NAME))
+        {
+            axis2_char_t *authenticate_module = NULL;
+            authenticate_module = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_authenticate_module(rampart_config, env,
+                authenticate_module);
+        }
+        else if(!axutil_strcmp(local_name, RP_RD_MODULE))
+        {
+            axis2_char_t *replay_detector = NULL;
+            replay_detector = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_replay_detector(rampart_config, env, replay_detector);
+        }
+        else if(!axutil_strcmp(local_name, RP_SCT_MODULE))
+        {
+            axis2_char_t *sct_module = NULL;
+            sct_module = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_sct_provider(rampart_config, env, sct_module);
+        }
+        else if(!axutil_strcmp(local_name, RP_PASSWORD_TYPE))
+        {
+            axis2_char_t *password_type = NULL;
+            password_type = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_password_type(rampart_config, env, password_type);
+        }
+        else if(!axutil_strcmp(local_name, RP_CERTIFICATE))
+        {
+            axis2_char_t *certificate_file = NULL;
+            certificate_file = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_certificate_file(rampart_config, env, certificate_file);
+        }
+        else if(!axutil_strcmp(local_name, RP_RECEIVER_CERTIFICATE))
+        {
+            axis2_char_t *receiver_certificate_file = NULL;
+            receiver_certificate_file = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_receiver_certificate_file(rampart_config, env,
+                receiver_certificate_file);
+        }
+        else if(!axutil_strcmp(local_name, RP_PRIVATE_KEY))
+        {
+            axis2_char_t *private_key_file = NULL;
+            private_key_file = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_private_key_file(rampart_config, env, private_key_file);
+        }
+        else if(!axutil_strcmp(local_name, RP_PKCS12_KEY_STORE))
+        {
+            axis2_char_t *pkcs12_key_store = NULL;
+            pkcs12_key_store = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_pkcs12_file(rampart_config, env, pkcs12_key_store);
+        }
+        else if(!axutil_strcmp(local_name, RP_TIME_TO_LIVE))
+        {
+            axis2_char_t *time_to_live = NULL;
+            time_to_live = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_time_to_live(rampart_config, env, time_to_live);
+        }
+        else if(!axutil_strcmp(local_name, RP_CLOCK_SKEW_BUFFER))
+        {
+            axis2_char_t *clock_skew_buffer = NULL;
+            clock_skew_buffer = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_clock_skew_buffer(rampart_config, env, clock_skew_buffer);
+        }
+        else if(!axutil_strcmp(local_name, RP_NEED_MILLISECOND_PRECISION))
+        {
+            axis2_char_t *need_ms_precision = NULL;
+            need_ms_precision = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_need_millisecond_precision(rampart_config, env,
+                need_ms_precision);
+        }
+        else if(!axutil_strcmp(local_name, RP_RD))
+        {
+            axis2_char_t *rd_val = NULL;
+            rd_val = axiom_element_get_text(element, env, node);
+            return rp_rampart_config_set_rd_val(rampart_config, env, rd_val);
+        }
+    }
+
+    /* either the assertion or the namespace is not identified */
+    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Unknown Assertion %s with namespace %s",
+        local_name, ns);
+    return AXIS2_FAILURE;
+
+}
diff --git a/neethi/src/secpolicy/builder/recipient_token_builder.c b/neethi/src/secpolicy/builder/recipient_token_builder.c
new file mode 100644
index 0000000..d29537d
--- /dev/null
+++ b/neethi/src/secpolicy/builder/recipient_token_builder.c
@@ -0,0 +1,139 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_recipient_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+recipient_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *recipient_token);
+
+/***********************************/
+
+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)
+{
+    rp_property_t *recipient_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    recipient_token = rp_property_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            recipient_token_process_alternatives(env, all, recipient_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_property_free, recipient_token,
+                ASSERTION_TYPE_RECIPIENT_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+recipient_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *recipient_token)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_X509_TOKEN)
+            {
+                rp_x509_token_t *x509_token = NULL;
+                x509_token = (rp_x509_token_t *)neethi_assertion_get_value(assertion, env);
+                if(x509_token)
+                {
+                    rp_property_set_value(recipient_token, env, x509_token, RP_PROPERTY_X509_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/saml_token_builder.c b/neethi/src/secpolicy/builder/saml_token_builder.c
new file mode 100644
index 0000000..6550d80
--- /dev/null
+++ b/neethi/src/secpolicy/builder/saml_token_builder.c
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_saml_token_builder.h>
+
+axis2_status_t AXIS2_CALL
+saml_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_saml_token_t *saml_token);
+
+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)
+{
+    rp_saml_token_t *saml_token = NULL;
+    axis2_char_t *inclusion_value = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    axutil_qname_t *qname = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    saml_token = rp_saml_token_create(env);
+    qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_11, RP_SP_PREFIX);
+    inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+    axutil_qname_free(qname, env);
+    qname = NULL;
+
+    if(!inclusion_value)
+    {
+        /* we can try whether WS-SP1.2 specific inclusion value */
+        qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_12, RP_SP_PREFIX);
+        inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+        axutil_qname_free(qname, env);
+        qname = NULL;
+    }
+
+    rp_saml_token_set_inclusion(saml_token, env, inclusion_value);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        assertion = neethi_assertion_create(env);
+        neethi_assertion_set_value(assertion, env, saml_token, ASSERTION_TYPE_SAML_TOKEN);
+        return assertion;
+    }
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            saml_token_process_alternatives(env, all, saml_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_saml_token_free, saml_token, ASSERTION_TYPE_SAML_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+saml_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_saml_token_t *saml_token)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10)
+        {
+            rp_saml_token_set_derivedkeys(saml_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_KEY_IDENTIFIRE_REFERENCE)
+        {
+            rp_saml_token_set_require_key_identifier_reference(saml_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_WSS_SAML_V10_TOKEN_V10)
+        {
+            rp_saml_token_set_token_version_and_type(saml_token, env, RP_WSS_SAML_V10_TOKEN_V10);
+        }
+        else if(type == ASSERTION_TYPE_WSS_SAML_V10_TOKEN_V11)
+        {
+            rp_saml_token_set_token_version_and_type(saml_token, env, RP_WSS_SAML_V10_TOKEN_V11);
+        }
+        else if(type == ASSERTION_TYPE_WSS_SAML_V11_TOKEN_V10)
+        {
+            rp_saml_token_set_token_version_and_type(saml_token, env, RP_WSS_SAML_V11_TOKEN_V10);
+        }
+        else if(type == ASSERTION_TYPE_WSS_SAML_V11_TOKEN_V11)
+        {
+            rp_saml_token_set_token_version_and_type(saml_token, env, RP_WSS_SAML_V11_TOKEN_V11);
+        }
+        else if(type == ASSERTION_TYPE_WSS_SAML_V20_TOKEN_V11)
+        {
+            rp_saml_token_set_token_version_and_type(saml_token, env, RP_WSS_SAML_V20_TOKEN_V11);
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
+
diff --git a/neethi/src/secpolicy/builder/secpolicy_builder.c b/neethi/src/secpolicy/builder/secpolicy_builder.c
new file mode 100644
index 0000000..8548403
--- /dev/null
+++ b/neethi/src/secpolicy/builder/secpolicy_builder.c
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_secpolicy_builder.h>
+#include <neethi_operator.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+#include <neethi_assertion.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+secpolicy_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_secpolicy_t *secpolicy);
+
+/***********************************/
+
+AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL
+rp_secpolicy_builder_build(
+    const axutil_env_t *env,
+    neethi_policy_t *policy)
+{
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    rp_secpolicy_t *secpolicy = NULL;
+
+    secpolicy = rp_secpolicy_create(env);
+
+    alternatives = neethi_policy_get_alternatives(policy, env);
+
+    component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+    all = (neethi_all_t *)neethi_operator_get_value(component, env);
+
+    if(secpolicy_process_alternatives(env, all, secpolicy) == AXIS2_FAILURE)
+    {
+        return NULL;
+    }
+    return secpolicy;
+}
+
+axis2_status_t AXIS2_CALL
+secpolicy_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_secpolicy_t *secpolicy)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_TRANSPORT_BINDING)
+            {
+                rp_property_t *binding = NULL;
+                rp_transport_binding_t *transport_binding = NULL;
+
+                transport_binding = (rp_transport_binding_t *)neethi_assertion_get_value(assertion,
+                    env);
+                if(!transport_binding)
+                {
+                    return AXIS2_FAILURE;
+                }
+                binding = rp_property_create(env);
+                rp_property_set_value(binding, env, transport_binding,
+                    RP_PROPERTY_TRANSPORT_BINDING);
+                rp_secpolicy_set_binding(secpolicy, env, binding);
+            }
+            else if(type == ASSERTION_TYPE_ASSYMMETRIC_BINDING)
+            {
+                rp_property_t *binding = NULL;
+                rp_asymmetric_binding_t *asymmetric_binding = NULL;
+
+                asymmetric_binding = (rp_asymmetric_binding_t *)neethi_assertion_get_value(
+                    assertion, env);
+                if(!asymmetric_binding)
+                {
+                    return AXIS2_FAILURE;
+                }
+                binding = rp_property_create(env);
+                rp_property_set_value(binding, env, asymmetric_binding,
+                    RP_PROPERTY_ASYMMETRIC_BINDING);
+                rp_secpolicy_set_binding(secpolicy, env, binding);
+            }
+            else if(type == ASSERTION_TYPE_SYMMETRIC_BINDING)
+            {
+                rp_property_t *binding = NULL;
+                rp_symmetric_binding_t *symmetric_binding = NULL;
+
+                symmetric_binding = (rp_symmetric_binding_t *)neethi_assertion_get_value(assertion,
+                    env);
+                if(!symmetric_binding)
+                {
+                    return AXIS2_FAILURE;
+                }
+                binding = rp_property_create(env);
+                rp_property_set_value(binding, env, symmetric_binding,
+                    RP_PROPERTY_SYMMETRIC_BINDING);
+                rp_secpolicy_set_binding(secpolicy, env, binding);
+            }
+            else if(type == ASSERTION_TYPE_SUPPORTING_TOKENS)
+            {
+                rp_supporting_tokens_t *supporting_tokens = NULL;
+                supporting_tokens = (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion,
+                    env);
+                if(supporting_tokens)
+                {
+                    rp_property_type_t type;
+                    type = rp_supporting_tokens_get_type(supporting_tokens, env);
+                    if(type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
+                    {
+                        rp_secpolicy_set_signed_supporting_tokens(secpolicy, env, supporting_tokens);
+                    }
+                    else if(type == RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
+                    {
+                        rp_secpolicy_set_signed_endorsing_supporting_tokens(secpolicy, env,
+                            supporting_tokens);
+                    }
+                    else if(type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
+                    {
+                        rp_secpolicy_set_supporting_tokens(secpolicy, env, supporting_tokens);
+                    }
+                    else if(type == RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
+                    {
+                        rp_secpolicy_set_endorsing_supporting_tokens(secpolicy, env,
+                            supporting_tokens);
+                    }
+                    else
+                        return AXIS2_FAILURE;
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_WSS10)
+            {
+                rp_wss10_t *wss10 = NULL;
+                rp_property_t *wss = NULL;
+                wss10 = (rp_wss10_t *)neethi_assertion_get_value(assertion, env);
+                if(!wss10)
+                {
+                    return AXIS2_FAILURE;
+                }
+                wss = rp_property_create(env);
+                rp_property_set_value(wss, env, wss10, RP_PROPERTY_WSS10);
+                rp_secpolicy_set_wss(secpolicy, env, wss);
+            }
+            else if(type == ASSERTION_TYPE_WSS11)
+            {
+                rp_wss11_t *wss11 = NULL;
+                rp_property_t *wss = NULL;
+                wss11 = (rp_wss11_t *)neethi_assertion_get_value(assertion, env);
+                if(!wss11)
+                {
+                    return AXIS2_FAILURE;
+                }
+                wss = rp_property_create(env);
+                rp_property_set_value(wss, env, wss11, RP_PROPERTY_WSS11);
+                rp_secpolicy_set_wss(secpolicy, env, wss);
+            }
+            else if(type == ASSERTION_TYPE_TRUST10)
+            {
+                rp_trust10_t *trust10 = NULL;
+                trust10 = (rp_trust10_t *)neethi_assertion_get_value(assertion, env);
+                if(!trust10)
+                {
+                    return AXIS2_FAILURE;
+                }
+                rp_secpolicy_set_trust10(secpolicy, env, trust10);
+            }
+            else if(type == ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS)
+            {
+                rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
+                signed_encrypted_parts = (rp_signed_encrypted_parts_t *)neethi_assertion_get_value(
+                    assertion, env);
+                if(signed_encrypted_parts)
+                {
+                    if(rp_signed_encrypted_parts_get_signedparts(signed_encrypted_parts, env))
+                    {
+                        rp_secpolicy_set_signed_parts(secpolicy, env, signed_encrypted_parts);
+                    }
+                    else
+                    {
+                        rp_secpolicy_set_encrypted_parts(secpolicy, env, signed_encrypted_parts);
+                    }
+                }
+                else
+                    return AXIS2_FAILURE;
+
+            }
+            else if(type == ASSERTION_TYPE_RAMPART_CONFIG)
+            {
+                rp_rampart_config_t *rampart_config = NULL;
+                rampart_config = (rp_rampart_config_t *)neethi_assertion_get_value(assertion, env);
+                if(!rampart_config)
+                {
+                    return AXIS2_FAILURE;
+                }
+                rp_secpolicy_set_rampart_config(secpolicy, env, rampart_config);
+            }
+            else
+            {
+                continue;
+            }
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/security_context_token_builder.c b/neethi/src/secpolicy/builder/security_context_token_builder.c
new file mode 100644
index 0000000..b4ad8e8
--- /dev/null
+++ b/neethi/src/secpolicy/builder/security_context_token_builder.c
@@ -0,0 +1,231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_security_context_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+security_context_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_security_context_token_t * security_context_token);
+
+/***********************************/
+
+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)
+{
+    rp_security_context_token_t *security_context_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axiom_children_iterator_t *children_iter = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    axis2_char_t *inclusion_value = NULL;
+    axutil_qname_t *qname = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    security_context_token = rp_security_context_token_create(env);
+    qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, sp_ns_uri, RP_SP_PREFIX);
+    inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+    axutil_qname_free(qname, env);
+    qname = NULL;
+
+    rp_security_context_token_set_inclusion(security_context_token, env, inclusion_value);
+    rp_security_context_token_set_is_secure_conversation_token(security_context_token, env,
+        is_secure_conversation_token);
+
+    if(!axutil_strcmp(sp_ns_uri, RP_SP_NS_11))
+    {
+        rp_security_context_token_set_sc10_security_context_token(security_context_token, env,
+            AXIS2_TRUE);
+    }
+    else
+    {
+        rp_security_context_token_set_sc10_security_context_token(security_context_token, env,
+            AXIS2_FALSE);
+    }
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    children_iter = axiom_element_get_children(element, env, node);
+    if(children_iter)
+    {
+        while(axiom_children_iterator_has_next(children_iter, env))
+        {
+            child_node = axiom_children_iterator_next(children_iter, env);
+            if(child_node)
+            {
+                if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+                {
+                    child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+                    if(child_element)
+                    {
+                        axis2_char_t *localname = NULL;
+                        localname = axiom_element_get_localname(child_element, env);
+                        if(axutil_strcmp(localname, RP_ISSUER) == 0)
+                        {
+                            axis2_char_t *ns = NULL;
+                            axutil_qname_t *node_qname = NULL;
+
+                            node_qname = axiom_element_get_qname(child_element, env, child_node);
+                            if(!node_qname)
+                            {
+                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                    "[neethi] Cannot get qname from element %s.", localname);
+                                return NULL;
+                            }
+
+                            ns = axutil_qname_get_uri(node_qname, env);
+                            if(!ns)
+                            {
+                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                    "[neethi] Cannot get namespace from element %s.", localname);
+                                return NULL;
+                            }
+                            if(!(axutil_strcmp(ns, RP_SP_NS_11) && axutil_strcmp(ns, RP_SP_NS_12)))
+                            {
+                                axis2_char_t *issuer = NULL;
+                                issuer = axiom_element_get_text(child_element, env, child_node);
+                                rp_security_context_token_set_issuer(security_context_token, env,
+                                    issuer);
+                            }
+                            else
+                            {
+                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                    "[neethi] Unknown Assertion %s with namespace %s", localname,
+                                    ns);
+                                return NULL;
+                            }
+                        }
+                        else
+                        {
+                            policy = neethi_engine_get_policy(env, child_node, child_element);
+                            if(!policy)
+                            {
+                                return NULL;
+                            }
+                            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE,
+                                policy);
+                            neethi_policy_free(policy, env);
+                            policy = NULL;
+                            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+                            component = (neethi_operator_t *)axutil_array_list_get(alternatives,
+                                env, 0);
+                            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+                            security_context_token_process_alternatives(env, all,
+                                security_context_token);
+
+                            assertion = neethi_assertion_create_with_args(env,
+                                (AXIS2_FREE_VOID_ARG)rp_security_context_token_free,
+                                security_context_token, ASSERTION_TYPE_SECURITY_CONTEXT_TOKEN);
+
+                            neethi_policy_free(normalized_policy, env);
+                            normalized_policy = NULL;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return assertion;
+}
+
+axis2_status_t AXIS2_CALL
+security_context_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_security_context_token_t * security_context_token)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10)
+        {
+            rp_security_context_token_set_derivedkey(security_context_token, env, DERIVEKEY_NEEDED);
+            rp_security_context_token_set_derivedkey_version(security_context_token, env,
+                DERIVEKEY_VERSION_SC10);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC13)
+        {
+            rp_security_context_token_set_derivedkey(security_context_token, env, DERIVEKEY_NEEDED);
+            rp_security_context_token_set_derivedkey_version(security_context_token, env,
+                DERIVEKEY_VERSION_SC13);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_EXTERNAL_URI)
+        {
+            rp_security_context_token_set_require_external_uri_ref(security_context_token, env,
+                AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_SC10_SECURITY_CONTEXT_TOKEN)
+        {
+            rp_security_context_token_set_sc10_security_context_token(security_context_token, env,
+                AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_SC13_SECURITY_CONTEXT_TOKEN)
+        {
+            rp_security_context_token_set_sc10_security_context_token(security_context_token, env,
+                AXIS2_FALSE);
+        }
+        else if(type == ASSERTION_TYPE_ISSUER)
+        {
+            axis2_char_t *issuer = NULL;
+            issuer = (axis2_char_t *)neethi_assertion_get_value(assertion, env);
+            rp_security_context_token_set_issuer(security_context_token, env, issuer);
+        }
+        else if(type == ASSERTION_TYPE_BOOTSTRAP_POLICY)
+        {
+            neethi_policy_t *bootstrap_policy = NULL;
+            bootstrap_policy = (neethi_policy_t *)neethi_assertion_get_value(assertion, env);
+            rp_security_context_token_set_bootstrap_policy(security_context_token, env,
+                bootstrap_policy);
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/signature_token_builder.c b/neethi/src/secpolicy/builder/signature_token_builder.c
new file mode 100644
index 0000000..0c1c0c7
--- /dev/null
+++ b/neethi/src/secpolicy/builder/signature_token_builder.c
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_signature_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+signature_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *signature_token);
+
+/***********************************/
+
+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)
+{
+    rp_property_t *signature_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    signature_token = rp_property_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            signature_token_process_alternatives(env, all, signature_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_property_free, signature_token,
+                ASSERTION_TYPE_SIGNATURE_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+signature_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_property_t *signature_token)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_X509_TOKEN)
+            {
+                rp_x509_token_t *x509_token = NULL;
+                x509_token = (rp_x509_token_t *)neethi_assertion_get_value(assertion, env);
+                if(x509_token)
+                {
+                    rp_property_set_value(signature_token, env, x509_token, RP_PROPERTY_X509_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_ISSUED_TOKEN)
+            {
+                rp_issued_token_t *issued_token = NULL;
+                issued_token = (rp_issued_token_t *)neethi_assertion_get_value(assertion, env);
+                if(issued_token)
+                {
+                    rp_property_set_value(signature_token, env, issued_token,
+                        RP_PROPERTY_ISSUED_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_SAML_TOKEN)
+            {
+                rp_saml_token_t *saml_token = NULL;
+                saml_token = (rp_saml_token_t *)neethi_assertion_get_value(assertion, env);
+                if(saml_token)
+                {
+                    rp_property_set_value(signature_token, env, saml_token, RP_PROPERTY_SAML_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(type == ASSERTION_TYPE_SECURITY_CONTEXT_TOKEN)
+            {
+                rp_security_context_token_t *security_context_token = NULL;
+                security_context_token = (rp_security_context_token_t *)neethi_assertion_get_value(
+                    assertion, env);
+
+                if(security_context_token)
+                {
+                    rp_property_set_value(signature_token, env, security_context_token,
+                        RP_PROPERTY_SECURITY_CONTEXT_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/signed_encrypted_parts_builder.c b/neethi/src/secpolicy/builder/signed_encrypted_parts_builder.c
new file mode 100644
index 0000000..be5008e
--- /dev/null
+++ b/neethi/src/secpolicy/builder/signed_encrypted_parts_builder.c
@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_signed_encrypted_parts_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+static rp_header_t *AXIS2_CALL
+rp_signed_encrypted_parts_builder_build_header(
+    axiom_element_t *element,
+    const axutil_env_t *env);
+
+static axis2_status_t AXIS2_CALL
+rp_signed_encrypted_parts_builder_set_properties(
+    axiom_node_t *node,
+    axiom_element_t *element,
+    axis2_char_t *local_name,
+    rp_signed_encrypted_parts_t *signed_encrypted_parts,
+    const axutil_env_t *env);
+
+/**
+ * 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 *parts,
+    axiom_element_t *parts_ele,
+    axis2_bool_t is_signed)
+{
+    rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
+    axiom_children_iterator_t *children_iter = NULL;
+    neethi_assertion_t *assertion = NULL;
+    axis2_status_t status = AXIS2_SUCCESS;
+
+    signed_encrypted_parts = rp_signed_encrypted_parts_create(env);
+    if(!signed_encrypted_parts)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot create signed_encrypted_parts.");
+        return NULL;
+    }
+
+    rp_signed_encrypted_parts_set_signedparts(signed_encrypted_parts, env, is_signed);
+
+    children_iter = axiom_element_get_children(parts_ele, env, parts);
+    if(children_iter)
+    {
+        while(axiom_children_iterator_has_next(children_iter, env))
+        {
+            axiom_node_t *node = NULL;
+            axiom_element_t *ele = NULL;
+            axis2_char_t *local_name = NULL;
+            node = axiom_children_iterator_next(children_iter, env);
+            if(node)
+            {
+                if(axiom_node_get_node_type(node, env) == AXIOM_ELEMENT)
+                {
+                    ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+                    if(ele)
+                    {
+                        local_name = axiom_element_get_localname(ele, env);
+                        if(local_name)
+                        {
+                            status = rp_signed_encrypted_parts_builder_set_properties(node, ele,
+                                local_name, signed_encrypted_parts, env);
+                            if(status != AXIS2_SUCCESS)
+                            {
+                                rp_signed_encrypted_parts_free(signed_encrypted_parts, env);
+                                signed_encrypted_parts = NULL;
+                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                                    "[neethi] Cannot create signed_encrypted_parts. "
+                                        "Error in processing child element %s", local_name);
+                                return NULL;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assertion = neethi_assertion_create_with_args(env,
+        (AXIS2_FREE_VOID_ARG)rp_signed_encrypted_parts_free, signed_encrypted_parts,
+        ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS);
+    return assertion;
+}
+
+static axis2_status_t AXIS2_CALL
+rp_signed_encrypted_parts_builder_set_properties(
+    axiom_node_t *node,
+    axiom_element_t *element,
+    axis2_char_t *local_name,
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t *env)
+{
+    axis2_char_t *ns = NULL;
+    axutil_qname_t *node_qname = NULL;
+
+    node_qname = axiom_element_get_qname(element, env, node);
+    if(!node_qname)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get qname from element %s.",
+            local_name);
+        return AXIS2_FAILURE;
+    }
+
+    ns = axutil_qname_get_uri(node_qname, env);
+    if(!ns)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot get namespace from element %s.",
+            local_name);
+        return AXIS2_FAILURE;
+    }
+
+    /* process assertions common for WS-SecPolicy 1.1 and 1.2 */
+    if(!(axutil_strcmp(ns, RP_SP_NS_11) && axutil_strcmp(ns, RP_SP_NS_12)))
+    {
+        /* this assertion is in WS-SecurityPolicy namespace */
+        if(!strcmp(local_name, RP_BODY))
+        {
+            rp_signed_encrypted_parts_set_body(signed_encrypted_parts, env, AXIS2_TRUE);
+            return AXIS2_SUCCESS;
+        }
+        else if(!strcmp(local_name, RP_HEADER))
+        {
+            rp_header_t *header = NULL;
+            header = rp_signed_encrypted_parts_builder_build_header(element, env);
+            if(!header)
+            {
+                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                    "[neethi] Failed to process Header Assertion.");
+                return AXIS2_FAILURE;
+            }
+
+            return rp_signed_encrypted_parts_add_header(signed_encrypted_parts, env, header);
+        }
+    }
+
+    /* process assertions specific to WS-SecPolicy 1.2 */
+    if(!axutil_strcmp(ns, RP_SP_NS_12))
+    {
+        if(!strcmp(local_name, RP_ATTACHMENTS))
+        {
+            rp_signed_encrypted_parts_set_attachments(signed_encrypted_parts, env, AXIS2_TRUE);
+            return AXIS2_SUCCESS;
+        }
+    }
+
+    /* either namespace or assertion is not understood */
+    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Unknown Assertion %s with namespace %s",
+        local_name, ns);
+    return AXIS2_FAILURE;
+}
+
+static rp_header_t *AXIS2_CALL
+rp_signed_encrypted_parts_builder_build_header(
+    axiom_element_t *element,
+    const axutil_env_t *env)
+{
+    rp_header_t *header = NULL;
+    axis2_char_t *name = NULL;
+    axis2_char_t *nspace = NULL;
+
+    name = axiom_element_get_attribute_value_by_name(element, env, RP_NAME);
+    nspace = axiom_element_get_attribute_value_by_name(element, env, RP_NAMESPACE);
+    if(!nspace)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] Header assertion should have namespace associated with it.");
+        return NULL;
+    }
+
+    header = rp_header_create(env);
+    if(!header)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] Cannot create rp_header structure. Insufficient memory.");
+        return NULL;
+    }
+
+    if(name)
+    {
+        rp_header_set_name(header, env, name);
+    }
+
+    rp_header_set_namespace(header, env, nspace);
+    return header;
+}
diff --git a/neethi/src/secpolicy/builder/supporting_tokens_builder.c b/neethi/src/secpolicy/builder/supporting_tokens_builder.c
new file mode 100644
index 0000000..7482144
--- /dev/null
+++ b/neethi/src/secpolicy/builder/supporting_tokens_builder.c
@@ -0,0 +1,203 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_supporting_tokens_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+supporting_tokens_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_supporting_tokens_t *supporting_tokens);
+
+axis2_bool_t AXIS2_CALL
+is_token_assertion(
+    const axutil_env_t *env,
+    neethi_assertion_type_t type);
+
+/***********************************/
+
+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)
+{
+    rp_supporting_tokens_t *supporting_tokens = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    axis2_char_t *local_name = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    supporting_tokens = rp_supporting_tokens_create(env);
+    local_name = axiom_element_get_localname(element, env);
+
+    if(local_name)
+    {
+        if(axutil_strcmp(local_name, RP_SIGNED_SUPPORTING_TOKENS) == 0)
+        {
+            rp_supporting_tokens_set_type(supporting_tokens, env,
+                RP_PROPERTY_SIGNED_SUPPORTING_TOKEN);
+        }
+        else if(axutil_strcmp(local_name, RP_SIGNED_ENDORSING_SUPPORTING_TOKENS) == 0)
+        {
+            rp_supporting_tokens_set_type(supporting_tokens, env,
+                RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN);
+        }
+        else if(axutil_strcmp(local_name, RP_SUPPORTING_TOKENS) == 0)
+        {
+            rp_supporting_tokens_set_type(supporting_tokens, env,
+                RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN);
+        }
+        else if(axutil_strcmp(local_name, RP_ENDORSING_SUPPORTING_TOKENS) == 0)
+        {
+            rp_supporting_tokens_set_type(supporting_tokens, env,
+                RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN);
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            supporting_tokens_process_alternatives(env, all, supporting_tokens);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_supporting_tokens_free, supporting_tokens,
+                ASSERTION_TYPE_SUPPORTING_TOKENS);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+supporting_tokens_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_supporting_tokens_t *supporting_tokens)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_ALGORITHM_SUITE)
+            {
+                rp_algorithmsuite_t *algorithmsuite = NULL;
+                algorithmsuite = (rp_algorithmsuite_t *)neethi_assertion_get_value(assertion, env);
+                if(algorithmsuite)
+                {
+                    rp_supporting_tokens_set_algorithmsuite(supporting_tokens, env, algorithmsuite);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else if(is_token_assertion(env, type))
+            {
+                rp_property_t *token = NULL;
+                token = rp_property_create(env);
+                rp_token_identifier_set_token(token, assertion, env);
+                rp_supporting_tokens_add_token(supporting_tokens, env, token);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+is_token_assertion(
+    const axutil_env_t *env,
+    neethi_assertion_type_t type)
+{
+    if(type == ASSERTION_TYPE_USERNAME_TOKEN)
+    {
+        return AXIS2_TRUE;
+    }
+    else if(type == ASSERTION_TYPE_X509_TOKEN)
+    {
+        return AXIS2_TRUE;
+    }
+    else if(type == ASSERTION_TYPE_ISSUED_TOKEN)
+    {
+        return AXIS2_TRUE;
+    }
+    else if(type == ASSERTION_TYPE_SAML_TOKEN)
+    {
+        return AXIS2_TRUE;
+    }
+    else
+        return AXIS2_FALSE;
+}
diff --git a/neethi/src/secpolicy/builder/symmetric_binding_builder.c b/neethi/src/secpolicy/builder/symmetric_binding_builder.c
new file mode 100644
index 0000000..1338963
--- /dev/null
+++ b/neethi/src/secpolicy/builder/symmetric_binding_builder.c
@@ -0,0 +1,245 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_symmetric_binding_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+symmetric_binding_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_symmetric_binding_t *symmetric_binding);
+
+/***********************************/
+
+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)
+{
+    rp_symmetric_binding_t *symmetric_binding = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    symmetric_binding = rp_symmetric_binding_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            symmetric_binding_process_alternatives(env, all, symmetric_binding);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_symmetric_binding_free, symmetric_binding,
+                ASSERTION_TYPE_SYMMETRIC_BINDING);
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+symmetric_binding_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_symmetric_binding_t * symmetric_binding)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+    rp_binding_commons_t *commons = NULL;
+    rp_symmetric_asymmetric_binding_commons_t *as_commons = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+    commons = rp_binding_commons_create(env);
+    as_commons = rp_symmetric_asymmetric_binding_commons_create(env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_PROTECTION_TOKEN)
+        {
+            rp_property_t *protection_token = NULL;
+            protection_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
+            if(protection_token)
+            {
+                rp_symmetric_binding_set_protection_token(symmetric_binding, env, protection_token);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_ENCRYPTION_TOKEN)
+        {
+            rp_property_t *encryption_token = NULL;
+            encryption_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
+            if(encryption_token)
+            {
+                rp_symmetric_binding_set_encryption_token(symmetric_binding, env, encryption_token);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_SIGNATURE_TOKEN)
+        {
+            rp_property_t *signature_token = NULL;
+            signature_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
+            if(signature_token)
+            {
+                rp_symmetric_binding_set_signature_token(symmetric_binding, env, signature_token);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_ALGORITHM_SUITE)
+        {
+            rp_algorithmsuite_t *algorithmsuite = NULL;
+            algorithmsuite = (rp_algorithmsuite_t *)neethi_assertion_get_value(assertion, env);
+            if(algorithmsuite)
+            {
+                rp_binding_commons_set_algorithmsuite(commons, env, algorithmsuite);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_INCLUDE_TIMESTAMP)
+        {
+            rp_binding_commons_set_include_timestamp(commons, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_LAYOUT)
+        {
+            rp_layout_t *layout = NULL;
+            layout = (rp_layout_t *)neethi_assertion_get_value(assertion, env);
+            if(layout)
+            {
+                rp_binding_commons_set_layout(commons, env, layout);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_ENCRYPT_BEFORE_SIGNING)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_protection_order(as_commons, env,
+                RP_ENCRYPT_BEFORE_SIGNING);
+        }
+        else if(type == ASSERTION_TYPE_SIGN_BEFORE_ENCRYPTING)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_protection_order(as_commons, env,
+                RP_SIGN_BEFORE_ENCRYPTING);
+        }
+        else if(type == ASSERTION_TYPE_ENCRYPT_SIGNATURE)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_signature_protection(as_commons, env,
+                AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_PROTECT_TOKENS)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_token_protection(as_commons, env,
+                AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_ONLY_SIGN_ENTIRE_HEADERS_AND_BODY)
+        {
+            rp_symmetric_asymmetric_binding_commons_set_entire_headers_and_body_signatures(
+                as_commons, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_SUPPORTING_TOKENS)
+        {
+            rp_supporting_tokens_t *supporting_tokens = NULL;
+            supporting_tokens
+                = (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion, env);
+            if(supporting_tokens)
+            {
+                rp_property_type_t type;
+                type = rp_supporting_tokens_get_type(supporting_tokens, env);
+                if(type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_signed_supporting_tokens(commons, env, supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_signed_endorsing_supporting_tokens(commons, env,
+                        supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_supporting_tokens(commons, env, supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_endorsing_supporting_tokens(commons, env,
+                        supporting_tokens);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    rp_symmetric_asymmetric_binding_commons_set_binding_commons(as_commons, env, commons);
+    rp_symmetric_binding_set_symmetric_asymmetric_binding_commons(symmetric_binding, env,
+        as_commons);
+
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/token_identifier.c b/neethi/src/secpolicy/builder/token_identifier.c
new file mode 100644
index 0000000..938627e
--- /dev/null
+++ b/neethi/src/secpolicy/builder/token_identifier.c
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_token_identifier.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+/***********************************/
+
+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)
+{
+    void *value = NULL;
+    neethi_assertion_type_t type;
+
+    value = neethi_assertion_get_value(assertion, env);
+    type = neethi_assertion_get_type(assertion, env);
+
+    if(value)
+    {
+        if(type == ASSERTION_TYPE_USERNAME_TOKEN)
+        {
+            rp_username_token_t *username_token = NULL;
+            username_token = (rp_username_token_t *)value;
+            rp_property_set_value(token, env, username_token, RP_PROPERTY_USERNAME_TOKEN);
+            return AXIS2_SUCCESS;
+        }
+        else if(type == ASSERTION_TYPE_X509_TOKEN)
+        {
+            rp_x509_token_t *x509_token = NULL;
+            x509_token = (rp_x509_token_t *)value;
+            rp_property_set_value(token, env, x509_token, RP_PROPERTY_X509_TOKEN);
+            return AXIS2_SUCCESS;
+        }
+        else if(type == ASSERTION_TYPE_SAML_TOKEN)
+        {
+            rp_saml_token_t *saml_token = NULL;
+            saml_token = (rp_saml_token_t *)value;
+            rp_property_set_value(token, env, saml_token, RP_PROPERTY_SAML_TOKEN);
+            return AXIS2_SUCCESS;
+        }
+        else if(type == ASSERTION_TYPE_ISSUED_TOKEN)
+        {
+            rp_issued_token_t *issued_token = NULL;
+            issued_token = (rp_issued_token_t *)value;
+            rp_property_set_value(token, env, issued_token, RP_PROPERTY_ISSUED_TOKEN);
+            return AXIS2_SUCCESS;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+
+    return AXIS2_FAILURE;
+}
+
diff --git a/neethi/src/secpolicy/builder/transport_binding_builder.c b/neethi/src/secpolicy/builder/transport_binding_builder.c
new file mode 100644
index 0000000..be84119
--- /dev/null
+++ b/neethi/src/secpolicy/builder/transport_binding_builder.c
@@ -0,0 +1,196 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_transport_binding_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+transport_binding_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_transport_binding_t *transport_binding);
+
+/***********************************/
+
+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)
+{
+    rp_transport_binding_t *transport_binding = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    transport_binding = rp_transport_binding_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            transport_binding_process_alternatives(env, all, transport_binding);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_transport_binding_free, transport_binding,
+                ASSERTION_TYPE_TRANSPORT_BINDING);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+transport_binding_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_transport_binding_t *transport_binding)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+    rp_binding_commons_t *commons = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+    commons = rp_binding_commons_create(env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_TRANSPORT_TOKEN)
+        {
+            rp_property_t *transport_token = NULL;
+            transport_token = (rp_property_t *)neethi_assertion_get_value(assertion, env);
+            if(transport_token)
+            {
+                rp_transport_binding_set_transport_token(transport_binding, env, transport_token);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_ALGORITHM_SUITE)
+        {
+            rp_algorithmsuite_t *algorithmsuite = NULL;
+            algorithmsuite = (rp_algorithmsuite_t *)neethi_assertion_get_value(assertion, env);
+            if(algorithmsuite)
+            {
+                rp_binding_commons_set_algorithmsuite(commons, env, algorithmsuite);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_INCLUDE_TIMESTAMP)
+        {
+            rp_binding_commons_set_include_timestamp(commons, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_LAYOUT)
+        {
+            rp_layout_t *layout = NULL;
+            layout = (rp_layout_t *)neethi_assertion_get_value(assertion, env);
+            if(layout)
+            {
+                rp_binding_commons_set_layout(commons, env, layout);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else if(type == ASSERTION_TYPE_SUPPORTING_TOKENS)
+        {
+            rp_supporting_tokens_t *supporting_tokens = NULL;
+            supporting_tokens
+                = (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion, env);
+            if(supporting_tokens)
+            {
+                rp_property_type_t type;
+                type = rp_supporting_tokens_get_type(supporting_tokens, env);
+                if(type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_signed_supporting_tokens(commons, env, supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_signed_endorsing_supporting_tokens(commons, env,
+                        supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_supporting_tokens(commons, env, supporting_tokens);
+                }
+                else if(type == RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
+                {
+                    rp_binding_commons_set_endorsing_supporting_tokens(commons, env,
+                        supporting_tokens);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+
+    rp_transport_binding_set_binding_commons(transport_binding, env, commons);
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/transport_token_builder.c b/neethi/src/secpolicy/builder/transport_token_builder.c
new file mode 100644
index 0000000..f50183d
--- /dev/null
+++ b/neethi/src/secpolicy/builder/transport_token_builder.c
@@ -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.
+ */
+
+#include <rp_transport_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+transport_token_process_alternatives(
+    const axutil_env_t * env,
+    neethi_all_t * all,
+    rp_property_t * transport_token);
+
+/***********************************/
+
+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)
+{
+    rp_property_t *transport_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    transport_token = rp_property_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            transport_token_process_alternatives(env, all, transport_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_property_free, transport_token,
+                ASSERTION_TYPE_TRANSPORT_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+transport_token_process_alternatives(
+    const axutil_env_t * env,
+    neethi_all_t * all,
+    rp_property_t * transport_token)
+{
+
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_HTTPS_TOKEN)
+            {
+                rp_https_token_t *https_token = NULL;
+                https_token = (rp_https_token_t *)neethi_assertion_get_value(assertion, env);
+                if(https_token)
+                {
+                    rp_property_set_value(transport_token, env, https_token,
+                        RP_PROPERTY_HTTPS_TOKEN);
+                }
+                else
+                    return AXIS2_FAILURE;
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/trust10_builder.c b/neethi/src/secpolicy/builder/trust10_builder.c
new file mode 100644
index 0000000..e97f0f7
--- /dev/null
+++ b/neethi/src/secpolicy/builder/trust10_builder.c
@@ -0,0 +1,139 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_trust10_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+trust10_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_trust10_t *trust10);
+
+/***********************************/
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+rp_trust10_builder_build(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    rp_trust10_t *trust10 = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    trust10 = rp_trust10_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            trust10_process_alternatives(env, all, trust10);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_trust10_free, trust10, ASSERTION_TYPE_TRUST10);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+trust10_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_trust10_t *trust10)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_MUST_SUPPORT_CLIENT_CHALLENGE)
+        {
+            rp_trust10_set_must_support_client_challenge(trust10, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_SERVER_CHALLENGE)
+        {
+            rp_trust10_set_must_support_server_challenge(trust10, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_CLIENT_ENTROPY)
+        {
+            rp_trust10_set_require_client_entropy(trust10, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_SERVER_ENTROPHY)
+        {
+            rp_trust10_set_require_server_entropy(trust10, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_ISSUED_TOKENS)
+        {
+            rp_trust10_set_must_support_issued_token(trust10, env, AXIS2_TRUE);
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/username_token_builder.c b/neethi/src/secpolicy/builder/username_token_builder.c
new file mode 100644
index 0000000..b8ac02b
--- /dev/null
+++ b/neethi/src/secpolicy/builder/username_token_builder.c
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_username_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+static axis2_status_t AXIS2_CALL username_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_username_token_t *username_token);
+
+/***********************************/
+
+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)
+{
+    rp_username_token_t *username_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    axis2_char_t *inclusion_value = NULL;
+    axutil_qname_t *qname = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    username_token = rp_username_token_create(env);
+    qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_11, RP_SP_PREFIX);
+    inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+    axutil_qname_free(qname, env);
+    qname = NULL;
+    if(!inclusion_value)
+    {
+        /* we can try whether WS-SP1.2 specific inclusion value */
+        qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_12, RP_SP_PREFIX);
+        inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+        axutil_qname_free(qname, env);
+        qname = NULL;
+    }
+
+    rp_username_token_set_inclusion(username_token, env, inclusion_value);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        assertion = neethi_assertion_create(env);
+        neethi_assertion_set_value(assertion, env, username_token, ASSERTION_TYPE_USERNAME_TOKEN);
+        return assertion;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            username_token_process_alternatives(env, all, username_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_username_token_free, username_token,
+                ASSERTION_TYPE_USERNAME_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+static axis2_status_t AXIS2_CALL
+username_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_username_token_t *username_token)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(value)
+        {
+            if(type == ASSERTION_TYPE_WSS_USERNAME_TOKEN_10)
+            {
+                rp_username_token_set_useUTprofile10(username_token, env, AXIS2_TRUE);
+            }
+            else if(type == ASSERTION_TYPE_WSS_USERNAME_TOKEN_11)
+            {
+                rp_username_token_set_useUTprofile11(username_token, env, AXIS2_TRUE);
+            }
+            else
+                return AXIS2_FAILURE;
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/wss10_builder.c b/neethi/src/secpolicy/builder/wss10_builder.c
new file mode 100644
index 0000000..6dd10ae
--- /dev/null
+++ b/neethi/src/secpolicy/builder/wss10_builder.c
@@ -0,0 +1,135 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_wss10_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+wss10_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_wss10_t *wss10);
+
+/***********************************/
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+rp_wss10_builder_build(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    rp_wss10_t *wss10 = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    wss10 = rp_wss10_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            wss10_process_alternatives(env, all, wss10);
+
+            assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_wss10_free,
+                wss10, ASSERTION_TYPE_WSS10);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+wss10_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_wss10_t *wss10)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_KEY_IDENTIFIER)
+        {
+            rp_wss10_set_must_support_ref_key_identifier(wss10, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_ISSUER_SERIAL)
+        {
+            rp_wss10_set_must_support_ref_issuer_serial(wss10, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_EXTERNAL_URI)
+        {
+            rp_wss10_set_must_support_ref_external_uri(wss10, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_EMBEDDED_TOKEN)
+        {
+            rp_wss10_set_must_support_ref_embedded_token(wss10, env, AXIS2_TRUE);
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/wss11_builder.c b/neethi/src/secpolicy/builder/wss11_builder.c
new file mode 100644
index 0000000..6249181
--- /dev/null
+++ b/neethi/src/secpolicy/builder/wss11_builder.c
@@ -0,0 +1,147 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_wss11_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+wss11_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_wss11_t *wss11);
+
+/***********************************/
+
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+rp_wss11_builder_build(
+    const axutil_env_t *env,
+    axiom_node_t *node,
+    axiom_element_t *element)
+{
+    rp_wss11_t *wss11 = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    wss11 = rp_wss11_create(env);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            wss11_process_alternatives(env, all, wss11);
+
+            assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_wss11_free,
+                wss11, ASSERTION_TYPE_WSS11);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+wss11_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_wss11_t *wss11)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+    void *value = NULL;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_KEY_IDENTIFIER)
+        {
+            rp_wss11_set_must_support_ref_key_identifier(wss11, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_ISSUER_SERIAL)
+        {
+            rp_wss11_set_must_support_ref_issuer_serial(wss11, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_EXTERNAL_URI)
+        {
+            rp_wss11_set_must_support_ref_external_uri(wss11, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_EMBEDDED_TOKEN)
+        {
+            rp_wss11_set_must_support_ref_embedded_token(wss11, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_THUMBPRINT)
+        {
+            rp_wss11_set_must_support_ref_thumbprint(wss11, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_MUST_SUPPORT_REF_ENCRYPTED_KEY)
+        {
+            rp_wss11_set_must_support_ref_encryptedkey(wss11, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_SIGNATURE_CONFIRMATION)
+        {
+            rp_wss11_set_require_signature_confirmation(wss11, env, AXIS2_TRUE);
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/builder/x509_token_builder.c b/neethi/src/secpolicy/builder/x509_token_builder.c
new file mode 100644
index 0000000..fa8d8f9
--- /dev/null
+++ b/neethi/src/secpolicy/builder/x509_token_builder.c
@@ -0,0 +1,168 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_x509_token_builder.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
+
+/*private functions*/
+
+axis2_status_t AXIS2_CALL
+x509_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_x509_token_t *x509_token);
+
+/***********************************/
+
+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)
+{
+    rp_x509_token_t *x509_token = NULL;
+    neethi_policy_t *policy = NULL;
+    axiom_node_t *child_node = NULL;
+    axiom_element_t *child_element = NULL;
+    axutil_array_list_t *alternatives = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
+    axis2_char_t *inclusion_value = NULL;
+    axutil_qname_t *qname = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_policy_t *normalized_policy = NULL;
+
+    x509_token = rp_x509_token_create(env);
+    qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_11, RP_SP_PREFIX);
+    inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+    axutil_qname_free(qname, env);
+    qname = NULL;
+
+    if(!inclusion_value)
+    {
+        /* we can try whether WS-SP1.2 specific inclusion value */
+        qname = axutil_qname_create(env, RP_INCLUDE_TOKEN, RP_SP_NS_12, RP_SP_PREFIX);
+        inclusion_value = axiom_element_get_attribute_value(element, env, qname);
+        axutil_qname_free(qname, env);
+        qname = NULL;
+    }
+
+    rp_x509_token_set_inclusion(x509_token, env, inclusion_value);
+
+    child_node = axiom_node_get_first_element(node, env);
+    if(!child_node)
+    {
+        return NULL;
+    }
+
+    if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+    {
+        child_element = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+        if(child_element)
+        {
+            policy = neethi_engine_get_policy(env, child_node, child_element);
+            if(!policy)
+            {
+                return NULL;
+            }
+            normalized_policy = neethi_engine_get_normalize(env, AXIS2_FALSE, policy);
+            neethi_policy_free(policy, env);
+            policy = NULL;
+            alternatives = neethi_policy_get_alternatives(normalized_policy, env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
+            all = (neethi_all_t *)neethi_operator_get_value(component, env);
+            x509_token_process_alternatives(env, all, x509_token);
+
+            assertion = neethi_assertion_create_with_args(env,
+                (AXIS2_FREE_VOID_ARG)rp_x509_token_free, x509_token, ASSERTION_TYPE_X509_TOKEN);
+
+            neethi_policy_free(normalized_policy, env);
+            normalized_policy = NULL;
+
+            return assertion;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+axis2_status_t AXIS2_CALL
+x509_token_process_alternatives(
+    const axutil_env_t *env,
+    neethi_all_t *all,
+    rp_x509_token_t *x509_token)
+{
+    neethi_operator_t *operator = NULL;
+    axutil_array_list_t *arraylist = NULL;
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t type;
+
+    int i = 0;
+
+    arraylist = neethi_all_get_policy_components(all, env);
+
+    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        type = neethi_assertion_get_type(assertion, env);
+
+        if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10)
+        {
+            rp_x509_token_set_derivedkey(x509_token, env, DERIVEKEY_NEEDED);
+            rp_x509_token_set_derivedkey_version(x509_token, env, DERIVEKEY_VERSION_SC10);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC13)
+        {
+            rp_x509_token_set_derivedkey(x509_token, env, DERIVEKEY_NEEDED);
+            rp_x509_token_set_derivedkey_version(x509_token, env, DERIVEKEY_VERSION_SC13);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_KEY_IDENTIFIRE_REFERENCE)
+        {
+            rp_x509_token_set_require_key_identifier_reference(x509_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_ISSUER_SERIAL_REFERENCE)
+        {
+            rp_x509_token_set_require_issuer_serial_reference(x509_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_EMBEDDED_TOKEN_REFERENCE)
+        {
+            rp_x509_token_set_require_embedded_token_reference(x509_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_REQUIRE_THUMBPRINT_REFERENCE)
+        {
+            rp_x509_token_set_require_thumb_print_reference(x509_token, env, AXIS2_TRUE);
+        }
+        else if(type == ASSERTION_TYPE_WSS_X509_V1_TOKEN_10)
+        {
+            rp_x509_token_set_token_version_and_type(x509_token, env, RP_WSS_X509_V1_TOKEN_10);
+        }
+        else if(type == ASSERTION_TYPE_WSS_X509_V3_TOKEN_10)
+        {
+            rp_x509_token_set_token_version_and_type(x509_token, env, RP_WSS_X509_V3_TOKEN_10);
+        }
+        else
+            return AXIS2_FAILURE;
+    }
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/Makefile.am b/neethi/src/secpolicy/model/Makefile.am
new file mode 100644
index 0000000..b24ddb7
--- /dev/null
+++ b/neethi/src/secpolicy/model/Makefile.am
@@ -0,0 +1,21 @@
+TESTS =
+
+noinst_LTLIBRARIES = librp_model.la
+
+librp_model_la_SOURCES = algorithmsuite.c asymmetric_binding.c \
+							binding_commons.c header.c element.c https_token.c layout.c \
+							property.c rampart_config.c secpolicy.c security_context_token.c \
+							signed_encrypted_elements.c signed_encrypted_parts.c signed_encrypted_items.c \
+							supporting_tokens.c symmetric_asymmetric_binding_commons.c \
+							symmetric_binding.c transport_binding.c ut.c wss10.c wss11.c x509_token.c \
+							trust10.c issued_token.c saml_token.c token.c
+
+
+librp_model_la_LIBADD  = ../../../../util/src/libaxutil.la
+
+
+INCLUDES = -I$(top_builddir)/include \
+			-I ../../../include \
+			-I ../../../../util/include \
+	        -I ../../../../axiom/include \
+    	    -I ../../../../include
diff --git a/neethi/src/secpolicy/model/algorithmsuite.c b/neethi/src/secpolicy/model/algorithmsuite.c
new file mode 100644
index 0000000..db3426c
--- /dev/null
+++ b/neethi/src/secpolicy/model/algorithmsuite.c
@@ -0,0 +1,627 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_algorithmsuite.h>
+
+struct rp_algorithmsuite_t
+{
+    axis2_char_t *algosuite_string;
+    axis2_char_t *symmetric_signature;
+    axis2_char_t *asymmetric_signature;
+    axis2_char_t *computed_key;
+    int max_symmetric_keylength;
+    int min_asymmetric_keylength;
+    int max_asymmetric_keylength;
+    axis2_char_t *digest;
+    axis2_char_t *encryption;
+    axis2_char_t *symmetrickeywrap;
+    axis2_char_t *asymmetrickeywrap;
+    axis2_char_t *encryption_key_derivation;
+    axis2_char_t *signature_key_derivation;
+    int encryption_key_derivation_keylength;
+    int signature_key_derivation_keylength;
+    int min_symmetric_keylength;
+    axis2_char_t *c14n;
+    axis2_char_t *soap_normalization;
+    axis2_char_t *str_transformation;
+    axis2_char_t *xpath;
+    int ref;
+
+};
+
+AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL
+rp_algorithmsuite_create(
+    const axutil_env_t *env)
+{
+    rp_algorithmsuite_t *algorithmsuite = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    algorithmsuite = (rp_algorithmsuite_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_algorithmsuite_t));
+
+    if(algorithmsuite == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    algorithmsuite->algosuite_string = NULL;
+    algorithmsuite->symmetric_signature = RP_HMAC_SHA1;
+    algorithmsuite->asymmetric_signature = RP_RSA_SHA1;
+    algorithmsuite->computed_key = RP_P_SHA1;
+    algorithmsuite->max_symmetric_keylength = 256;
+    algorithmsuite->min_asymmetric_keylength = 1024;
+    algorithmsuite->max_asymmetric_keylength = 4096;
+    algorithmsuite->digest = NULL;
+    algorithmsuite->encryption = NULL;
+    algorithmsuite->symmetrickeywrap = NULL;
+    algorithmsuite->asymmetrickeywrap = NULL;
+    algorithmsuite->encryption_key_derivation = NULL;
+    algorithmsuite->signature_key_derivation = NULL;
+    algorithmsuite->encryption_key_derivation_keylength = 192;
+    algorithmsuite->signature_key_derivation_keylength = 192;
+    algorithmsuite->min_symmetric_keylength = 0;
+    ;
+    algorithmsuite->c14n = RP_EX_C14N;
+    algorithmsuite->soap_normalization = NULL;
+    algorithmsuite->str_transformation = NULL;
+    algorithmsuite->xpath = NULL;
+    algorithmsuite->ref = 0;
+    return algorithmsuite;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_algorithmsuite_free(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    if(algorithmsuite)
+    {
+        if(--(algorithmsuite->ref) > 0)
+        {
+            return;
+        }
+
+        AXIS2_FREE(env->allocator, algorithmsuite);
+        algorithmsuite = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_algosuite_string(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    if(!algorithmsuite)
+        return NULL;
+    else
+        return algorithmsuite->algosuite_string;
+
+}
+
+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_PARAM_CHECK(env->error, algosuite_string, AXIS2_FAILURE);
+
+    algorithmsuite->algosuite_string = algosuite_string;
+
+    if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC256) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_AES256;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES256;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L256;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 256;
+        algorithmsuite->encryption_key_derivation_keylength = 256;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC192) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_AES192;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES192;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC128) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_AES128;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES128;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->min_symmetric_keylength = 128;
+        algorithmsuite->encryption_key_derivation_keylength = 128;
+        algorithmsuite->signature_key_derivation_keylength = 128;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_TRIPLE_DES) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_TRIPLE_DES;
+        algorithmsuite->symmetrickeywrap = RP_KW_TRIPLE_DES;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC256_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_AES256;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES256;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L256;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 256;
+        algorithmsuite->encryption_key_derivation_keylength = 256;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC192_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_AES192;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES192;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC128_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_AES128;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES128;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->min_symmetric_keylength = 128;
+        algorithmsuite->encryption_key_derivation_keylength = 128;
+        algorithmsuite->signature_key_derivation_keylength = 128;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_TRIPLE_DES_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA1;
+        algorithmsuite->encryption = RP_TRIPLE_DES;
+        algorithmsuite->symmetrickeywrap = RP_KW_TRIPLE_DES;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC256_SHA256) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_AES256;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES256;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L256;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 256;
+        algorithmsuite->encryption_key_derivation_keylength = 256;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC192_SHA256) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_AES192;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES192;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC128_SHA256) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_AES128;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES128;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->min_symmetric_keylength = 128;
+        algorithmsuite->encryption_key_derivation_keylength = 128;
+        algorithmsuite->signature_key_derivation_keylength = 128;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_TRIPLE_DES_SHA256) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_TRIPLE_DES;
+        algorithmsuite->symmetrickeywrap = RP_KW_TRIPLE_DES;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA_OAEP;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC256_SHA256_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_AES256;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES256;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L256;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 256;
+        algorithmsuite->encryption_key_derivation_keylength = 256;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC192_SHA256_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_AES192;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES192;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_BASIC128_SHA256_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_AES128;
+        algorithmsuite->symmetrickeywrap = RP_KW_AES128;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L128;
+        algorithmsuite->min_symmetric_keylength = 128;
+        algorithmsuite->encryption_key_derivation_keylength = 128;
+        algorithmsuite->signature_key_derivation_keylength = 128;
+
+        return AXIS2_SUCCESS;
+    }
+    else if(axutil_strcmp(algosuite_string, RP_ALGO_SUITE_TRIPLE_DES_SHA256_RSA15) == 0)
+    {
+        algorithmsuite->digest = RP_SHA256;
+        algorithmsuite->encryption = RP_TRIPLE_DES;
+        algorithmsuite->symmetrickeywrap = RP_KW_TRIPLE_DES;
+        algorithmsuite->asymmetrickeywrap = RP_KW_RSA15;
+        algorithmsuite->encryption_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->signature_key_derivation = RP_P_SHA1_L192;
+        algorithmsuite->min_symmetric_keylength = 192;
+        algorithmsuite->encryption_key_derivation_keylength = 192;
+        algorithmsuite->signature_key_derivation_keylength = 192;
+
+        return AXIS2_SUCCESS;
+    }
+    else
+        return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_symmetric_signature(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->symmetric_signature;
+}
+
+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_PARAM_CHECK(env->error, symmetric_signature, AXIS2_FAILURE);
+
+    algorithmsuite->symmetric_signature = symmetric_signature;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_asymmetric_signature(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->asymmetric_signature;
+}
+
+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_PARAM_CHECK(env->error, asymmetric_signature, AXIS2_FAILURE);
+
+    algorithmsuite->asymmetric_signature = asymmetric_signature;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_computed_key(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->computed_key;
+}
+
+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_PARAM_CHECK(env->error, computed_key, AXIS2_FAILURE);
+
+    algorithmsuite->computed_key = computed_key;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_digest(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->digest;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_encryption(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->encryption;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+rp_algorithmsuite_get_max_symmetric_keylength(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->max_symmetric_keylength;
+}
+
+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)
+{
+    algorithmsuite->max_symmetric_keylength = max_symmetric_keylength;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+rp_algorithmsuite_get_min_symmetric_keylength(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->min_symmetric_keylength;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+rp_algorithmsuite_get_encryption_derivation_keylength(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->encryption_key_derivation_keylength;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+rp_algorithmsuite_get_signature_derivation_keylength(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->signature_key_derivation_keylength;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+rp_algorithmsuite_get_max_asymmetric_keylength(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->max_asymmetric_keylength;
+}
+
+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)
+{
+    algorithmsuite->max_asymmetric_keylength = max_asymmetric_keylength;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+rp_algorithmsuite_get_min_asymmetric_keylength(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->min_asymmetric_keylength;
+}
+
+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)
+{
+    algorithmsuite->min_asymmetric_keylength = min_asymmetric_keylength;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_symmetrickeywrap(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->symmetrickeywrap;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_asymmetrickeywrap(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->asymmetrickeywrap;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_signature_key_derivation(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->signature_key_derivation;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_encryption_key_derivation(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->encryption_key_derivation;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_soap_normalization(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->soap_normalization;
+}
+
+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_PARAM_CHECK(env->error, soap_normalization, AXIS2_FAILURE);
+    algorithmsuite->soap_normalization = soap_normalization;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_str_transformation(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->str_transformation;
+}
+
+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_PARAM_CHECK(env->error, str_transformation, AXIS2_FAILURE);
+    algorithmsuite->str_transformation = str_transformation;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_c14n(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->c14n;
+}
+
+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_PARAM_CHECK(env->error, c14n, AXIS2_FAILURE);
+    algorithmsuite->c14n = c14n;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_algorithmsuite_get_xpath(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    return algorithmsuite->xpath;
+}
+
+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_PARAM_CHECK(env->error, xpath, AXIS2_FAILURE);
+    algorithmsuite->xpath = xpath;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_algorithmsuite_increment_ref(
+    rp_algorithmsuite_t *algorithmsuite,
+    const axutil_env_t *env)
+{
+    algorithmsuite->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/asymmetric_binding.c b/neethi/src/secpolicy/model/asymmetric_binding.c
new file mode 100644
index 0000000..0e57dce
--- /dev/null
+++ b/neethi/src/secpolicy/model/asymmetric_binding.c
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_asymmetric_binding.h>
+
+struct rp_asymmetric_binding_t
+{
+    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons;
+    rp_property_t *initiator_token;
+    rp_property_t *recipient_token;
+    int ref;
+};
+
+AXIS2_EXTERN rp_asymmetric_binding_t *AXIS2_CALL
+rp_asymmetric_binding_create(
+    const axutil_env_t *env)
+{
+    rp_asymmetric_binding_t *asymmetric_binding = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    asymmetric_binding = (rp_asymmetric_binding_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_asymmetric_binding_t));
+
+    if(asymmetric_binding == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    asymmetric_binding->symmetric_asymmetric_binding_commons = NULL;
+    asymmetric_binding->initiator_token = NULL;
+    asymmetric_binding->recipient_token = NULL;
+    asymmetric_binding->ref = 0;
+
+    return asymmetric_binding;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_asymmetric_binding_free(
+    rp_asymmetric_binding_t *asymmetric_binding,
+    const axutil_env_t *env)
+{
+    if(asymmetric_binding)
+    {
+
+        if(--(asymmetric_binding->ref) > 0)
+        {
+            return;
+        }
+
+        if(asymmetric_binding->symmetric_asymmetric_binding_commons)
+        {
+            rp_symmetric_asymmetric_binding_commons_free(
+                asymmetric_binding-> symmetric_asymmetric_binding_commons, env);
+            asymmetric_binding->symmetric_asymmetric_binding_commons = NULL;
+        }
+        if(asymmetric_binding->initiator_token)
+        {
+            rp_property_free(asymmetric_binding->initiator_token, env);
+            asymmetric_binding->initiator_token = NULL;
+        }
+        if(asymmetric_binding->recipient_token)
+        {
+            rp_property_free(asymmetric_binding->recipient_token, env);
+            asymmetric_binding->recipient_token = NULL;
+        }
+        AXIS2_FREE(env->allocator, asymmetric_binding);
+    }
+
+    return;
+}
+
+/* Implementations */
+
+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)
+{
+    return asymmetric_binding->symmetric_asymmetric_binding_commons;
+}
+
+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_PARAM_CHECK(env->error, symmetric_asymmetric_binding_commons, AXIS2_FAILURE);
+
+    asymmetric_binding->symmetric_asymmetric_binding_commons = symmetric_asymmetric_binding_commons;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_property_t *AXIS2_CALL
+rp_asymmetric_binding_get_initiator_token(
+    rp_asymmetric_binding_t *asymmetric_binding,
+    const axutil_env_t *env)
+{
+    return asymmetric_binding->initiator_token;
+}
+
+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_PARAM_CHECK(env->error, initiator_token, AXIS2_FAILURE);
+
+    rp_property_increment_ref(initiator_token, env);
+    asymmetric_binding->initiator_token = initiator_token;
+    return AXIS2_SUCCESS;
+}
+
+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_PARAM_CHECK(env->error, recipient_token, AXIS2_FAILURE);
+
+    rp_property_increment_ref(recipient_token, env);
+    asymmetric_binding->recipient_token = recipient_token;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_property_t *AXIS2_CALL
+rp_asymmetric_binding_get_recipient_token(
+    rp_asymmetric_binding_t *asymmetric_binding,
+    const axutil_env_t *env)
+{
+    return asymmetric_binding->recipient_token;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_asymmetric_binding_increment_ref(
+    rp_asymmetric_binding_t *asymmetric_binding,
+    const axutil_env_t *env)
+{
+    asymmetric_binding->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/binding_commons.c b/neethi/src/secpolicy/model/binding_commons.c
new file mode 100644
index 0000000..9795c78
--- /dev/null
+++ b/neethi/src/secpolicy/model/binding_commons.c
@@ -0,0 +1,245 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_binding_commons.h>
+
+struct rp_binding_commons_t
+{
+    rp_algorithmsuite_t *algorithmsuite;
+    axis2_bool_t include_timestamp;
+    rp_layout_t *layout;
+    rp_supporting_tokens_t *signed_supporting_tokens;
+    rp_supporting_tokens_t *signed_endorsing_supporting_tokens;
+    rp_supporting_tokens_t *endorsing_supporting_tokens;
+    rp_supporting_tokens_t *supporting_tokens;
+};
+
+AXIS2_EXTERN rp_binding_commons_t *AXIS2_CALL
+rp_binding_commons_create(
+    const axutil_env_t *env)
+{
+    rp_binding_commons_t *binding_commons = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    binding_commons = (rp_binding_commons_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_binding_commons_t));
+
+    if(binding_commons == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+    binding_commons->algorithmsuite = NULL;
+    binding_commons->include_timestamp = AXIS2_FALSE;
+    binding_commons->layout = NULL;
+    binding_commons->signed_supporting_tokens = NULL;
+    binding_commons->signed_endorsing_supporting_tokens = NULL;
+    binding_commons->endorsing_supporting_tokens = NULL;
+    binding_commons->supporting_tokens = NULL;
+
+    return binding_commons;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_binding_commons_free(
+    rp_binding_commons_t *binding_commons,
+    const axutil_env_t *env)
+{
+    if(binding_commons)
+    {
+        if(binding_commons->algorithmsuite)
+        {
+            rp_algorithmsuite_free(binding_commons->algorithmsuite, env);
+            binding_commons->algorithmsuite = NULL;
+        }
+        if(binding_commons->layout)
+        {
+            rp_layout_free(binding_commons->layout, env);
+            binding_commons->layout = NULL;
+        }
+        if(binding_commons->signed_supporting_tokens)
+        {
+            rp_supporting_tokens_free(binding_commons->signed_supporting_tokens, env);
+            binding_commons->signed_supporting_tokens = NULL;
+        }
+        if(binding_commons->signed_endorsing_supporting_tokens)
+        {
+            rp_supporting_tokens_free(binding_commons-> signed_endorsing_supporting_tokens, env);
+            binding_commons->signed_endorsing_supporting_tokens = NULL;
+        }
+        if(binding_commons->endorsing_supporting_tokens)
+        {
+            rp_supporting_tokens_free(binding_commons-> endorsing_supporting_tokens, env);
+            binding_commons->endorsing_supporting_tokens = NULL;
+        }
+        if(binding_commons->supporting_tokens)
+        {
+            rp_supporting_tokens_free(binding_commons->supporting_tokens, env);
+            binding_commons->supporting_tokens = NULL;
+        }
+        AXIS2_FREE(env->allocator, binding_commons);
+        binding_commons = NULL;
+
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_binding_commons_get_include_timestamp(
+    rp_binding_commons_t *binding_commons,
+    const axutil_env_t *env)
+{
+    return binding_commons->include_timestamp;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, include_timestamp, AXIS2_FAILURE);
+
+    binding_commons->include_timestamp = include_timestamp;
+
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL
+rp_binding_commons_get_algorithmsuite(
+    rp_binding_commons_t *binding_commons,
+    const axutil_env_t *env)
+{
+    return binding_commons->algorithmsuite;
+}
+
+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_PARAM_CHECK(env->error, algorithmsuite, AXIS2_FAILURE);
+
+    rp_algorithmsuite_increment_ref(algorithmsuite, env);
+    binding_commons->algorithmsuite = algorithmsuite;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_layout_t *AXIS2_CALL
+rp_binding_commons_get_layout(
+    rp_binding_commons_t *binding_commons,
+    const axutil_env_t *env)
+{
+    return binding_commons->layout;
+}
+
+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_PARAM_CHECK(env->error, layout, AXIS2_FAILURE);
+    rp_layout_increment_ref(layout, env);
+    binding_commons->layout = layout;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return binding_commons->signed_supporting_tokens;
+}
+
+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_PARAM_CHECK(env->error, signed_supporting_tokens, AXIS2_FAILURE);
+    binding_commons->signed_supporting_tokens = signed_supporting_tokens;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return binding_commons->signed_endorsing_supporting_tokens;
+}
+
+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_PARAM_CHECK(env->error, signed_endorsing_supporting_tokens, AXIS2_FAILURE);
+
+    binding_commons->signed_endorsing_supporting_tokens = signed_endorsing_supporting_tokens;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return binding_commons->endorsing_supporting_tokens;
+}
+
+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_PARAM_CHECK(env->error, endorsing_supporting_tokens, AXIS2_FAILURE);
+    binding_commons->endorsing_supporting_tokens = endorsing_supporting_tokens;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return binding_commons->supporting_tokens;
+}
+
+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)
+{
+    AXIS2_PARAM_CHECK(env->error, supporting_tokens, AXIS2_FAILURE);
+    binding_commons->supporting_tokens = supporting_tokens;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/element.c b/neethi/src/secpolicy/model/element.c
new file mode 100644
index 0000000..125fef3
--- /dev/null
+++ b/neethi/src/secpolicy/model/element.c
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_element.h>
+
+struct rp_element_t
+{
+    axis2_char_t *name;
+    axis2_char_t *nspace;
+};
+
+AXIS2_EXTERN rp_element_t *AXIS2_CALL
+rp_element_create(
+    const axutil_env_t * env)
+{
+    rp_element_t *element = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    element = (rp_element_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_element_t));
+
+    if(element == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    element->name = NULL;
+    element->nspace = NULL;
+
+    return element;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_element_free(
+    rp_element_t * element,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(element)
+    {
+        AXIS2_FREE(env->allocator, element);
+        element = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_element_get_name(
+    rp_element_t * element,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return element->name;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, name, AXIS2_FAILURE);
+
+    element->name = name;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_element_get_namespace(
+    rp_element_t * element,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return element->nspace;
+
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_element_set_namespace(
+    rp_element_t * element,
+    const axutil_env_t * env,
+    axis2_char_t * nspace)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, nspace, AXIS2_FAILURE);
+
+    element->nspace = nspace;
+
+    return AXIS2_SUCCESS;
+
+}
diff --git a/neethi/src/secpolicy/model/header.c b/neethi/src/secpolicy/model/header.c
new file mode 100644
index 0000000..9aab978
--- /dev/null
+++ b/neethi/src/secpolicy/model/header.c
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_header.h>
+
+struct rp_header_t
+{
+    axis2_char_t *name;
+    axis2_char_t *nspace;
+};
+
+AXIS2_EXTERN rp_header_t *AXIS2_CALL
+rp_header_create(
+    const axutil_env_t * env)
+{
+    rp_header_t *header = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    header = (rp_header_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_header_t));
+
+    if(header == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    header->name = NULL;
+    header->nspace = NULL;
+
+    return header;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_header_free(
+    rp_header_t * header,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(header)
+    {
+        if(header->name)
+        {
+            AXIS2_FREE(env->allocator, header->name);
+            header->name = NULL;
+        }
+        if(header->nspace)
+        {
+            AXIS2_FREE(env->allocator, header->nspace);
+            header->nspace = NULL;
+        }
+
+        AXIS2_FREE(env->allocator, header);
+        header = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_header_get_name(
+    rp_header_t * header,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return header->name;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, name, AXIS2_FAILURE);
+
+    header->name = axutil_strdup(env, name);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_header_get_namespace(
+    rp_header_t * header,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return header->nspace;
+
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_header_set_namespace(
+    rp_header_t * header,
+    const axutil_env_t * env,
+    axis2_char_t * nspace)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, nspace, AXIS2_FAILURE);
+
+    header->nspace = axutil_strdup(env, nspace);
+
+    return AXIS2_SUCCESS;
+
+}
diff --git a/neethi/src/secpolicy/model/https_token.c b/neethi/src/secpolicy/model/https_token.c
new file mode 100644
index 0000000..100af45
--- /dev/null
+++ b/neethi/src/secpolicy/model/https_token.c
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_https_token.h>
+
+struct rp_https_token_t
+{
+    axis2_char_t *inclusion;
+    axis2_bool_t derivedkeys;
+    axis2_bool_t require_client_certificate;
+    int ref;
+};
+
+AXIS2_EXTERN rp_https_token_t *AXIS2_CALL
+rp_https_token_create(
+    const axutil_env_t * env)
+{
+    rp_https_token_t *https_token = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    https_token = (rp_https_token_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_https_token_t));
+
+    if(https_token == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    https_token->inclusion = RP_INCLUDE_ALWAYS;
+    https_token->derivedkeys = AXIS2_FALSE;
+    https_token->require_client_certificate = AXIS2_FALSE;
+    https_token->ref = 0;
+
+    return https_token;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_https_token_free(
+    rp_https_token_t * https_token,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(https_token)
+    {
+        if(--(https_token->ref) > 0)
+        {
+            return;
+        }
+        AXIS2_FREE(env->allocator, https_token);
+        https_token = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_https_token_get_inclusion(
+    rp_https_token_t * https_token,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return https_token->inclusion;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, inclusion, AXIS2_FAILURE);
+
+    https_token->inclusion = inclusion;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_https_token_get_derivedkeys(
+    rp_https_token_t * https_token,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return https_token->derivedkeys;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, derivedkeys, AXIS2_FAILURE);
+
+    https_token->derivedkeys = derivedkeys;
+
+    return AXIS2_SUCCESS;
+
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return https_token->require_client_certificate;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, require_client_certificate, AXIS2_FAILURE)
+    https_token->require_client_certificate = require_client_certificate;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_https_token_increment_ref(
+    rp_https_token_t * https_token,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    https_token->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/issued_token.c b/neethi/src/secpolicy/model/issued_token.c
new file mode 100644
index 0000000..00948f2
--- /dev/null
+++ b/neethi/src/secpolicy/model/issued_token.c
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_issued_token.h>
+
+struct rp_issued_token
+{
+    axis2_char_t *inclusion;
+    axiom_node_t *issuer_epr;
+    axiom_node_t *requested_sec_token_template;
+    axis2_bool_t derivedkeys;
+    axis2_bool_t require_external_reference;
+    axis2_bool_t require_internal_reference;
+    int ref;
+};
+
+AXIS2_EXTERN rp_issued_token_t * AXIS2_CALL
+rp_issued_token_create(
+    const axutil_env_t *env)
+{
+    rp_issued_token_t *issued_token = NULL;
+
+    issued_token = (rp_issued_token_t*)AXIS2_MALLOC(env->allocator, sizeof(rp_issued_token_t));
+
+    if(issued_token == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    issued_token->inclusion = NULL;
+    issued_token->issuer_epr = NULL;
+    issued_token->requested_sec_token_template = NULL;
+    issued_token->derivedkeys = AXIS2_FALSE;
+    issued_token->require_external_reference = AXIS2_FALSE;
+    issued_token->require_internal_reference = AXIS2_FALSE;
+    issued_token->ref = 0;
+
+    return issued_token;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_issued_token_free(
+    rp_issued_token_t *issued_token,
+    const axutil_env_t *env)
+{
+    if(issued_token)
+    {
+        if(--(issued_token->ref) > 0)
+        {
+            return;
+        }
+
+        AXIS2_FREE(env->allocator, issued_token);
+        issued_token = NULL;
+    }
+    return;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+rp_issued_token_get_inclusion(
+    rp_issued_token_t *issued_token,
+    const axutil_env_t *env)
+{
+    return issued_token->inclusion;
+}
+
+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)
+{
+    if(inclusion)
+    {
+        issued_token->inclusion = inclusion;
+        return AXIS2_SUCCESS;
+    }
+
+    return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axiom_node_t * AXIS2_CALL
+rp_issued_token_get_issuer_epr(
+    rp_issued_token_t *issued_token,
+    const axutil_env_t *env)
+{
+    return issued_token->issuer_epr;
+}
+
+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)
+{
+    if(issuer_epr)
+    {
+        issued_token->issuer_epr = issuer_epr;
+        return AXIS2_SUCCESS;
+    }
+
+    return AXIS2_FAILURE;
+}
+
+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)
+{
+    return issued_token->requested_sec_token_template;
+}
+
+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)
+{
+    if(req_sec_token_template)
+    {
+        issued_token->requested_sec_token_template = req_sec_token_template;
+        return AXIS2_SUCCESS;
+    }
+
+    return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_issued_token_get_derivedkeys(
+    rp_issued_token_t *issued_token,
+    const axutil_env_t *env)
+{
+    return issued_token->derivedkeys;
+}
+
+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_PARAM_CHECK(env->error, derivedkeys, AXIS2_FAILURE);
+    issued_token->derivedkeys = derivedkeys;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return issued_token->require_external_reference;
+}
+
+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_PARAM_CHECK(env->error, require_external_reference, AXIS2_FAILURE);
+    issued_token->require_external_reference = require_external_reference;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return issued_token->require_internal_reference;
+}
+
+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_PARAM_CHECK(env->error, require_internal_reference, AXIS2_FAILURE);
+    issued_token->require_internal_reference = require_internal_reference;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_issued_token_increment_ref(
+    rp_issued_token_t *issued_token,
+    const axutil_env_t *env)
+{
+    issued_token->ref++;
+    return AXIS2_SUCCESS;
+}
+
diff --git a/neethi/src/secpolicy/model/layout.c b/neethi/src/secpolicy/model/layout.c
new file mode 100644
index 0000000..b4591c4
--- /dev/null
+++ b/neethi/src/secpolicy/model/layout.c
@@ -0,0 +1,99 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_layout.h>
+
+struct rp_layout_t
+{
+    axis2_char_t *value;
+    int ref;
+};
+
+AXIS2_EXTERN rp_layout_t *AXIS2_CALL
+rp_layout_create(
+    const axutil_env_t * env)
+{
+    rp_layout_t *layout = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    layout = (rp_layout_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_layout_t));
+
+    if(layout == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    layout->value = RP_LAYOUT_STRICT;
+    layout->ref = 0;
+    return layout;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_layout_free(
+    rp_layout_t * layout,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(layout)
+    {
+        if(--(layout->ref) > 0)
+        {
+            return;
+        }
+        AXIS2_FREE(env->allocator, layout);
+        layout = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_layout_get_value(
+    rp_layout_t * layout,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return layout->value;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE);
+
+    layout->value = value;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_layout_increment_ref(
+    rp_layout_t * layout,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    layout->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/property.c b/neethi/src/secpolicy/model/property.c
new file mode 100644
index 0000000..a8d806c
--- /dev/null
+++ b/neethi/src/secpolicy/model/property.c
@@ -0,0 +1,265 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_property.h>
+#include <rp_symmetric_binding.h>
+#include <rp_asymmetric_binding.h>
+#include <rp_transport_binding.h>
+#include <rp_supporting_tokens.h>
+#include <rp_wss10.h>
+#include <rp_wss11.h>
+
+struct rp_property_t
+{
+    rp_property_type_t type;
+    void *value;
+    int ref;
+};
+
+AXIS2_EXTERN rp_property_t *AXIS2_CALL
+rp_property_create(
+    const axutil_env_t * env)
+{
+    rp_property_t *property = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    property = (rp_property_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_property_t));
+
+    if(property == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    property->type = RP_PROPERTY_UNKNOWN;
+    property->value = NULL;
+    property->ref = 0;
+
+    return property;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_property_free(
+    rp_property_t * property,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(property)
+    {
+        if(--(property->ref) > 0)
+        {
+            return;
+        }
+
+        if(property->value)
+        {
+            switch(property->type)
+            {
+                case RP_PROPERTY_USERNAME_TOKEN:
+                    rp_username_token_free((rp_username_token_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_X509_TOKEN:
+                    rp_x509_token_free((rp_x509_token_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_ISSUED_TOKEN:
+                    rp_issued_token_free((rp_issued_token_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_SAML_TOKEN:
+                    rp_saml_token_free((rp_saml_token_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_SECURITY_CONTEXT_TOKEN:
+                    rp_security_context_token_free((rp_security_context_token_t *)property->value,
+                        env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_HTTPS_TOKEN:
+                    rp_https_token_free((rp_https_token_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_SYMMETRIC_BINDING:
+                    rp_symmetric_binding_free((rp_symmetric_binding_t *)property-> value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_ASYMMETRIC_BINDING:
+                    rp_asymmetric_binding_free((rp_asymmetric_binding_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_TRANSPORT_BINDING:
+                    rp_transport_binding_free((rp_transport_binding_t *)property-> value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_SIGNED_SUPPORTING_TOKEN:
+                    rp_supporting_tokens_free((rp_supporting_tokens_t *)property-> value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN:
+                    rp_supporting_tokens_free((rp_supporting_tokens_t *)property-> value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN:
+                    rp_supporting_tokens_free((rp_supporting_tokens_t *)property-> value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN:
+                    rp_supporting_tokens_free((rp_supporting_tokens_t *)property-> value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_SUPPORTING_TOKEN:
+                    rp_supporting_tokens_free((rp_supporting_tokens_t *)property-> value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_WSS10:
+                    rp_wss10_free((rp_wss10_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_WSS11:
+                    rp_wss11_free((rp_wss11_t *)property->value, env);
+                    property->value = NULL;
+                    break;
+
+                case RP_PROPERTY_UNKNOWN:
+                    break;
+            }
+        }
+        AXIS2_FREE(env->allocator, property);
+    }
+
+    return;
+}
+
+/* Implementations */
+AXIS2_EXTERN void *AXIS2_CALL
+rp_property_get_value(
+    rp_property_t * property,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return property->value;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE);
+
+    property->type = type;
+
+    if(type == RP_PROPERTY_X509_TOKEN)
+    {
+        rp_x509_token_increment_ref((rp_x509_token_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_SECURITY_CONTEXT_TOKEN)
+    {
+        rp_security_context_token_increment_ref((rp_security_context_token_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_WSS10)
+    {
+        rp_wss10_increment_ref((rp_wss10_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_WSS11)
+    {
+        rp_wss11_increment_ref((rp_wss11_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_USERNAME_TOKEN)
+    {
+        rp_username_token_increment_ref((rp_username_token_t *)value, env);
+    }
+
+    else if(type == RP_PROPERTY_HTTPS_TOKEN)
+    {
+        rp_https_token_increment_ref((rp_https_token_t *)value, env);
+    }
+
+    else if(type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
+    {
+        rp_supporting_tokens_increment_ref((rp_supporting_tokens_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
+    {
+        rp_supporting_tokens_increment_ref((rp_supporting_tokens_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
+    {
+        rp_supporting_tokens_increment_ref((rp_supporting_tokens_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
+    {
+        rp_supporting_tokens_increment_ref((rp_supporting_tokens_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_ASYMMETRIC_BINDING)
+    {
+        rp_asymmetric_binding_increment_ref((rp_asymmetric_binding_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_TRANSPORT_BINDING)
+    {
+        rp_transport_binding_increment_ref((rp_transport_binding_t *)value, env);
+    }
+    else if(type == RP_PROPERTY_SYMMETRIC_BINDING)
+    {
+        rp_symmetric_binding_increment_ref((rp_symmetric_binding_t *)value, env);
+    }
+    property->value = (void *)value;
+
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN rp_property_type_t AXIS2_CALL
+rp_property_get_type(
+    rp_property_t * property,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return property->type;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_property_increment_ref(
+    rp_property_t * property,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    property->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/rampart_config.c b/neethi/src/secpolicy/model/rampart_config.c
new file mode 100644
index 0000000..ba8bebd
--- /dev/null
+++ b/neethi/src/secpolicy/model/rampart_config.c
@@ -0,0 +1,446 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_rampart_config.h>
+
+struct rp_rampart_config_t
+{
+    axis2_char_t *user;
+    axis2_char_t *encryption_user;
+    axis2_char_t *password_callback_class;
+    axis2_char_t *authenticate_module;
+    axis2_char_t *replay_detector;
+    axis2_char_t *sct_provider;
+    axis2_char_t *password_type;
+    axis2_char_t *time_to_live;
+    axis2_char_t *clock_skew_buffer;
+    axis2_char_t *need_millisecond_precision;
+    axis2_char_t *receiver_certificate_file;
+    axis2_char_t *certificate_file;
+    axis2_char_t *private_key_file;
+    axis2_char_t *pkcs12_file;
+    axis2_char_t *rd_val;
+    int ref;
+};
+
+AXIS2_EXTERN rp_rampart_config_t *AXIS2_CALL
+rp_rampart_config_create(
+    const axutil_env_t * env)
+{
+    rp_rampart_config_t *rampart_config = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    rampart_config = (rp_rampart_config_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_rampart_config_t));
+
+    if(rampart_config == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    rampart_config->user = NULL;
+    rampart_config->encryption_user = NULL;
+    rampart_config->password_callback_class = NULL;
+    rampart_config->private_key_file = NULL;
+    rampart_config->receiver_certificate_file = NULL;
+    rampart_config->certificate_file = NULL;
+    rampart_config->authenticate_module = NULL;
+    rampart_config->replay_detector = NULL;
+    rampart_config->sct_provider = NULL;
+    rampart_config->password_type = NULL;
+    rampart_config->time_to_live = NULL;
+    rampart_config->clock_skew_buffer = NULL;
+    rampart_config->need_millisecond_precision = NULL;
+    rampart_config->pkcs12_file = NULL;
+    rampart_config->rd_val = NULL;
+    rampart_config->ref = 0;
+
+    return rampart_config;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_rampart_config_free(
+    rp_rampart_config_t * rampart_config,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(rampart_config)
+    {
+        if(--(rampart_config->ref) > 0)
+        {
+            return;
+        }
+
+        AXIS2_FREE(env->allocator, rampart_config);
+        rampart_config = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_rampart_config_get_user(
+    rp_rampart_config_t * rampart_config,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->user;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, user, AXIS2_FAILURE);
+
+    rampart_config->user = user;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->encryption_user;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, encryption_user, AXIS2_FAILURE);
+
+    rampart_config->encryption_user = encryption_user;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->password_callback_class;
+}
+
+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 * password_callback_class)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, password_callback_class, AXIS2_FAILURE);
+
+    rampart_config->password_callback_class = password_callback_class;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->authenticate_module;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, authenticate_module, AXIS2_FAILURE);
+
+    rampart_config->authenticate_module = authenticate_module;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->replay_detector;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, replay_detector, AXIS2_FAILURE);
+
+    rampart_config->replay_detector = replay_detector;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->sct_provider;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, sct_module, AXIS2_FAILURE);
+
+    rampart_config->sct_provider = sct_module;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->password_type;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, password_type, AXIS2_FAILURE);
+
+    rampart_config->password_type = password_type;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->private_key_file;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, private_key_file, AXIS2_FAILURE);
+
+    rampart_config->private_key_file = private_key_file;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->receiver_certificate_file;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, receiver_certificate_file, AXIS2_FAILURE);
+
+    rampart_config->receiver_certificate_file = receiver_certificate_file;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->certificate_file;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, certificate_file, AXIS2_FAILURE);
+
+    rampart_config->certificate_file = certificate_file;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->time_to_live;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, time_to_live, AXIS2_FAILURE);
+
+    rampart_config->time_to_live = time_to_live;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rampart_config->clock_skew_buffer;
+}
+
+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)
+{
+    rampart_config->clock_skew_buffer = clock_skew_buffer;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rampart_config->need_millisecond_precision;
+}
+
+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)
+{
+    rampart_config->need_millisecond_precision = need_millisecond_precision;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_rampart_config_get_pkcs12_file(
+    rp_rampart_config_t * rampart_config,
+    const axutil_env_t * env)
+{
+    return rampart_config->pkcs12_file;
+}
+
+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)
+{
+    if(rampart_config)
+    {
+        if(pkcs12_file)
+        {
+            rampart_config->pkcs12_file = pkcs12_file;
+            return AXIS2_SUCCESS;
+        }
+
+        return AXIS2_FAILURE;
+    }
+
+    return AXIS2_FAILURE;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return rampart_config->rd_val;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, rd_val, AXIS2_FAILURE);
+
+    rampart_config->rd_val = rd_val;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_rampart_config_increment_ref(
+    rp_rampart_config_t * rampart_config,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    rampart_config->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/saml_token.c b/neethi/src/secpolicy/model/saml_token.c
new file mode 100644
index 0000000..ae0f1ea
--- /dev/null
+++ b/neethi/src/secpolicy/model/saml_token.c
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_saml_token.h>
+
+struct rp_saml_token
+{
+    axis2_char_t *inclusion;
+    axis2_bool_t derivedkeys;
+    axis2_bool_t require_key_identifier_reference;
+    axis2_char_t *token_version_and_type;
+    int ref;
+};
+
+AXIS2_EXTERN rp_saml_token_t * AXIS2_CALL
+rp_saml_token_create(
+    const axutil_env_t *env)
+{
+    rp_saml_token_t * saml_token;
+
+    saml_token = (rp_saml_token_t*)AXIS2_MALLOC(env->allocator, sizeof(rp_saml_token_t));
+
+    if(saml_token == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    saml_token->inclusion = NULL;
+    saml_token->derivedkeys = AXIS2_FALSE;
+    saml_token->require_key_identifier_reference = AXIS2_FALSE;
+    saml_token->token_version_and_type = NULL;
+    saml_token->ref = 0;
+
+    return saml_token;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_saml_token_free(
+    rp_saml_token_t *saml_token,
+    const axutil_env_t *env)
+{
+    if(saml_token)
+    {
+        if(--(saml_token->ref) > 0)
+        {
+            return;
+        }
+
+        AXIS2_FREE(env->allocator, saml_token);
+        saml_token = NULL;
+    }
+
+    return;
+}
+
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+rp_saml_token_get_inclusion(
+    rp_saml_token_t *saml_token,
+    const axutil_env_t *env)
+{
+    return saml_token->inclusion;
+}
+
+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_PARAM_CHECK(env->error, inclusion, AXIS2_FAILURE);
+    saml_token->inclusion = inclusion;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_saml_token_get_derivedkeys(
+    rp_saml_token_t *saml_token,
+    const axutil_env_t *env)
+{
+    return saml_token->derivedkeys;
+}
+
+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_PARAM_CHECK(env->error, derivedkeys, AXIS2_FAILURE);
+    saml_token->derivedkeys = derivedkeys;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return saml_token->require_key_identifier_reference;
+}
+
+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_PARAM_CHECK(env->error, require_key_identifier_reference, AXIS2_FAILURE);
+    saml_token->require_key_identifier_reference = require_key_identifier_reference;
+
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return saml_token->token_version_and_type;
+}
+
+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_PARAM_CHECK(env->error, token_version_and_type, AXIS2_FAILURE);
+
+    saml_token->token_version_and_type = token_version_and_type;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_saml_token_increment_ref(
+    rp_saml_token_t * saml_token,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    saml_token->ref++;
+    return AXIS2_SUCCESS;
+}
+
diff --git a/neethi/src/secpolicy/model/secpolicy.c b/neethi/src/secpolicy/model/secpolicy.c
new file mode 100644
index 0000000..fdd112c
--- /dev/null
+++ b/neethi/src/secpolicy/model/secpolicy.c
@@ -0,0 +1,493 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_secpolicy.h>
+
+struct rp_secpolicy_t
+{
+    rp_property_t *binding;
+    rp_property_t *wss;
+    rp_trust10_t *trust10;
+    rp_supporting_tokens_t *supporting_tokens;
+    rp_supporting_tokens_t *signed_supporting_tokens;
+    rp_supporting_tokens_t *endorsing_supporting_tokens;
+    rp_supporting_tokens_t *signed_endorsing_supporting_tokens;
+    rp_signed_encrypted_parts_t *signed_parts;
+    rp_signed_encrypted_parts_t *encrypted_parts;
+    rp_signed_encrypted_elements_t *signed_elements;
+    rp_signed_encrypted_elements_t *encrypted_elements;
+    rp_signed_encrypted_items_t *signed_items;
+    rp_signed_encrypted_items_t *encrypted_items;
+    rp_rampart_config_t *rampart_config;
+
+};
+
+AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL
+rp_secpolicy_create(
+    const axutil_env_t * env)
+{
+    rp_secpolicy_t *secpolicy = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    secpolicy = (rp_secpolicy_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_secpolicy_t));
+
+    if(secpolicy == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    secpolicy->binding = NULL;
+    secpolicy->wss = NULL;
+    secpolicy->trust10 = NULL;
+    secpolicy->supporting_tokens = NULL;
+    secpolicy->signed_supporting_tokens = NULL;
+    secpolicy->endorsing_supporting_tokens = NULL;
+    secpolicy->signed_endorsing_supporting_tokens = NULL;
+    secpolicy->signed_parts = NULL;
+    secpolicy->encrypted_parts = NULL;
+    secpolicy->signed_elements = NULL;
+    secpolicy->encrypted_elements = NULL;
+    secpolicy->signed_items = NULL;
+    secpolicy->encrypted_items = NULL;
+    secpolicy->rampart_config = NULL;
+
+    return secpolicy;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_secpolicy_free(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(secpolicy)
+    {
+        if(secpolicy->binding)
+        {
+            rp_property_free(secpolicy->binding, env);
+            secpolicy->binding = NULL;
+        }
+        if(secpolicy->wss)
+        {
+            rp_property_free(secpolicy->wss, env);
+            secpolicy->wss = NULL;
+        }
+        if(secpolicy->trust10)
+        {
+            rp_trust10_free(secpolicy->trust10, env);
+            secpolicy->trust10 = NULL;
+        }
+        if(secpolicy->supporting_tokens)
+        {
+            rp_supporting_tokens_free(secpolicy->supporting_tokens, env);
+            secpolicy->supporting_tokens = NULL;
+        }
+        if(secpolicy->signed_supporting_tokens)
+        {
+            rp_supporting_tokens_free(secpolicy->signed_supporting_tokens, env);
+            secpolicy->signed_supporting_tokens = NULL;
+        }
+        if(secpolicy->endorsing_supporting_tokens)
+        {
+            rp_supporting_tokens_free(secpolicy->endorsing_supporting_tokens, env);
+            secpolicy->endorsing_supporting_tokens = NULL;
+        }
+        if(secpolicy->signed_endorsing_supporting_tokens)
+        {
+            rp_supporting_tokens_free(secpolicy-> signed_endorsing_supporting_tokens, env);
+            secpolicy->signed_endorsing_supporting_tokens = NULL;
+        }
+        if(secpolicy->signed_parts)
+        {
+            rp_signed_encrypted_parts_free(secpolicy->signed_parts, env);
+            secpolicy->signed_parts = NULL;
+        }
+        if(secpolicy->encrypted_parts)
+        {
+            rp_signed_encrypted_parts_free(secpolicy->encrypted_parts, env);
+            secpolicy->encrypted_parts = NULL;
+        }
+        if(secpolicy->signed_elements)
+        {
+            rp_signed_encrypted_elements_free(secpolicy->signed_elements, env);
+            secpolicy->signed_elements = NULL;
+        }
+        if(secpolicy->encrypted_elements)
+        {
+            rp_signed_encrypted_elements_free(secpolicy->encrypted_elements, env);
+            secpolicy->encrypted_elements = NULL;
+        }
+        if(secpolicy->signed_items)
+        {
+            rp_signed_encrypted_items_free(secpolicy->signed_items, env);
+            secpolicy->signed_items = NULL;
+        }
+        if(secpolicy->encrypted_items)
+        {
+            rp_signed_encrypted_items_free(secpolicy->encrypted_items, env);
+            secpolicy->encrypted_items = NULL;
+        }
+        if(secpolicy->rampart_config)
+        {
+            rp_rampart_config_free(secpolicy->rampart_config, env);
+            secpolicy->rampart_config = NULL;
+        }
+        AXIS2_FREE(env->allocator, secpolicy);
+    }
+
+    return;
+}
+
+/* Implementations */
+AXIS2_EXTERN rp_property_t *AXIS2_CALL
+rp_secpolicy_get_binding(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->binding;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, binding, AXIS2_FAILURE);
+    rp_property_increment_ref(binding, env);
+    secpolicy->binding = binding;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, supporting_tokens, AXIS2_FAILURE);
+
+    rp_supporting_tokens_increment_ref(supporting_tokens, env);
+    secpolicy->supporting_tokens = supporting_tokens;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
+rp_secpolicy_get_supporting_tokens(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->supporting_tokens;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_supporting_tokens, AXIS2_FAILURE);
+
+    rp_supporting_tokens_increment_ref(signed_supporting_tokens, env);
+    secpolicy->signed_supporting_tokens = signed_supporting_tokens;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
+rp_secpolicy_get_signed_supporting_tokens(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->signed_supporting_tokens;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, endorsing_supporting_tokens, AXIS2_FAILURE);
+
+    rp_supporting_tokens_increment_ref(endorsing_supporting_tokens, env);
+    secpolicy->endorsing_supporting_tokens = endorsing_supporting_tokens;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
+rp_secpolicy_get_endorsing_supporting_tokens(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->endorsing_supporting_tokens;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_endorsing_supporting_tokens, AXIS2_FAILURE);
+
+    rp_supporting_tokens_increment_ref(signed_endorsing_supporting_tokens, env);
+    secpolicy->signed_endorsing_supporting_tokens = signed_endorsing_supporting_tokens;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->signed_endorsing_supporting_tokens;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_parts, AXIS2_FAILURE);
+    rp_signed_encrypted_parts_increment_ref(signed_parts, env);
+    secpolicy->signed_parts = signed_parts;
+
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
+rp_secpolicy_get_signed_parts(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->signed_parts;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, encrypted_parts, AXIS2_FAILURE);
+
+    rp_signed_encrypted_parts_increment_ref(encrypted_parts, env);
+    secpolicy->encrypted_parts = encrypted_parts;
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
+rp_secpolicy_get_encrypted_parts(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->encrypted_parts;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_elements, AXIS2_FAILURE);
+
+    rp_signed_encrypted_elements_increment_ref(signed_elements, env);
+    secpolicy->signed_elements = signed_elements;
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
+rp_secpolicy_get_signed_elements(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->signed_elements;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, encrypted_elements, AXIS2_FAILURE);
+
+    rp_signed_encrypted_elements_increment_ref(encrypted_elements, env);
+    secpolicy->encrypted_elements = encrypted_elements;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
+rp_secpolicy_get_encrypted_elements(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->encrypted_elements;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_items, AXIS2_FAILURE);
+
+    secpolicy->signed_items = signed_items;
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL
+rp_secpolicy_get_signed_items(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->signed_items;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, encrypted_items, AXIS2_FAILURE);
+
+    secpolicy->encrypted_items = encrypted_items;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL
+rp_secpolicy_get_encrypted_items(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->encrypted_items;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, wss, AXIS2_FAILURE);
+
+    rp_property_increment_ref(wss, env);
+    secpolicy->wss = wss;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_property_t *AXIS2_CALL
+rp_secpolicy_get_wss(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->wss;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, trust10, AXIS2_FAILURE);
+
+    rp_trust10_increment_ref(trust10, env);
+    secpolicy->trust10 = trust10;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_trust10_t *AXIS2_CALL
+rp_secpolicy_get_trust10(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->trust10;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, rampart_config, AXIS2_FAILURE);
+
+    rp_rampart_config_increment_ref(rampart_config, env);
+    secpolicy->rampart_config = rampart_config;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_rampart_config_t *AXIS2_CALL
+rp_secpolicy_get_rampart_config(
+    rp_secpolicy_t * secpolicy,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return secpolicy->rampart_config;
+}
diff --git a/neethi/src/secpolicy/model/security_context_token.c b/neethi/src/secpolicy/model/security_context_token.c
new file mode 100644
index 0000000..9b00465
--- /dev/null
+++ b/neethi/src/secpolicy/model/security_context_token.c
@@ -0,0 +1,239 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_security_context_token.h>
+
+struct rp_security_context_token_t
+{
+    rp_token_t *token;
+    axis2_bool_t require_external_uri_ref;
+    axis2_bool_t sc10_security_context_token;
+    neethi_policy_t *bootstrap_policy;
+    axis2_bool_t is_secure_conversation_token;
+    int ref;
+};
+
+AXIS2_EXTERN rp_security_context_token_t *AXIS2_CALL
+rp_security_context_token_create(
+    const axutil_env_t * env)
+{
+    rp_security_context_token_t *security_context_token = NULL;
+
+    security_context_token = (rp_security_context_token_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_security_context_token_t));
+
+    if(!security_context_token)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] Security context token assertion creation failed. Insufficient memory");
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    security_context_token->ref = 0;
+    security_context_token->require_external_uri_ref = AXIS2_FALSE;
+    security_context_token->sc10_security_context_token = AXIS2_FALSE;
+    security_context_token->bootstrap_policy = NULL;
+    security_context_token->is_secure_conversation_token = AXIS2_FALSE;
+
+    security_context_token->token = rp_token_create(env);
+    if(!security_context_token->token)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] Security context token assertion creation failed.");
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        rp_security_context_token_free(security_context_token, env);
+        return NULL;
+    }
+
+    return security_context_token;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_security_context_token_free(
+    rp_security_context_token_t * security_context_token,
+    const axutil_env_t * env)
+{
+    if(security_context_token)
+    {
+        if(--(security_context_token->ref) > 0)
+        {
+            return;
+        }
+
+        if(security_context_token->bootstrap_policy)
+        {
+            neethi_policy_free(security_context_token->bootstrap_policy, env);
+        }
+
+        rp_token_free(security_context_token->token, env);
+        AXIS2_FREE(env->allocator, security_context_token);
+        security_context_token = NULL;
+    }
+}
+
+/* Implementations */
+
+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)
+{
+    return rp_token_get_inclusion(security_context_token->token, 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)
+{
+    return rp_token_set_inclusion(security_context_token->token, env, 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)
+{
+    return rp_token_get_derivedkey_type(security_context_token->token, 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)
+{
+    return rp_token_set_derivedkey_type(security_context_token->token, env, 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)
+{
+    return rp_token_get_derive_key_version(security_context_token->token, 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)
+{
+    return rp_token_set_derive_key_version(security_context_token->token, env, 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)
+{
+    return security_context_token->require_external_uri_ref;
+}
+
+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)
+{
+    security_context_token->require_external_uri_ref = require_external_uri_ref;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return security_context_token->sc10_security_context_token;
+}
+
+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)
+{
+    security_context_token->sc10_security_context_token = sc10_security_context_token;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return rp_token_get_issuer(security_context_token->token, 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)
+{
+    return rp_token_set_issuer(security_context_token->token, env, 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)
+{
+    return security_context_token->bootstrap_policy;
+}
+
+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)
+{
+    security_context_token->bootstrap_policy = bootstrap_policy;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return security_context_token->is_secure_conversation_token;
+}
+
+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)
+{
+    security_context_token->is_secure_conversation_token = is_secure_conversation_token;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    security_context_token->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/signed_encrypted_elements.c b/neethi/src/secpolicy/model/signed_encrypted_elements.c
new file mode 100644
index 0000000..b656f0f
--- /dev/null
+++ b/neethi/src/secpolicy/model/signed_encrypted_elements.c
@@ -0,0 +1,180 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_signed_encrypted_elements.h>
+
+struct rp_signed_encrypted_elements_t
+{
+    axis2_bool_t signedelements;
+    axutil_array_list_t *xpath_expressions;
+    axis2_char_t *xpath_version;
+    int ref;
+
+};
+
+AXIS2_EXTERN rp_signed_encrypted_elements_t *AXIS2_CALL
+rp_signed_encrypted_elements_create(
+    const axutil_env_t * env)
+{
+    rp_signed_encrypted_elements_t *signed_encrypted_elements = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    signed_encrypted_elements = (rp_signed_encrypted_elements_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_signed_encrypted_elements_t));
+
+    if(signed_encrypted_elements == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    signed_encrypted_elements->xpath_expressions = NULL;
+
+    signed_encrypted_elements->xpath_expressions = axutil_array_list_create(env, 0);
+    if(!(signed_encrypted_elements->xpath_expressions))
+    {
+        rp_signed_encrypted_elements_free(signed_encrypted_elements, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    signed_encrypted_elements->xpath_version = NULL;
+    signed_encrypted_elements->ref = 0;
+
+    return signed_encrypted_elements;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_signed_encrypted_elements_free(
+    rp_signed_encrypted_elements_t * signed_encrypted_elements,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(signed_encrypted_elements)
+    {
+        if(--(signed_encrypted_elements->ref) > 0)
+        {
+            return;
+        }
+
+        if(signed_encrypted_elements->xpath_expressions)
+        {
+            int i = 0;
+            for(i = 0; i < axutil_array_list_size(signed_encrypted_elements-> xpath_expressions,
+                env); i++)
+            {
+                axis2_char_t *expression = NULL;
+                expression = (axis2_char_t *)axutil_array_list_get(
+                    signed_encrypted_elements-> xpath_expressions, env, i);
+                if(expression)
+                    AXIS2_FREE(env->allocator, expression);
+
+                expression = NULL;
+            }
+            axutil_array_list_free(signed_encrypted_elements->xpath_expressions, env);
+            signed_encrypted_elements->xpath_expressions = NULL;
+
+        }
+        AXIS2_FREE(env->allocator, signed_encrypted_elements);
+        signed_encrypted_elements = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return signed_encrypted_elements->signedelements;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signedelements, AXIS2_FAILURE);
+
+    signed_encrypted_elements->signedelements = signedelements;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return signed_encrypted_elements->xpath_expressions;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, expression, AXIS2_FAILURE);
+
+    axutil_array_list_add(signed_encrypted_elements->xpath_expressions, env, expression);
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return signed_encrypted_elements->xpath_version;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, xpath_version, AXIS2_FAILURE);
+
+    signed_encrypted_elements->xpath_version = xpath_version;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    signed_encrypted_elements->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/signed_encrypted_items.c b/neethi/src/secpolicy/model/signed_encrypted_items.c
new file mode 100644
index 0000000..e3e6150
--- /dev/null
+++ b/neethi/src/secpolicy/model/signed_encrypted_items.c
@@ -0,0 +1,136 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_signed_encrypted_items.h>
+
+struct rp_signed_encrypted_items_t
+{
+    axis2_bool_t signeditems;
+    axutil_array_list_t *elements;
+
+};
+
+AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL
+rp_signed_encrypted_items_create(
+    const axutil_env_t * env)
+{
+    rp_signed_encrypted_items_t *signed_encrypted_items = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    signed_encrypted_items = (rp_signed_encrypted_items_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_signed_encrypted_items_t));
+
+    if(signed_encrypted_items == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    signed_encrypted_items->elements = NULL;
+
+    signed_encrypted_items->elements = axutil_array_list_create(env, 0);
+    if(!(signed_encrypted_items->elements))
+    {
+        rp_signed_encrypted_items_free(signed_encrypted_items, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    return signed_encrypted_items;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_signed_encrypted_items_free(
+    rp_signed_encrypted_items_t * signed_encrypted_items,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(signed_encrypted_items)
+    {
+
+        if(signed_encrypted_items->elements)
+        {
+            int i = 0;
+            for(i = 0; i < axutil_array_list_size(signed_encrypted_items->elements, env); i++)
+            {
+                rp_element_t *element = NULL;
+                element = (rp_element_t *)axutil_array_list_get(signed_encrypted_items->elements,
+                    env, i);
+                if(element)
+                    rp_element_free(element, env);
+
+                element = NULL;
+            }
+            axutil_array_list_free(signed_encrypted_items->elements, env);
+            signed_encrypted_items->elements = NULL;
+
+        }
+        AXIS2_FREE(env->allocator, signed_encrypted_items);
+        signed_encrypted_items = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return signed_encrypted_items->signeditems;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signeditems, AXIS2_FAILURE);
+    signed_encrypted_items->signeditems = signeditems;
+
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return signed_encrypted_items->elements;
+}
+
+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)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, element, AXIS2_FAILURE);
+
+    axutil_array_list_add(signed_encrypted_items->elements, env, element);
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/signed_encrypted_parts.c b/neethi/src/secpolicy/model/signed_encrypted_parts.c
new file mode 100644
index 0000000..0f16e83
--- /dev/null
+++ b/neethi/src/secpolicy/model/signed_encrypted_parts.c
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_signed_encrypted_parts.h>
+
+struct rp_signed_encrypted_parts_t
+{
+    axis2_bool_t body;
+    axis2_bool_t signedparts;
+    axis2_bool_t attachments;
+    axutil_array_list_t *headers;
+    int ref;
+};
+
+AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
+rp_signed_encrypted_parts_create(
+    const axutil_env_t * env)
+{
+    rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
+    signed_encrypted_parts = (rp_signed_encrypted_parts_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_signed_encrypted_parts_t));
+
+    if(!signed_encrypted_parts)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] Cannot create signed_encrypted_parts. Insuficient memory.");
+        return NULL;
+    }
+
+    signed_encrypted_parts->headers = axutil_array_list_create(env, 0);
+    if(!signed_encrypted_parts->headers)
+    {
+        rp_signed_encrypted_parts_free(signed_encrypted_parts, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] Cannot create signed_encrypted_parts. Headers array list creation failed.");
+        return NULL;
+    }
+
+    signed_encrypted_parts->body = AXIS2_FALSE;
+    signed_encrypted_parts->ref = 0;
+    signed_encrypted_parts->signedparts = AXIS2_FALSE;
+    signed_encrypted_parts->attachments = AXIS2_FALSE;
+    return signed_encrypted_parts;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_signed_encrypted_parts_free(
+    rp_signed_encrypted_parts_t * signed_encrypted_parts,
+    const axutil_env_t * env)
+{
+    if(signed_encrypted_parts)
+    {
+        if(--(signed_encrypted_parts->ref) > 0)
+        {
+            return;
+        }
+
+        if(signed_encrypted_parts->headers)
+        {
+            int i = 0;
+            for(i = 0; i < axutil_array_list_size(signed_encrypted_parts->headers, env); i++)
+            {
+                rp_header_t *header = NULL;
+                header = (rp_header_t *)axutil_array_list_get(signed_encrypted_parts->headers, env,
+                    i);
+                if(header)
+                {
+                    rp_header_free(header, env);
+                }
+            }
+            axutil_array_list_free(signed_encrypted_parts->headers, env);
+            signed_encrypted_parts->headers = NULL;
+        }
+        AXIS2_FREE(env->allocator, signed_encrypted_parts);
+        signed_encrypted_parts = NULL;
+    }
+}
+
+/* Implementations */
+
+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)
+{
+    return signed_encrypted_parts->body;
+}
+
+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_PARAM_CHECK(env->error, body, AXIS2_FAILURE);
+    signed_encrypted_parts->body = body;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return signed_encrypted_parts->signedparts;
+}
+
+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)
+{
+    signed_encrypted_parts->signedparts = signedparts;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return signed_encrypted_parts->headers;
+}
+
+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_PARAM_CHECK(env->error, header, AXIS2_FAILURE);
+    axutil_array_list_add(signed_encrypted_parts->headers, env, header);
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    signed_encrypted_parts->ref++;
+    return AXIS2_SUCCESS;
+}
+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)
+{
+    return signed_encrypted_parts->attachments;
+}
+
+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)
+{
+    signed_encrypted_parts->attachments = attachments;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/supporting_tokens.c b/neethi/src/secpolicy/model/supporting_tokens.c
new file mode 100644
index 0000000..7ec2d7f
--- /dev/null
+++ b/neethi/src/secpolicy/model/supporting_tokens.c
@@ -0,0 +1,300 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_supporting_tokens.h>
+
+struct rp_supporting_tokens_t
+{
+    rp_algorithmsuite_t *algorithmsuite;
+    axutil_array_list_t *tokens;
+    rp_signed_encrypted_elements_t *signed_elements;
+    rp_signed_encrypted_parts_t *signed_parts;
+    rp_signed_encrypted_elements_t *encrypted_elements;
+    rp_signed_encrypted_parts_t *encrypted_parts;
+    int type;
+    int ref;
+};
+
+AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
+rp_supporting_tokens_create(
+    const axutil_env_t * env)
+{
+    rp_supporting_tokens_t *supporting_tokens = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    supporting_tokens = (rp_supporting_tokens_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_supporting_tokens_t));
+
+    if(supporting_tokens == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    supporting_tokens->tokens = NULL;
+    supporting_tokens->tokens = axutil_array_list_create(env, 0);
+    if(!(supporting_tokens->tokens))
+    {
+        rp_supporting_tokens_free(supporting_tokens, env);
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+
+    supporting_tokens->algorithmsuite = NULL;
+    supporting_tokens->signed_parts = NULL;
+    supporting_tokens->signed_elements = NULL;
+    supporting_tokens->encrypted_parts = NULL;
+    supporting_tokens->encrypted_elements = NULL;
+    supporting_tokens->type = 0;
+    supporting_tokens->ref = 0;
+    return supporting_tokens;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_supporting_tokens_free(
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(supporting_tokens)
+    {
+
+        if(--(supporting_tokens->ref) > 0)
+        {
+            return;
+        }
+
+        if(supporting_tokens->tokens)
+        {
+            int i = 0;
+            for(i = 0; i < axutil_array_list_size(supporting_tokens->tokens, env); i++)
+            {
+                rp_property_t *token = NULL;
+                token = (rp_property_t *)axutil_array_list_get(supporting_tokens->tokens, env, i);
+                if(token)
+                    rp_property_free(token, env);
+
+                token = NULL;
+            }
+            axutil_array_list_free(supporting_tokens->tokens, env);
+            supporting_tokens->tokens = NULL;
+
+        }
+        if(supporting_tokens->algorithmsuite)
+        {
+            rp_algorithmsuite_free(supporting_tokens->algorithmsuite, env);
+            supporting_tokens->algorithmsuite = NULL;
+        }
+        if(supporting_tokens->signed_parts)
+        {
+            rp_signed_encrypted_parts_free(supporting_tokens->signed_parts, env);
+            supporting_tokens->signed_parts = NULL;
+        }
+        if(supporting_tokens->signed_elements)
+        {
+            rp_signed_encrypted_elements_free(supporting_tokens-> signed_elements, env);
+            supporting_tokens->signed_elements = NULL;
+        }
+        if(supporting_tokens->encrypted_parts)
+        {
+            rp_signed_encrypted_parts_free(supporting_tokens->encrypted_parts, env);
+            supporting_tokens->encrypted_parts = NULL;
+        }
+        if(supporting_tokens->encrypted_elements)
+        {
+            rp_signed_encrypted_elements_free(supporting_tokens-> encrypted_elements, env);
+            supporting_tokens->encrypted_elements = NULL;
+        }
+        AXIS2_FREE(env->allocator, supporting_tokens);
+        supporting_tokens = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return supporting_tokens->tokens;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, token, AXIS2_FAILURE);
+
+    rp_property_increment_ref(token, env);
+    axutil_array_list_add(supporting_tokens->tokens, env, token);
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN rp_algorithmsuite_t *AXIS2_CALL
+rp_supporting_tokens_get_algorithmsuite(
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, NULL);
+
+    return supporting_tokens->algorithmsuite;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, algorithmsuite, AXIS2_FAILURE);
+
+    rp_algorithmsuite_increment_ref(algorithmsuite, env);
+    supporting_tokens->algorithmsuite = algorithmsuite;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return supporting_tokens->signed_parts;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_parts, AXIS2_FAILURE);
+
+    supporting_tokens->signed_parts = signed_parts;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return supporting_tokens->signed_elements;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signed_elements, AXIS2_FAILURE);
+
+    supporting_tokens->signed_elements = signed_elements;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return supporting_tokens->encrypted_parts;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, encrypted_parts, AXIS2_FAILURE);
+
+    supporting_tokens->encrypted_parts = encrypted_parts;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return supporting_tokens->encrypted_elements;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, encrypted_elements, AXIS2_FAILURE);
+
+    supporting_tokens->encrypted_elements = encrypted_elements;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN int AXIS2_CALL
+rp_supporting_tokens_get_type(
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    return supporting_tokens->type;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    supporting_tokens->type = type;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_supporting_tokens_increment_ref(
+    rp_supporting_tokens_t * supporting_tokens,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    supporting_tokens->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/symmetric_asymmetric_binding_commons.c b/neethi/src/secpolicy/model/symmetric_asymmetric_binding_commons.c
new file mode 100644
index 0000000..06a4188
--- /dev/null
+++ b/neethi/src/secpolicy/model/symmetric_asymmetric_binding_commons.c
@@ -0,0 +1,192 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_symmetric_asymmetric_binding_commons.h>
+
+struct rp_symmetric_asymmetric_binding_commons_t
+{
+    rp_binding_commons_t *binding_commons;
+    axis2_char_t *protection_order;
+    axis2_bool_t signature_protection;
+    axis2_bool_t token_protection;
+    axis2_bool_t entire_headers_and_body_signatures;
+
+};
+
+AXIS2_EXTERN rp_symmetric_asymmetric_binding_commons_t *AXIS2_CALL
+rp_symmetric_asymmetric_binding_commons_create(
+    const axutil_env_t * env)
+{
+    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    symmetric_asymmetric_binding_commons
+        = (rp_symmetric_asymmetric_binding_commons_t *)AXIS2_MALLOC(env-> allocator,
+            sizeof(rp_symmetric_asymmetric_binding_commons_t));
+
+    if(symmetric_asymmetric_binding_commons == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    symmetric_asymmetric_binding_commons->binding_commons = NULL;
+    symmetric_asymmetric_binding_commons->protection_order = RP_SIGN_BEFORE_ENCRYPTING;
+    symmetric_asymmetric_binding_commons->signature_protection = AXIS2_FALSE;
+    symmetric_asymmetric_binding_commons->token_protection = AXIS2_FALSE;
+    symmetric_asymmetric_binding_commons->entire_headers_and_body_signatures = AXIS2_FALSE;
+
+    return symmetric_asymmetric_binding_commons;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(symmetric_asymmetric_binding_commons)
+    {
+        if(symmetric_asymmetric_binding_commons->binding_commons)
+        {
+            rp_binding_commons_free(symmetric_asymmetric_binding_commons-> binding_commons, env);
+            symmetric_asymmetric_binding_commons->binding_commons = NULL;
+        }
+        AXIS2_FREE(env->allocator, symmetric_asymmetric_binding_commons);
+        symmetric_asymmetric_binding_commons = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+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_ENV_CHECK(env, NULL);
+
+    return symmetric_asymmetric_binding_commons->binding_commons;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, binding_commons, AXIS2_FAILURE);
+
+    symmetric_asymmetric_binding_commons->binding_commons = binding_commons;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return symmetric_asymmetric_binding_commons->signature_protection;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signature_protection, AXIS2_FAILURE);
+    symmetric_asymmetric_binding_commons->signature_protection = signature_protection;
+
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return symmetric_asymmetric_binding_commons->token_protection;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, token_protection, AXIS2_FAILURE);
+
+    symmetric_asymmetric_binding_commons->token_protection = token_protection;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return symmetric_asymmetric_binding_commons-> entire_headers_and_body_signatures;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, entire_headers_and_body_signatures, AXIS2_FAILURE);
+
+    symmetric_asymmetric_binding_commons->entire_headers_and_body_signatures
+        = entire_headers_and_body_signatures;
+
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return symmetric_asymmetric_binding_commons->protection_order;
+}
+
+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)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, protection_order, AXIS2_FAILURE);
+
+    symmetric_asymmetric_binding_commons->protection_order = protection_order;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/symmetric_binding.c b/neethi/src/secpolicy/model/symmetric_binding.c
new file mode 100644
index 0000000..4d6dc2d
--- /dev/null
+++ b/neethi/src/secpolicy/model/symmetric_binding.c
@@ -0,0 +1,216 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_symmetric_binding.h>
+
+struct rp_symmetric_binding_t
+{
+    rp_symmetric_asymmetric_binding_commons_t *symmetric_asymmetric_binding_commons;
+    rp_property_t *protection_token;
+    rp_property_t *signature_token;
+    rp_property_t *encryption_token;
+    int ref;
+};
+
+AXIS2_EXTERN rp_symmetric_binding_t *AXIS2_CALL
+rp_symmetric_binding_create(
+    const axutil_env_t * env)
+{
+    rp_symmetric_binding_t *symmetric_binding = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    symmetric_binding = (rp_symmetric_binding_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_symmetric_binding_t));
+
+    if(symmetric_binding == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    symmetric_binding->symmetric_asymmetric_binding_commons = NULL;
+    symmetric_binding->protection_token = NULL;
+    symmetric_binding->signature_token = NULL;
+    symmetric_binding->encryption_token = NULL;
+    symmetric_binding->ref = 0;
+
+    return symmetric_binding;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_symmetric_binding_free(
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(symmetric_binding)
+    {
+        if(--(symmetric_binding->ref) > 0)
+        {
+            return;
+        }
+
+        if(symmetric_binding->symmetric_asymmetric_binding_commons)
+        {
+            rp_symmetric_asymmetric_binding_commons_free(
+                symmetric_binding-> symmetric_asymmetric_binding_commons, env);
+            symmetric_binding->symmetric_asymmetric_binding_commons = NULL;
+        }
+        if(symmetric_binding->protection_token)
+        {
+            rp_property_free(symmetric_binding->protection_token, env);
+            symmetric_binding->protection_token = NULL;
+        }
+        if(symmetric_binding->encryption_token)
+        {
+            rp_property_free(symmetric_binding->encryption_token, env);
+            symmetric_binding->encryption_token = NULL;
+        }
+        if(symmetric_binding->signature_token)
+        {
+            rp_property_free(symmetric_binding->signature_token, env);
+            symmetric_binding->signature_token = NULL;
+        }
+        AXIS2_FREE(env->allocator, symmetric_binding);
+    }
+
+    return;
+}
+
+/* Implementations */
+
+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_ENV_CHECK(env, NULL);
+
+    return symmetric_binding->symmetric_asymmetric_binding_commons;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, symmetric_asymmetric_binding_commons, AXIS2_FAILURE);
+
+    symmetric_binding->symmetric_asymmetric_binding_commons = symmetric_asymmetric_binding_commons;
+
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return symmetric_binding->protection_token;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, protection_token, AXIS2_FAILURE);
+    if(symmetric_binding->signature_token || symmetric_binding->encryption_token)
+    {
+        return AXIS2_FAILURE;
+    }
+    rp_property_increment_ref(protection_token, env);
+    symmetric_binding->protection_token = protection_token;
+
+    return AXIS2_SUCCESS;
+
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, encryption_token, AXIS2_FAILURE);
+    if(symmetric_binding->protection_token)
+    {
+        return AXIS2_FAILURE;
+    }
+    rp_property_increment_ref(encryption_token, env);
+    symmetric_binding->encryption_token = encryption_token;
+
+    return AXIS2_SUCCESS;
+
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return symmetric_binding->encryption_token;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, signature_token, AXIS2_FAILURE);
+    if(symmetric_binding->protection_token)
+    {
+        return AXIS2_FAILURE;
+    }
+    rp_property_increment_ref(signature_token, env);
+    symmetric_binding->signature_token = signature_token;
+
+    return AXIS2_SUCCESS;
+
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return symmetric_binding->signature_token;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_symmetric_binding_increment_ref(
+    rp_symmetric_binding_t * symmetric_binding,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    symmetric_binding->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/token.c b/neethi/src/secpolicy/model/token.c
new file mode 100644
index 0000000..ccb80e4
--- /dev/null
+++ b/neethi/src/secpolicy/model/token.c
@@ -0,0 +1,190 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_token.h>
+
+struct rp_token_t
+{
+    axis2_char_t *issuer;
+    axis2_char_t *inclusion;
+    axiom_node_t *claim;
+    axis2_bool_t is_issuer_name; /* shows whether 'issuer' points to issuer name or end point */
+    derive_key_type_t derive_key;
+    derive_key_version_t derive_key_version;
+    int ref;
+};
+
+AXIS2_EXTERN rp_token_t *AXIS2_CALL
+rp_token_create(
+    const axutil_env_t * env)
+{
+    rp_token_t *token = NULL;
+    token = (rp_token_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_token_t));
+
+    if(!token)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] Token creation failed. Insufficient memory");
+        return NULL;
+    }
+    token->issuer = NULL;
+    token->is_issuer_name = AXIS2_FALSE;
+    token->claim = NULL;
+    token->derive_key = DERIVEKEY_NONE;
+    token->derive_key_version = DERIVEKEY_VERSION_SC13;
+    token->inclusion = RP_INCLUDE_ALWAYS_SP12;
+    token->ref = 0;
+
+    return token;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_token_free(
+    rp_token_t * token,
+    const axutil_env_t * env)
+{
+    if(token)
+    {
+        if(--(token->ref) > 0)
+        {
+            return;
+        }
+
+        AXIS2_FREE(env->allocator, token);
+        token = NULL;
+    }
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_token_get_issuer(
+    rp_token_t * token,
+    const axutil_env_t * env)
+{
+    return token->issuer;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_token_set_issuer(
+    rp_token_t * token,
+    const axutil_env_t * env,
+    axis2_char_t * issuer)
+{
+    token->issuer = issuer;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    token->derive_key_version = version;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN derive_key_version_t AXIS2_CALL
+rp_token_get_derive_key_version(
+    rp_token_t *token,
+    const axutil_env_t *env)
+{
+    return token->derive_key_version;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_token_set_inclusion(
+    rp_token_t *token,
+    const axutil_env_t *env,
+    axis2_char_t *inclusion)
+{
+    token->inclusion = inclusion;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_token_get_inclusion(
+    rp_token_t *token,
+    const axutil_env_t *env)
+{
+    return token->inclusion;
+}
+
+AXIS2_EXTERN derive_key_type_t AXIS2_CALL
+rp_token_get_derivedkey_type(
+    rp_token_t * token,
+    const axutil_env_t * env)
+{
+    return token->derive_key;
+}
+
+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)
+{
+    token->derive_key = derivedkey;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_token_get_is_issuer_name(
+    rp_token_t * token,
+    const axutil_env_t * env)
+{
+    return token->is_issuer_name;
+}
+
+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)
+{
+    token->is_issuer_name = is_issuer_name;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+rp_token_get_claim(
+    rp_token_t * token,
+    const axutil_env_t * env)
+{
+    return token->claim;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_token_set_claim(
+    rp_token_t * token,
+    const axutil_env_t * env,
+    axiom_node_t *claim)
+{
+    token->claim = claim;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_token_increment_ref(
+    rp_token_t * token,
+    const axutil_env_t * env)
+{
+    token->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/transport_binding.c b/neethi/src/secpolicy/model/transport_binding.c
new file mode 100644
index 0000000..cb84fff
--- /dev/null
+++ b/neethi/src/secpolicy/model/transport_binding.c
@@ -0,0 +1,137 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_transport_binding.h>
+
+struct rp_transport_binding_t
+{
+    rp_binding_commons_t *binding_commons;
+    rp_property_t *transport_token;
+    int ref;
+};
+
+AXIS2_EXTERN rp_transport_binding_t *AXIS2_CALL
+rp_transport_binding_create(
+    const axutil_env_t * env)
+{
+    rp_transport_binding_t *transport_binding = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    transport_binding = (rp_transport_binding_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_transport_binding_t));
+
+    if(transport_binding == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    transport_binding->binding_commons = NULL;
+    transport_binding->transport_token = NULL;
+    transport_binding->ref = 0;
+
+    return transport_binding;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_transport_binding_free(
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(transport_binding)
+    {
+        if(--(transport_binding->ref) > 0)
+        {
+            return;
+        }
+        if(transport_binding->binding_commons)
+        {
+            rp_binding_commons_free(transport_binding->binding_commons, env);
+            transport_binding->binding_commons = NULL;
+        }
+        if(transport_binding->transport_token)
+        {
+            rp_property_free(transport_binding->transport_token, env);
+            transport_binding->transport_token = NULL;
+        }
+        AXIS2_FREE(env->allocator, transport_binding);
+    }
+
+    return;
+}
+
+/* Implementations */
+
+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_ENV_CHECK(env, NULL);
+
+    return transport_binding->binding_commons;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, binding_commons, AXIS2_FAILURE);
+
+    transport_binding->binding_commons = binding_commons;
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, NULL);
+
+    return transport_binding->transport_token;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, transport_token, AXIS2_FAILURE);
+
+    rp_property_increment_ref(transport_token, env);
+    transport_binding->transport_token = transport_token;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_transport_binding_increment_ref(
+    rp_transport_binding_t * transport_binding,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    transport_binding->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/trust10.c b/neethi/src/secpolicy/model/trust10.c
new file mode 100644
index 0000000..54d98c8
--- /dev/null
+++ b/neethi/src/secpolicy/model/trust10.c
@@ -0,0 +1,201 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_trust10.h>
+
+struct rp_trust10_t
+{
+    axis2_bool_t must_support_client_challenge;
+    axis2_bool_t must_support_server_challenge;
+    axis2_bool_t require_client_entropy;
+    axis2_bool_t require_server_entropy;
+    axis2_bool_t must_support_issued_token;
+    int ref;
+};
+
+AXIS2_EXTERN rp_trust10_t *AXIS2_CALL
+rp_trust10_create(
+    const axutil_env_t * env)
+{
+    rp_trust10_t *trust10 = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    trust10 = (rp_trust10_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_trust10_t));
+
+    if(trust10 == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    trust10->must_support_client_challenge = AXIS2_FALSE;
+    trust10->must_support_server_challenge = AXIS2_FALSE;
+    trust10->require_client_entropy = AXIS2_FALSE;
+    trust10->require_server_entropy = AXIS2_FALSE;
+    trust10->must_support_issued_token = AXIS2_FALSE;
+    trust10->ref = 0;
+
+    return trust10;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_trust10_free(
+    rp_trust10_t * trust10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(trust10)
+    {
+        if(--(trust10->ref) > 0)
+        {
+            return;
+        }
+
+        AXIS2_FREE(env->allocator, trust10);
+        trust10 = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_trust10_get_must_support_client_challenge(
+    rp_trust10_t * trust10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return trust10->must_support_client_challenge;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_client_challenge, AXIS2_FAILURE);
+    trust10->must_support_client_challenge = must_support_client_challenge;
+
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_trust10_get_must_support_server_challenge(
+    rp_trust10_t * trust10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return trust10->must_support_server_challenge;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_server_challenge, AXIS2_FAILURE);
+    trust10->must_support_server_challenge = must_support_server_challenge;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_trust10_get_require_client_entropy(
+    rp_trust10_t * trust10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return trust10->require_client_entropy;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, require_client_entropy, AXIS2_FAILURE);
+    trust10->require_client_entropy = require_client_entropy;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_trust10_get_require_server_entropy(
+    rp_trust10_t * trust10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return trust10->require_server_entropy;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, require_server_entropy, AXIS2_FAILURE);
+    trust10->require_server_entropy = require_server_entropy;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_trust10_get_must_support_issued_token(
+    rp_trust10_t * trust10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return trust10->must_support_issued_token;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_issued_token, AXIS2_FAILURE);
+    trust10->must_support_issued_token = must_support_issued_token;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_trust10_increment_ref(
+    rp_trust10_t * trust10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    trust10->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/ut.c b/neethi/src/secpolicy/model/ut.c
new file mode 100644
index 0000000..867e5c1
--- /dev/null
+++ b/neethi/src/secpolicy/model/ut.c
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_username_token.h>
+#include <rp_token.h>
+
+struct rp_username_token_t
+{
+    axis2_char_t *inclusion;
+    password_type_t password_type;
+    axis2_bool_t useUTprofile10;
+    axis2_bool_t useUTprofile11;
+    rp_token_t *token;
+    int ref;
+};
+
+AXIS2_EXTERN rp_username_token_t *AXIS2_CALL
+rp_username_token_create(
+    const axutil_env_t * env)
+{
+    rp_username_token_t *username_token = NULL;
+    username_token = (rp_username_token_t *)AXIS2_MALLOC(env->allocator,
+        sizeof(rp_username_token_t));
+
+    if(!username_token)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] User name token creation failed. Insufficient memory");
+        return NULL;
+    }
+
+    username_token->token = rp_token_create(env);
+    if(!username_token->token)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] User name token creation failed.");
+        rp_username_token_free(username_token, env);
+        return NULL;
+    }
+
+    username_token->inclusion = RP_INCLUDE_ALWAYS;
+    username_token->password_type = PASSWORD_PLAIN;
+    username_token->useUTprofile10 = AXIS2_TRUE;
+    username_token->useUTprofile11 = AXIS2_FALSE;
+    username_token->ref = 0;
+
+    return username_token;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_username_token_free(
+    rp_username_token_t * username_token,
+    const axutil_env_t * env)
+{
+    if(username_token)
+    {
+        if(--(username_token->ref) > 0)
+        {
+            return;
+        }
+
+        rp_token_free(username_token->token, env);
+        AXIS2_FREE(env->allocator, username_token);
+        username_token = NULL;
+    }
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_username_token_get_inclusion(
+    rp_username_token_t * username_token,
+    const axutil_env_t * env)
+{
+    return username_token->inclusion;
+}
+
+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_PARAM_CHECK(env->error, inclusion, AXIS2_FAILURE);
+    username_token->inclusion = inclusion;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_username_token_get_useUTprofile10(
+    rp_username_token_t * username_token,
+    const axutil_env_t * env)
+{
+    return username_token->useUTprofile10;
+}
+
+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)
+{
+    username_token->useUTprofile10 = useUTprofile10;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_username_token_get_useUTprofile11(
+    rp_username_token_t * username_token,
+    const axutil_env_t * env)
+{
+    return username_token->useUTprofile10;
+}
+
+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)
+{
+    username_token->useUTprofile11 = useUTprofile11;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_username_token_increment_ref(
+    rp_username_token_t * username_token,
+    const axutil_env_t * env)
+{
+    username_token->ref++;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_username_token_get_issuer(
+    rp_username_token_t * username_token,
+    const axutil_env_t * env)
+{
+    return rp_token_get_issuer(username_token->token, 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)
+{
+    return rp_token_set_issuer(username_token->token, env, 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)
+{
+    return rp_token_get_derivedkey_type(username_token->token, 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)
+{
+    return rp_token_set_derivedkey_type(username_token->token, env, 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)
+{
+    return rp_token_get_is_issuer_name(username_token->token, 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)
+{
+    return rp_token_set_is_issuer_name(username_token->token, env, 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)
+{
+    return rp_token_get_claim(username_token->token, 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)
+{
+    return rp_token_set_claim(username_token->token, env, claim);
+}
diff --git a/neethi/src/secpolicy/model/wss10.c b/neethi/src/secpolicy/model/wss10.c
new file mode 100644
index 0000000..2ee451d
--- /dev/null
+++ b/neethi/src/secpolicy/model/wss10.c
@@ -0,0 +1,178 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_wss10.h>
+
+struct rp_wss10_t
+{
+    axis2_bool_t must_support_ref_key_identifier;
+    axis2_bool_t must_support_ref_issuer_serial;
+    axis2_bool_t must_support_ref_external_uri;
+    axis2_bool_t must_support_ref_embedded_token;
+    axis2_bool_t must_support_direct_reference;
+    int ref;
+};
+
+AXIS2_EXTERN rp_wss10_t *AXIS2_CALL
+rp_wss10_create(
+    const axutil_env_t * env)
+{
+    rp_wss10_t *wss10 = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    wss10 = (rp_wss10_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_wss10_t));
+
+    if(wss10 == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    wss10->must_support_ref_key_identifier = AXIS2_FALSE;
+    wss10->must_support_ref_issuer_serial = AXIS2_FALSE;
+    wss10->must_support_ref_external_uri = AXIS2_FALSE;
+    wss10->must_support_ref_embedded_token = AXIS2_FALSE;
+    wss10->must_support_direct_reference = AXIS2_TRUE;
+    wss10->ref = 0;
+
+    return wss10;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_wss10_free(
+    rp_wss10_t * wss10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(wss10)
+    {
+        if(--(wss10->ref) > 0)
+        {
+            return;
+        }
+
+        AXIS2_FREE(env->allocator, wss10);
+        wss10 = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss10->must_support_ref_key_identifier;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_key_identifier, AXIS2_FAILURE);
+    wss10->must_support_ref_key_identifier = must_support_ref_key_identifier;
+
+    return AXIS2_SUCCESS;
+
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss10->must_support_ref_issuer_serial;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_issuer_serial, AXIS2_FAILURE);
+    wss10->must_support_ref_issuer_serial = must_support_ref_issuer_serial;
+
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss10->must_support_ref_external_uri;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_external_uri, AXIS2_FAILURE);
+    wss10->must_support_ref_external_uri = must_support_ref_external_uri;
+
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss10->must_support_ref_embedded_token;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_embedded_token, AXIS2_FAILURE);
+    wss10->must_support_ref_embedded_token = must_support_ref_embedded_token;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_wss10_increment_ref(
+    rp_wss10_t * wss10,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    wss10->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/wss11.c b/neethi/src/secpolicy/model/wss11.c
new file mode 100644
index 0000000..552646c
--- /dev/null
+++ b/neethi/src/secpolicy/model/wss11.c
@@ -0,0 +1,256 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_wss11.h>
+
+struct rp_wss11_t
+{
+    axis2_bool_t must_support_ref_key_identifier;
+    axis2_bool_t must_support_ref_issuer_serial;
+    axis2_bool_t must_support_ref_external_uri;
+    axis2_bool_t must_support_ref_embedded_token;
+    axis2_bool_t must_support_ref_thumbprint;
+    axis2_bool_t must_support_ref_encryptedkey;
+    axis2_bool_t require_signature_confirmation;
+    axis2_bool_t must_support_direct_reference;
+    int ref;
+};
+
+AXIS2_EXTERN rp_wss11_t *AXIS2_CALL
+rp_wss11_create(
+    const axutil_env_t * env)
+{
+    rp_wss11_t *wss11 = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+
+    wss11 = (rp_wss11_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_wss11_t));
+
+    if(wss11 == NULL)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    wss11->must_support_ref_key_identifier = AXIS2_FALSE;
+    wss11->must_support_ref_issuer_serial = AXIS2_FALSE;
+    wss11->must_support_ref_external_uri = AXIS2_FALSE;
+    wss11->must_support_ref_embedded_token = AXIS2_FALSE;
+    wss11->must_support_ref_thumbprint = AXIS2_FALSE;
+    wss11->must_support_ref_encryptedkey = AXIS2_FALSE;
+    wss11->require_signature_confirmation = AXIS2_FALSE;
+    wss11->must_support_direct_reference = AXIS2_TRUE;
+    wss11->ref = 0;
+
+    return wss11;
+
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_wss11_free(
+    rp_wss11_t * wss11,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+    if(wss11)
+    {
+        if(--(wss11->ref) > 0)
+        {
+            return;
+        }
+        AXIS2_FREE(env->allocator, wss11);
+        wss11 = NULL;
+    }
+    return;
+}
+
+/* Implementations */
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss11->must_support_ref_key_identifier;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_key_identifier, AXIS2_FAILURE);
+    wss11->must_support_ref_key_identifier = must_support_ref_key_identifier;
+
+    return AXIS2_SUCCESS;
+
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss11->must_support_ref_issuer_serial;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_issuer_serial, AXIS2_FAILURE);
+    wss11->must_support_ref_issuer_serial = must_support_ref_issuer_serial;
+
+    return AXIS2_SUCCESS;
+
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss11->must_support_ref_external_uri;
+
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_external_uri, AXIS2_FAILURE);
+    wss11->must_support_ref_external_uri = must_support_ref_external_uri;
+
+    return AXIS2_SUCCESS;
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss11->must_support_ref_embedded_token;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_embedded_token, AXIS2_FAILURE);
+    wss11->must_support_ref_embedded_token = must_support_ref_embedded_token;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_wss11_get_must_support_ref_thumbprint(
+    rp_wss11_t * wss11,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss11->must_support_ref_thumbprint;
+}
+
+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_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_thumbprint, AXIS2_FAILURE);
+    wss11->must_support_ref_thumbprint = must_support_ref_thumbprint;
+
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_wss11_get_must_support_ref_encryptedkey(
+    rp_wss11_t * wss11,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss11->must_support_ref_encryptedkey;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, must_support_ref_encryptedkey, AXIS2_FAILURE);
+    wss11->must_support_ref_encryptedkey = must_support_ref_encryptedkey;
+
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+rp_wss11_get_require_signature_confirmation(
+    rp_wss11_t * wss11,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+    return wss11->require_signature_confirmation;
+}
+
+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_ENV_CHECK(env, AXIS2_FAILURE);
+    AXIS2_PARAM_CHECK(env->error, require_signature_confirmation, AXIS2_FAILURE);
+    wss11->require_signature_confirmation = require_signature_confirmation;
+
+    return AXIS2_SUCCESS;
+
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_wss11_increment_ref(
+    rp_wss11_t * wss11,
+    const axutil_env_t * env)
+{
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    wss11->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/secpolicy/model/x509_token.c b/neethi/src/secpolicy/model/x509_token.c
new file mode 100644
index 0000000..057af86
--- /dev/null
+++ b/neethi/src/secpolicy/model/x509_token.c
@@ -0,0 +1,231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <rp_x509_token.h>
+
+struct rp_x509_token_t
+{
+    rp_token_t *token;
+    axis2_bool_t require_key_identifier_reference;
+    axis2_bool_t require_issuer_serial_reference;
+    axis2_bool_t require_embedded_token_reference;
+    axis2_bool_t require_thumb_print_reference;
+    axis2_char_t *token_version_and_type;
+    int ref;
+
+};
+
+AXIS2_EXTERN rp_x509_token_t *AXIS2_CALL
+rp_x509_token_create(
+    const axutil_env_t * env)
+{
+    rp_x509_token_t *x509_token = NULL;
+    x509_token = (rp_x509_token_t *)AXIS2_MALLOC(env->allocator, sizeof(rp_x509_token_t));
+
+    if(!x509_token)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+            "[neethi] X509 token assertion creation failed. Insufficient memory");
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;
+    }
+    x509_token->require_key_identifier_reference = AXIS2_FALSE;
+    x509_token->require_issuer_serial_reference = AXIS2_FALSE;
+    x509_token->require_embedded_token_reference = AXIS2_FALSE;
+    x509_token->require_thumb_print_reference = AXIS2_FALSE;
+    x509_token->token_version_and_type = RP_WSS_X509_V3_TOKEN_10;
+    x509_token->ref = 0;
+
+    x509_token->token = rp_token_create(env);
+    if(!x509_token->token)
+    {
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] X509 token assertion creation failed.");
+        rp_x509_token_free(x509_token, env);
+        return NULL;
+    }
+    return x509_token;
+}
+
+AXIS2_EXTERN void AXIS2_CALL
+rp_x509_token_free(
+    rp_x509_token_t * x509_token,
+    const axutil_env_t * env)
+{
+    if(x509_token)
+    {
+        if(--(x509_token->ref) > 0)
+        {
+            return;
+        }
+
+        rp_token_free(x509_token->token, env);
+        AXIS2_FREE(env->allocator, x509_token);
+        x509_token = NULL;
+    }
+}
+
+/* Implementations */
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+rp_x509_token_get_inclusion(
+    rp_x509_token_t * x509_token,
+    const axutil_env_t * env)
+{
+    return rp_token_get_inclusion(x509_token->token, 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)
+{
+    return rp_token_set_inclusion(x509_token->token, env, 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)
+{
+    return rp_token_get_derivedkey_type(x509_token->token, 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)
+{
+    return rp_token_set_derivedkey_type(x509_token->token, env, 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)
+{
+    return rp_token_get_derive_key_version(x509_token->token, 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)
+{
+    return rp_token_set_derive_key_version(x509_token->token, env, 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)
+{
+    return x509_token->require_key_identifier_reference;
+}
+
+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)
+{
+    x509_token->require_key_identifier_reference = require_key_identifier_reference;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return x509_token->require_issuer_serial_reference;
+}
+
+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)
+{
+    x509_token->require_issuer_serial_reference = require_issuer_serial_reference;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return x509_token->require_embedded_token_reference;
+}
+
+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)
+{
+    x509_token->require_embedded_token_reference = require_embedded_token_reference;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return x509_token->require_thumb_print_reference;
+}
+
+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)
+{
+    x509_token->require_thumb_print_reference = require_thumb_print_reference;
+    return AXIS2_SUCCESS;
+}
+
+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)
+{
+    return x509_token->token_version_and_type;
+}
+
+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)
+{
+    x509_token->token_version_and_type = token_version_and_type;
+    return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+rp_x509_token_increment_ref(
+    rp_x509_token_t * x509_token,
+    const axutil_env_t * env)
+{
+    x509_token->ref++;
+    return AXIS2_SUCCESS;
+}
diff --git a/neethi/src/util.c b/neethi/src/util.c
new file mode 100644
index 0000000..ca3d790
--- /dev/null
+++ b/neethi/src/util.c
@@ -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.
+ */
+
+#include <neethi_util.h>
+
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_util_create_policy_from_file(
+    const axutil_env_t *env,
+    axis2_char_t *file_name)
+{
+
+    axiom_xml_reader_t *reader = NULL;
+    axiom_stax_builder_t *builder = NULL;
+    axiom_document_t *document = NULL;
+    axiom_node_t *root_node = NULL;
+
+    reader = axiom_xml_reader_create_for_file(env, file_name, NULL);
+
+    if(!reader)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER, AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
+        return NULL;
+    }
+
+    builder = axiom_stax_builder_create(env, reader);
+    if(!builder)
+    {
+        axiom_xml_reader_free(reader, env);
+        return NULL;
+    }
+    document = axiom_stax_builder_get_document(builder, env);
+
+    if(!document)
+    {
+        axiom_stax_builder_free(builder, env);
+        return NULL;
+    }
+
+    root_node = axiom_document_build_all(document, env);
+    if(!root_node)
+    {
+        axiom_stax_builder_free(builder, env);
+        return NULL;
+    }
+
+    axiom_stax_builder_free_self(builder, env);
+    builder = NULL;
+
+    return neethi_util_create_policy_from_om(env, root_node);
+
+}
+
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_util_create_policy_from_om(
+    const axutil_env_t *env,
+    axiom_node_t *root_node)
+{
+
+    axiom_element_t *root_ele = NULL;
+
+    if(axiom_node_get_node_type(root_node, env) == AXIOM_ELEMENT)
+    {
+        root_ele = (axiom_element_t *)axiom_node_get_data_element(root_node, env);
+        if(root_ele)
+        {
+            neethi_policy_t *neethi_policy = NULL;
+            neethi_policy = neethi_engine_get_policy(env, root_node, root_ele);
+            if(!neethi_policy)
+            {
+                return NULL;
+            }
+            neethi_policy_set_root_node(neethi_policy, env, root_node);
+            return neethi_policy;
+        }
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
diff --git a/neethi/test/Makefile.am b/neethi/test/Makefile.am
new file mode 100644
index 0000000..b7ace58
--- /dev/null
+++ b/neethi/test/Makefile.am
@@ -0,0 +1,14 @@
+TESTS = 
+noinst_PROGRAMS = test
+
+test_SOURCES = test.c
+
+INCLUDES = -I$(top_builddir)/include \
+			-I ../../util/include \
+			-I ../../axiom/include \
+		    -I ../../include
+
+test_LDADD = $(top_builddir)/src/libneethi.la \
+			../../axiom/src/om/libaxis2_axiom.la \
+			../../util/src/libaxutil.la \
+			../src/libneethi.la
diff --git a/neethi/test/main.c b/neethi/test/main.c
new file mode 100644
index 0000000..53ec367
--- /dev/null
+++ b/neethi/test/main.c
@@ -0,0 +1,362 @@
+#include <axiom.h>
+#include <axutil_utils.h>
+#include <axutil_env.h>
+#include <axutil_log_default.h>
+#include <axutil_error_default.h>
+#include <stdio.h>
+#include <axiom_xml_reader.h>
+#include <neethi_engine.h>
+#include <axutil_hash.h>
+
+axis2_status_t AXIS2_CALL om_node_serialize(
+    axiom_node_t * node,
+    const axutil_env_t * env);
+
+/*axis2_status_t AXIS2_CALL
+load_policy_array(
+        axutil_array_list_t *arraylist,
+        axis2_char_t *file_name,
+        const axutil_env_t *env);
+*/
+axis2_status_t AXIS2_CALL load_policy_array(
+    axutil_array_list_t * arraylist,
+    axiom_node_t * root,
+    const axutil_env_t * env);
+
+axiom_node_t *return_policy_element(
+    axis2_char_t * name,
+    const axutil_env_t * env,
+    axis2_char_t * wsdl_name);
+
+axis2_char_t *get_policy_ref(
+    axiom_node_t * node,
+    const axutil_env_t * env);
+
+void get_all_policy(
+    axis2_char_t * element_name,
+    const axutil_env_t * env,
+    axutil_array_list_t * policy_node_list,
+    axis2_char_t * wsdl_name);
+
+neethi_policy_t *AXIS2_CALL merge_policylist(
+    axutil_array_list_t * arraylist,
+    const axutil_env_t * env);
+
+int
+main(
+    int argc,
+    char **argv)
+{
+    axis2_status_t status = AXIS2_FAILURE;
+    int i = 0;
+    axutil_array_list_t *policy_list = NULL;
+    axutil_array_list_t *policy_node_list = NULL;
+    neethi_policy_t *resultant = NULL;
+    axutil_allocator_t *allocator = axutil_allocator_init(NULL);
+    axutil_error_t *error = axutil_error_create(allocator);
+    const axutil_env_t *env = axutil_env_create_with_error(allocator, error);
+
+    policy_list = axutil_array_list_create(env, 0);
+    policy_node_list = axutil_array_list_create(env, 0);
+
+    get_all_policy(argv[1], env, policy_node_list, argv[2]);
+
+    for (i = 0; i < axutil_array_list_size(policy_node_list, env); i++)
+    {
+        axiom_node_t *node = NULL;
+        node = (axiom_node_t *) axutil_array_list_get(policy_node_list, env, i);
+        status = load_policy_array(policy_list, node, env);
+    }
+
+    resultant = merge_policylist(policy_list, env);
+    if (!resultant)
+    {
+        printf("Error Merging\n");
+        return 0;
+    }
+    else
+    {
+        axiom_node_t *s_node = NULL;
+        axis2_char_t *buff = NULL;
+        s_node = neethi_engine_serialize(resultant, env);
+        if (!s_node)
+        {
+            printf("Serializing failed\n");
+            return 0;
+        }
+        buff = axiom_node_to_string(s_node, env);
+        printf("\n%s", buff);
+    }
+    printf("Successful\n");
+    return 0;
+
+}
+
+neethi_policy_t *AXIS2_CALL
+merge_policylist(
+    axutil_array_list_t * arraylist,
+    const axutil_env_t * env)
+{
+    int i = 0;
+    neethi_policy_t *policy = NULL;
+    neethi_policy_t *result = NULL;
+
+    result = (neethi_policy_t *) axutil_array_list_get(arraylist, env, 0);
+    result =
+        (neethi_policy_t *) neethi_engine_get_normalize(env, AXIS2_FALSE,
+                                                        result);
+
+    for (i = 1; i < axutil_array_list_size(arraylist, env); i++)
+    {
+        policy = (neethi_policy_t *) axutil_array_list_get(arraylist, env, i);
+        policy =
+            (neethi_policy_t *) neethi_engine_get_normalize(env, AXIS2_FALSE,
+                                                            policy);
+        result = (neethi_policy_t *) neethi_engine_merge(env, policy, result);
+    }
+    return result;
+}
+
+axis2_status_t AXIS2_CALL
+om_node_serialize(
+    axiom_node_t * node,
+    const axutil_env_t * env)
+{
+
+    axiom_output_t *om_output = NULL;
+    axiom_xml_writer_t *writer = NULL;
+    axis2_char_t *output_buffer = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
+                                                AXIS2_XML_PARSER_TYPE_BUFFER);
+    om_output = axiom_output_create(env, writer);
+
+    status = axiom_node_serialize(node, env, om_output);
+    if (status != AXIS2_SUCCESS)
+    {
+        printf("\naxiom_node_serialize failed\n");
+        return 0;
+    }
+    else
+        printf("\naxiom_node_serialize success\n");
+    /* end serializing stuff */
+
+    /*axiom_node_free_tree(node1, env); */
+    output_buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, env);
+
+    printf("\nend test_om_serialize\n");
+
+}
+
+axis2_status_t AXIS2_CALL
+load_policy_array(
+    axutil_array_list_t * arraylist,
+    axiom_node_t * root,
+    const axutil_env_t * env)
+{
+
+    axiom_element_t *root_ele = NULL;
+
+    if (root)
+    {
+        if (axiom_node_get_node_type(root, env) == AXIOM_ELEMENT)
+        {
+            root_ele =
+                (axiom_element_t *) axiom_node_get_data_element(root, env);
+            if (root_ele)
+            {
+                neethi_policy_t *neethi_policy = NULL;
+                neethi_policy = neethi_engine_get_policy(env, root, root_ele);
+                if (!neethi_policy)
+                {
+                    printf("Policy Creation fails\n");
+                    return AXIS2_FAILURE;
+                }
+                axutil_array_list_add(arraylist, env, neethi_policy);
+            }
+        }
+    }
+    return AXIS2_SUCCESS;
+}
+
+axiom_node_t *
+return_policy_element(
+    axis2_char_t * name,
+    const axutil_env_t * env,
+    axis2_char_t * wsdl_name)
+{
+    axiom_element_t *ele1 = NULL,
+        *ele2 = NULL;
+    axiom_document_t *document = NULL;
+    axiom_node_t *node1 = NULL,
+        *node2 = NULL,
+        *policy_node = NULL;
+    axiom_namespace_t *ns = NULL;
+    axiom_xml_reader_t *reader = NULL;
+    axiom_stax_builder_t *builder = NULL;
+    char *buffer = NULL;
+    axiom_attribute_t *attr = NULL;
+    axis2_char_t *value = NULL;
+    axis2_char_t *val = NULL;
+    axutil_hash_t *attr_hash = NULL;
+    axis2_char_t *xml_output = NULL;
+    axutil_hash_index_t *hi;
+
+/*
+    f = fopen(wsdl_name, "r");
+    if (!f)
+        return NULL;
+
+    reader = axiom_xml_reader_create_for_io(env, read_input, NULL , NULL, NULL);
+*/
+    reader = axiom_xml_reader_create_for_file(env, wsdl_name, NULL);
+
+    if (!reader)
+    {
+        printf("ERROR CREATING PULLPARSER");
+        return NULL;
+    }
+
+    builder = axiom_stax_builder_create(env, reader);
+
+    if (!builder)
+    {
+        printf("ERROR CREATING PULL PARSER");
+        return NULL;
+    }
+
+    document = axiom_stax_builder_get_document(builder, env);
+    if (!document)
+        return NULL;
+
+    node1 = axiom_document_get_root_element(document, env);
+    if (!node1)
+    {
+        printf(" root element null ");
+        axiom_stax_builder_free(builder, env);
+        return NULL;
+    }
+
+    do
+    {
+        node2 = axiom_document_build_next(document, env);
+
+        if (!node2)
+            break;
+
+        if (axiom_node_get_node_type(node2, env) == AXIOM_ELEMENT)
+        {
+            ele2 = (axiom_element_t *) axiom_node_get_data_element(node2, env);
+            attr_hash = axiom_element_get_all_attributes(ele2, env);
+            if (attr_hash)
+            {
+                hi = axutil_hash_first(attr_hash, env);
+                axutil_hash_this(hi, NULL, NULL, &attr);
+
+                if (axutil_strcmp(axiom_attribute_get_value(attr, env), name) ==
+                    0)
+                {
+                    policy_node = node2;
+                }
+            }
+        }
+    }
+    while (node2);
+    return policy_node;
+}
+
+axis2_char_t *
+get_policy_ref(
+    axiom_node_t * node,
+    const axutil_env_t * env)
+{
+    axiom_element_t *policy_element = NULL;
+    axiom_children_iterator_t *children_iter = NULL;
+    axiom_node_t *child_node = NULL;
+    axutil_qname_t *qname = NULL;
+    axis2_char_t *value = NULL;
+    axis2_char_t *val = NULL;
+    axiom_attribute_t *attr = NULL;
+
+    policy_element = (axiom_element_t *) axiom_node_get_data_element(node, env);
+    children_iter = axiom_element_get_children(policy_element, env, node);
+
+    while (axiom_children_iterator_has_next(children_iter, env))
+    {
+        child_node = axiom_children_iterator_next(children_iter, env);
+        if (axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+        {
+            policy_element =
+                (axiom_element_t *) axiom_node_get_data_element(child_node,
+                                                                env);
+
+            if (axutil_strcmp
+                (axiom_element_get_localname(policy_element, env),
+                 "PolicyReference") == 0)
+            {
+                qname = axutil_qname_create(env, "URI", NULL, NULL);
+                attr = axiom_element_get_attribute(policy_element, env, qname);
+
+                if (attr)
+                {
+                    value = axiom_attribute_get_value(attr, env);
+                    val = axutil_string_substring_starting_at(value, 1);
+                    return val;
+                }
+            }
+        }
+    }
+    return NULL;
+}
+
+void
+get_all_policy(
+    axis2_char_t * element_name,
+    const axutil_env_t * env,
+    axutil_array_list_t * policy_node_list,
+    axis2_char_t * wsdl_name)
+{
+    axutil_hash_t *attr_hash = NULL;
+    axutil_hash_index_t *hi = NULL;
+    axiom_element_t *element = NULL;
+    axiom_attribute_t *attribute = NULL;
+    axis2_char_t *attribute_val = NULL;
+    axiom_node_t *parent_policy_node = NULL,
+        *parent_node = NULL;
+
+    parent_node = return_policy_element(element_name, env, wsdl_name);
+    if (!parent_node)
+        return;
+
+    parent_policy_node =
+        return_policy_element(get_policy_ref(parent_node, env), env, wsdl_name);
+    axutil_array_list_add(policy_node_list, env, parent_policy_node);
+
+    if (axiom_node_get_node_type(parent_node, env) == AXIOM_ELEMENT)
+    {
+        element =
+            (axiom_element_t *) axiom_node_get_data_element(parent_node, env);
+        attr_hash = axiom_element_get_all_attributes(element, env);
+        if (attr_hash)
+        {
+            hi = axutil_hash_next(env, axutil_hash_first(attr_hash, env));
+            do
+            {
+                if (hi)
+                {
+                    axutil_hash_this(hi, NULL, NULL, &attribute);
+                    attribute_val = axiom_attribute_get_value(attribute, env);
+                    attribute_val = axutil_rindex(attribute_val, ':');
+                    attribute_val =
+                        axutil_string_substring_starting_at(attribute_val, 1);
+                    get_all_policy(attribute_val, env, policy_node_list,
+                                   wsdl_name);
+                    hi = axutil_hash_next(env, hi);
+                }
+            }
+            while (hi);
+        }
+    }
+    return;
+}
diff --git a/neethi/test/policies/1.5symmetric_binding_policy.xml b/neethi/test/policies/1.5symmetric_binding_policy.xml
new file mode 100644
index 0000000..b660ac9
--- /dev/null
+++ b/neethi/test/policies/1.5symmetric_binding_policy.xml
@@ -0,0 +1,75 @@
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy">
+    <wsp:ExactlyOne>
+        <wsp:All>
+           <sp:SymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:ProtectionToken>
+                        <wsp:Policy>
+                            <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+                                <wsp:Policy>
+                                    <sp:RequireDerivedKeys/>
+                                    <sp:RequireThumbprintReference/>
+                                    <sp:WssX509V3Token10/>
+                                </wsp:Policy>
+                            </sp:X509Token>
+                        </wsp:Policy>
+                    </sp:ProtectionToken>
+                    <sp:AlgorithmSuite>
+                        <wsp:Policy>
+                            <sp:Basic256/>
+                        </wsp:Policy>
+                    </sp:AlgorithmSuite>
+                    <sp:Layout>
+                        <wsp:Policy>
+                            <sp:Strict/>
+                        </wsp:Policy>
+                    </sp:Layout>
+                    <sp:IncludeTimestamp/>
+                    <sp:EncryptSignature/>
+                    <sp:OnlySignEntireHeadersAndBody/>
+                </wsp:Policy>
+            </sp:SymmetricBinding>
+            <sp:SignedSupportingTokens xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+                        <wsp:Policy>
+                            <sp:WssUsernameToken10/>
+                        </wsp:Policy>
+                    </sp:UsernameToken>
+                </wsp:Policy>
+            </sp:SignedSupportingTokens>
+            <sp:Wss11 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:MustSupportRefKeyIdentifier/>
+                    <sp:MustSupportRefIssuerSerial/>
+                    <sp:MustSupportRefThumbprint/>
+                    <sp:MustSupportRefEncryptedKey/>
+                </wsp:Policy>
+            </sp:Wss11>
+            <sp:Trust10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:MustSupportIssuedTokens/>
+                    <sp:RequireClientEntropy/>
+                    <sp:RequireServerEntropy/>
+                </wsp:Policy>
+            </sp:Trust10> 
+            <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:EncryptedParts>
+            <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+                <sp:Header Namespace="http://www.w3.org/2005/08/addressing"/>
+            </sp:SignedParts>
+            <rampc:RampartConfig xmlns:rampc="http://ws.apache.org/rampart/c/policy">
+                <rampc:User>Alice</rampc:User>
+                <rampc:TimeToLive>360</rampc:TimeToLive>
+                <rampc:EncryptionUser>a</rampc:EncryptionUser>
+                <rampc:PasswordType>Digest</rampc:PasswordType>
+                <rampc:PasswordCallbackClass>AXIS2C_HOME/bin/samples/rampart/callback/libpwcb.so</rampc:PasswordCallbackClass>
+                <rampc:ReceiverCertificate>AXIS2C_HOME/bin/samples/rampart/keys/ahome/bob_cert.cert</rampc:ReceiverCertificate>
+                <rampc:Certificate>AXIS2C_HOME/bin/samples/rampart/keys/ahome/alice_cert.cert</rampc:Certificate>
+                <rampc:PrivateKey>AXIS2C_HOME/bin/samples/rampart/keys/ahome/alice_key.pem</rampc:PrivateKey>
+            </rampc:RampartConfig>
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Endpoint-1A.xml b/neethi/test/policies/Policy-for-Endpoint-1A.xml
new file mode 100644
index 0000000..ff1a54f
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Endpoint-1A.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion59 marker="59" />
+            <pa:Assertion22 marker="22" />
+            <pa:Assertion2 marker="2" />
+            <pa:Assertion1 marker="1" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Endpoint-1B.xml b/neethi/test/policies/Policy-for-Endpoint-1B.xml
new file mode 100644
index 0000000..4df87e6
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Endpoint-1B.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion60 marker="60" />
+            <pa:Assertion31 marker="31" />
+            <pa:Assertion2 marker="2" />
+            <pa:Assertion1 marker="1" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Endpoint-2A.xml b/neethi/test/policies/Policy-for-Endpoint-2A.xml
new file mode 100644
index 0000000..1517682
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Endpoint-2A.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion62 marker="62" />
+            <pa:Assertion40 marker="40" />
+            <pa:Assertion12 marker="12" />
+            <pa:Assertion1 marker="1" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Endpoint-2B.xml b/neethi/test/policies/Policy-for-Endpoint-2B.xml
new file mode 100644
index 0000000..359f4bb
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Endpoint-2B.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion63 marker="63" />
+            <pa:Assertion49 marker="49" />
+            <pa:Assertion12 marker="12" />
+            <pa:Assertion1 marker="1" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-1A-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-Input-in-Operation-1A-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..de6cf40
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-1A-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion24 marker="24" />
+            <pa:Assertion5 marker="5" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-1A-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-Input-in-Operation-1A-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..c88dafa
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-1A-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion33 marker="33" />
+            <pa:Assertion5 marker="5" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-1B-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-Input-in-Operation-1B-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..2885491
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-1B-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion28 marker="28" />
+            <pa:Assertion9 marker="9" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-1B-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-Input-in-Operation-1B-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..187a7b7
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-1B-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion37 marker="37" />
+            <pa:Assertion9 marker="9" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-2A-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-Input-in-Operation-2A-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..60e9575
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-2A-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion42 marker="42" />
+            <pa:Assertion15 marker="15" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-2A-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-Input-in-Operation-2A-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..59cc4fa
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-2A-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion51 marker="51" />
+            <pa:Assertion15 marker="15" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-2B-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-Input-in-Operation-2B-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..ee38033
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-2B-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion46 marker="46" />
+            <pa:Assertion19 marker="19" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Input-in-Operation-2B-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-Input-in-Operation-2B-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..883dcda
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Input-in-Operation-2B-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion55 marker="55" />
+            <pa:Assertion19 marker="19" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-1A-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-Operation-1A-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..dfccd95
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-1A-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion23 marker="23" />
+            <pa:Assertion4 marker="4" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-1A-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-Operation-1A-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..f86c59d
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-1A-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion31 marker="31" />
+            <pa:Assertion4 marker="4" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-1B-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-Operation-1B-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..1f39527
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-1B-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion27 marker="27" />
+            <pa:Assertion8 marker="8" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-1B-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-Operation-1B-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..180e72f
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-1B-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion36 marker="36" />
+            <pa:Assertion8 marker="8" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-2A-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-Operation-2A-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..07efde6
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-2A-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion41 marker="41" />
+            <pa:Assertion14 marker="14" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-2A-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-Operation-2A-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..071fe79
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-2A-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion50 marker="50" />
+            <pa:Assertion14 marker="14" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-2B-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-Operation-2B-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..2356e7e
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-2B-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion45 marker="45" />
+            <pa:Assertion18 marker="18" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Operation-2B-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-Operation-2B-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..2a1787b
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Operation-2B-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion54 marker="54" />
+            <pa:Assertion18 marker="18" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-1A-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-1A-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..084aa48
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-1A-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion26 marker="26" />
+            <pa:Assertion7 marker="7" />
+            <pa:Assertion3 marker="3" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-1A-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-1A-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..7873554
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-1A-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion35 marker="35" />
+            <pa:Assertion7 marker="7" />
+            <pa:Assertion3 marker="3" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-1B-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-1B-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..83acbfb
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-1B-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion30 marker="30" />
+            <pa:Assertion11 marker="11" />
+            <pa:Assertion3 marker="3" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-1B-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-1B-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..238a6dc
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-1B-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion39 marker="39" />
+            <pa:Assertion11 marker="11" />
+            <pa:Assertion3 marker="3" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-2A-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-2A-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..df84817
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-2A-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion44 marker="44" />
+            <pa:Assertion17 marker="17" />
+            <pa:Assertion13 marker="13" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-2A-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-2A-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..83c6448
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-2A-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion53 marker="53" />
+            <pa:Assertion17 marker="17" />
+            <pa:Assertion13 marker="13" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-2B-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-2B-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..e448339
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-2B-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion48 marker="48" />
+            <pa:Assertion21 marker="21" />
+            <pa:Assertion13 marker="13" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-OutFault-in-Operation-2B-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-OutFault-in-Operation-2B-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..f0332c8
--- /dev/null
+++ b/neethi/test/policies/Policy-for-OutFault-in-Operation-2B-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion57 marker="57" />
+            <pa:Assertion21 marker="21" />
+            <pa:Assertion13 marker="13" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-1A-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-Output-in-Operation-1A-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..7bb10e5
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-1A-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion25 marker="25" />
+            <pa:Assertion6 marker="6" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-1A-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-Output-in-Operation-1A-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..76493bb
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-1A-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion34 marker="34" />
+            <pa:Assertion6 marker="6" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-1B-in-relation-to-Endpoint-1A.xml b/neethi/test/policies/Policy-for-Output-in-Operation-1B-in-relation-to-Endpoint-1A.xml
new file mode 100644
index 0000000..f4734e7
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-1B-in-relation-to-Endpoint-1A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion29 marker="29" />
+            <pa:Assertion10 marker="10" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-1B-in-relation-to-Endpoint-1B.xml b/neethi/test/policies/Policy-for-Output-in-Operation-1B-in-relation-to-Endpoint-1B.xml
new file mode 100644
index 0000000..4bffd4e
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-1B-in-relation-to-Endpoint-1B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion38 marker="38" />
+            <pa:Assertion10 marker="10" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-2A-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-Output-in-Operation-2A-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..3cdbe39
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-2A-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion43 marker="43" />
+            <pa:Assertion16 marker="16" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-2A-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-Output-in-Operation-2A-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..54be84f
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-2A-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion52 marker="52" />
+            <pa:Assertion16 marker="16" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-2B-in-relation-to-Endpoint-2A.xml b/neethi/test/policies/Policy-for-Output-in-Operation-2B-in-relation-to-Endpoint-2A.xml
new file mode 100644
index 0000000..a891bfc
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-2B-in-relation-to-Endpoint-2A.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion47 marker="47" />
+            <pa:Assertion20 marker="20" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Output-in-Operation-2B-in-relation-to-Endpoint-2B.xml b/neethi/test/policies/Policy-for-Output-in-Operation-2B-in-relation-to-Endpoint-2B.xml
new file mode 100644
index 0000000..4dfc80a
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Output-in-Operation-2B-in-relation-to-Endpoint-2B.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion56 marker="56" />
+            <pa:Assertion20 marker="20" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Service-1.xml b/neethi/test/policies/Policy-for-Service-1.xml
new file mode 100644
index 0000000..a94a159
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Service-1.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion58 marker="58" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/Policy-for-Service-2.xml b/neethi/test/policies/Policy-for-Service-2.xml
new file mode 100644
index 0000000..b57b6cf
--- /dev/null
+++ b/neethi/test/policies/Policy-for-Service-2.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
+    xmlns:pa="http://ws-policy.example.com/assertion" >
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <pa:Assertion61 marker="61" />
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/PolicyAttachments.wsdl b/neethi/test/policies/PolicyAttachments.wsdl
new file mode 100644
index 0000000..acf07c1
--- /dev/null
+++ b/neethi/test/policies/PolicyAttachments.wsdl
@@ -0,0 +1,448 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- Round 2 test cases for testing effective policy 
+     computations for policies attached to WSDL 20 policy subjects.
+
+    xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    
+ -->
+ 
+<wsdl20:description xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    xmlns:wsdl20="http://www.w3.org/2006/01/wsdl"
+    xmlns:wsoap="http://www.w3.org/2006/01/wsdl/soap"
+    xmlns:wsp="http://www.w3.org/ns/ws-policy"
+    xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+    xmlns:pa="http://ws-policy.example.com/assertion"
+    xmlns:s="http://schema.example.com/test"
+    targetNamespace="http://ws-policy.example.com/test"
+    xmlns:tns="http://ws-policy.example.com/test"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.w3.org/2001/XMLSchema http://www.w3.org/2001/XMLSchema.xsd
+    http://www.w3.org/2006/01/wsdl http://www.w3.org/2006/03/wsdl/wsdl20.xsd
+    http://www.w3.org/2006/01/wsdl/soap http://www.w3.org/2006/03/wsdl/soap.xsd
+    http://www.w3.org/ns/ws-policy http://www.w3.org/2002/ws/policy/ns/ws-policy">
+    
+    <wsp:Policy wsu:Id="Policy1">
+        <pa:Assertion1 marker="1"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy2">
+        <pa:Assertion2 marker="2"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy3">
+        <pa:Assertion3 marker="3"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy4">
+        <pa:Assertion4 marker="4"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy5">
+        <pa:Assertion5 marker="5"/>
+        <wsp:PolicyReference URI="#Policy2"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy6">
+        <pa:Assertion6 marker="6"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy7">
+        <pa:Assertion7 marker="7"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy8">
+        <pa:Assertion8 marker="8"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy9">
+        <pa:Assertion9 marker="9"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy10">
+        <pa:Assertion10 marker="10"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy11">
+        <pa:Assertion11 marker="11"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy12">
+        <pa:Assertion12 marker="12"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy13">
+        <pa:Assertion13 marker="13"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy14">
+        <pa:Assertion14 marker="14"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy15">
+        <pa:Assertion15 marker="15"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy16">
+        <pa:Assertion16 marker="16"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy17">
+        <pa:Assertion17 marker="17"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy18">
+        <pa:Assertion18 marker="18"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy19">
+        <pa:Assertion19 marker="19"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy20">
+        <pa:Assertion20 marker="20"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy21">
+        <pa:Assertion21 marker="21"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy22">
+        <pa:Assertion22 marker="22"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy23">
+        <pa:Assertion23 marker="23"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy24">
+        <pa:Assertion24 marker="24"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy25">
+        <pa:Assertion25 marker="25"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy26">
+        <pa:Assertion26 marker="26"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy27">
+        <pa:Assertion27 marker="27"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy28">
+        <pa:Assertion28 marker="28"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy29">
+        <pa:Assertion29 marker="29"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy30">
+        <pa:Assertion30 marker="30"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy31">
+        <pa:Assertion31 marker="31"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy32">
+        <pa:Assertion32 marker="32"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy33">
+        <pa:Assertion33 marker="33"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy34">
+        <pa:Assertion34 marker="34"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy35">
+        <pa:Assertion35 marker="35"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy36">
+        <pa:Assertion36 marker="36"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy37">
+        <pa:Assertion37 marker="37"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy38">
+        <pa:Assertion38 marker="38"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy39">
+        <pa:Assertion39 marker="39"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy40">
+        <pa:Assertion40 marker="40"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy41">
+        <pa:Assertion41 marker="41"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy42">
+        <pa:Assertion42 marker="42"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy43">
+        <pa:Assertion43 marker="43"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy44">
+        <pa:Assertion44 marker="44"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy45">
+        <pa:Assertion45 marker="45"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy46">
+        <pa:Assertion46 marker="46"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy47">
+        <pa:Assertion47 marker="47"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy48">
+        <pa:Assertion48 marker="48"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy49">
+        <pa:Assertion49 marker="49"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy50">
+        <pa:Assertion50 marker="50"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy51">
+        <pa:Assertion51 marker="51"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy52">
+        <pa:Assertion52 marker="52"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy53">
+        <pa:Assertion53 marker="53"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy54">
+        <pa:Assertion54 marker="54"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy55">
+        <pa:Assertion55 marker="55"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy56">
+        <pa:Assertion56 marker="56"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy57">
+        <pa:Assertion57 marker="57"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy58">
+        <pa:Assertion58 marker="58"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy59">
+        <pa:Assertion59 marker="59"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy60">
+        <pa:Assertion60 marker="60"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy61">
+        <pa:Assertion61 marker="61"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy62">
+        <pa:Assertion62 marker="62"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy63">
+        <pa:Assertion63 marker="63"/>
+    </wsp:Policy>
+    
+    <wsdl20:types>
+        <xsd:schema elementFormDefault="qualified" targetNamespace="http://schema.example.com/test">
+            <xsd:element name="SimpleRequest">
+                <xsd:complexType>
+                    <xsd:sequence>
+                        <xsd:element name="request" nillable="true" type="xsd:string"/>
+                    </xsd:sequence>
+                </xsd:complexType>
+            </xsd:element>
+            <xsd:element name="SimpleResponse">
+                <xsd:complexType>
+                    <xsd:sequence>
+                        <xsd:element name="response" nillable="true" type="xsd:string"/>
+                    </xsd:sequence>
+                </xsd:complexType>
+            </xsd:element>
+            <xsd:element name="SimpleFault">
+                <xsd:complexType>
+                    <xsd:sequence>
+                        <xsd:element name="fault" nillable="true" type="xsd:string"/>
+                    </xsd:sequence>
+                </xsd:complexType>
+            </xsd:element>
+        </xsd:schema>
+    </wsdl20:types>
+
+    <wsdl20:interface name="Base-Interface">
+        <wsp:PolicyReference URI="#Policy1"></wsp:PolicyReference>
+    </wsdl20:interface>
+    
+    <wsdl20:interface name="Interface-1" extends="tns:Base-Interface">
+        <wsp:PolicyReference URI="#Policy2"></wsp:PolicyReference>
+        <wsdl20:fault name="Fault-1" element="s:SimpleFault">
+            <wsp:PolicyReference URI="#Policy3"></wsp:PolicyReference>
+        </wsdl20:fault>
+        <wsdl20:operation name="Operation-1A" pattern="http://www.w3.org/2006/01/wsdl/in-out">
+            <wsp:PolicyReference URI="#Policy4"></wsp:PolicyReference>
+            <wsdl20:input element="s:SimpleRequest">
+                <wsp:PolicyReference URI="#Policy5"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output element="s:SimpleResponse">
+                <wsp:PolicyReference URI="#Policy6"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-1">
+                <wsp:PolicyReference URI="#Policy7"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>
+        <wsdl20:operation name="Operation-1B" pattern="http://www.w3.org/2006/01/wsdl/in-out">
+            <wsp:PolicyReference URI="#Policy8"></wsp:PolicyReference>
+            <wsdl20:input element="s:SimpleRequest">
+                <wsp:PolicyReference URI="#Policy9"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output element="s:SimpleResponse">
+                <wsp:PolicyReference URI="#Policy10"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-1">
+                <wsp:PolicyReference URI="#Policy11"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>        
+    </wsdl20:interface>
+
+    <wsdl20:interface name="Interface-2" extends="tns:Base-Interface">
+        <wsp:PolicyReference URI="#Policy12"></wsp:PolicyReference>
+        <wsdl20:fault name="Fault-2" element="s:SimpleFault">
+            <wsp:PolicyReference URI="#Policy13"></wsp:PolicyReference>
+        </wsdl20:fault>
+        <wsdl20:operation name="Operation-2A" pattern="http://www.w3.org/2006/01/wsdl/in-out">
+            <wsp:PolicyReference URI="#Policy14"></wsp:PolicyReference>
+            <wsdl20:input element="s:SimpleRequest">
+                <wsp:PolicyReference URI="#Policy15"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output element="s:SimpleResponse">
+                <wsp:PolicyReference URI="#Policy16"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-2">
+                <wsp:PolicyReference URI="#Policy17"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>
+        <wsdl20:operation name="Operation-2B" pattern="http://www.w3.org/2006/01/wsdl/in-out">
+            <wsp:PolicyReference URI="#Policy18"></wsp:PolicyReference>
+            <wsdl20:input element="s:SimpleRequest">
+                <wsp:PolicyReference URI="#Policy19"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output element="s:SimpleResponse">
+                <wsp:PolicyReference URI="#Policy20"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-2">
+                <wsp:PolicyReference URI="#Policy21"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>        
+    </wsdl20:interface>
+    
+    <wsdl20:binding name="Binding-1A" interface="tns:Interface-1"
+        type="http://www.w3.org/2006/01/wsdl/soap"
+        wsoap:protocol="http://www.w3.org/2003/05/soap/bindings/HTTP/">
+        <wsp:PolicyReference URI="#Policy22"></wsp:PolicyReference>
+        <wsdl20:operation ref="tns:Operation-1A">
+            <wsp:PolicyReference URI="#Policy23"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy24"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy25"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-1">
+                <wsp:PolicyReference URI="#Policy26"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>
+        <wsdl20:operation ref="tns:Operation-1B">
+            <wsp:PolicyReference URI="#Policy27"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy28"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy29"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-1">
+                <wsp:PolicyReference URI="#Policy30"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>
+    </wsdl20:binding>
+
+    <wsdl20:binding name="Binding-1B" interface="tns:Interface-1"
+        type="http://www.w3.org/2006/01/wsdl/soap"
+        wsoap:protocol="http://www.w3.org/2003/05/soap/bindings/HTTP/">
+        <wsp:PolicyReference URI="#Policy31"></wsp:PolicyReference>
+        <wsdl20:operation ref="tns:Operation-1A">
+            <wsp:PolicyReference URI="#Policy32"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy33"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy34"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-1">
+                <wsp:PolicyReference URI="#Policy35"></wsp:PolicyReference>
+            </wsdl20:outfault>            
+        </wsdl20:operation>
+        <wsdl20:operation ref="tns:Operation-1B">
+            <wsp:PolicyReference URI="#Policy36"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy37"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy38"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-1">
+                <wsp:PolicyReference URI="#Policy39"></wsp:PolicyReference>
+            </wsdl20:outfault>            
+        </wsdl20:operation>
+    </wsdl20:binding>
+
+    <wsdl20:binding name="Binding-2A" interface="tns:Interface-2"
+        type="http://www.w3.org/2006/01/wsdl/soap"
+        wsoap:protocol="http://www.w3.org/2003/05/soap/bindings/HTTP/">
+        <wsp:PolicyReference URI="#Policy40"></wsp:PolicyReference>
+        <wsdl20:operation ref="tns:Operation-2A">
+            <wsp:PolicyReference URI="#Policy41"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy42"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy43"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-2">
+                <wsp:PolicyReference URI="#Policy44"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>
+        <wsdl20:operation ref="tns:Operation-2B">
+            <wsp:PolicyReference URI="#Policy45"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy46"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy47"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-2">
+                <wsp:PolicyReference URI="#Policy48"></wsp:PolicyReference>
+            </wsdl20:outfault>
+        </wsdl20:operation>
+    </wsdl20:binding>
+    
+    <wsdl20:binding name="Binding-2B" interface="tns:Interface-2"
+        type="http://www.w3.org/2006/01/wsdl/soap"
+        wsoap:protocol="http://www.w3.org/2003/05/soap/bindings/HTTP/">
+        <wsp:PolicyReference URI="#Policy49"></wsp:PolicyReference>
+        <wsdl20:operation ref="tns:Operation-2A">
+            <wsp:PolicyReference URI="#Policy50"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy51"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy52"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-2">
+                <wsp:PolicyReference URI="#Policy53"></wsp:PolicyReference>
+            </wsdl20:outfault>            
+        </wsdl20:operation>
+        <wsdl20:operation ref="tns:Operation-2B">
+            <wsp:PolicyReference URI="#Policy54"></wsp:PolicyReference>
+            <wsdl20:input>
+                <wsp:PolicyReference URI="#Policy55"></wsp:PolicyReference>
+            </wsdl20:input>
+            <wsdl20:output>
+                <wsp:PolicyReference URI="#Policy56"></wsp:PolicyReference>
+            </wsdl20:output>
+            <wsdl20:outfault ref="tns:Fault-2">
+                <wsp:PolicyReference URI="#Policy57"></wsp:PolicyReference>
+            </wsdl20:outfault>            
+        </wsdl20:operation>
+    </wsdl20:binding>
+            
+    <wsdl20:service name="Service-1" interface="tns:Interface-1">
+        <wsp:PolicyReference URI="#Policy58"></wsp:PolicyReference>
+        <wsdl20:endpoint name="Endpoint-1A" binding="Binding-1A">
+            <wsp:PolicyReference URI="#Policy59"></wsp:PolicyReference>
+        </wsdl20:endpoint>
+        <wsdl20:endpoint name="Endpoint-1B" binding="Binding-1B">
+            <wsp:PolicyReference URI="#Policy60"></wsp:PolicyReference>
+        </wsdl20:endpoint>
+    </wsdl20:service>
+    
+    <wsdl20:service name="Service-2" interface="tns:Interface-2">
+        <wsp:PolicyReference URI="#Policy61"></wsp:PolicyReference>
+        <wsdl20:endpoint name="Endpoint-2A" binding="Binding-2A">
+            <wsp:PolicyReference URI="#Policy62"></wsp:PolicyReference>
+        </wsdl20:endpoint>
+        <wsdl20:endpoint name="Endpoint-2B" binding="Binding-2A">
+            <wsp:PolicyReference URI="#Policy63"></wsp:PolicyReference>
+        </wsdl20:endpoint>
+    </wsdl20:service>
+    
+</wsdl20:description>
diff --git a/neethi/test/policies/asymmetric_binding_policy.xml b/neethi/test/policies/asymmetric_binding_policy.xml
new file mode 100644
index 0000000..da136af
--- /dev/null
+++ b/neethi/test/policies/asymmetric_binding_policy.xml
@@ -0,0 +1,70 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:InitiatorToken>
+                        <wsp:Policy>
+                            <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+                                <wsp:Policy>
+                                    <sp:WssX509V3Token10/>
+                                </wsp:Policy>
+                            </sp:X509Token>
+                        </wsp:Policy>
+                    </sp:InitiatorToken>
+                    <sp:RecipientToken>
+                        <wsp:Policy>
+                            <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+                                <wsp:Policy>
+                                    <sp:WssX509V3Token10/>
+                                </wsp:Policy>
+                            </sp:X509Token>
+                        </wsp:Policy>
+                    </sp:RecipientToken>
+                    <sp:AlgorithmSuite>
+                        <wsp:Policy>
+                            <sp:Basic256Rsa15/>
+                        </wsp:Policy>
+                    </sp:AlgorithmSuite>
+                    <sp:Layout>
+                        <wsp:Policy>
+                            <sp:Strict/>
+                        </wsp:Policy>
+                    </sp:Layout>
+                    <sp:IncludeTimestamp/>
+                    <sp:EncryptSignature/>
+                    <sp:EncryptBeforeSigning/>
+                </wsp:Policy>
+            </sp:AsymmetricBinding>
+            <sp:SignedSupportingTokens xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+            <wsp:Policy>
+                <sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Always"/>
+            </wsp:Policy>
+            </sp:SignedSupportingTokens>
+            <sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:MustSupportRefKeyIdentifier/>
+                    <sp:MustSupportRefEmbeddedToken/>
+                    <sp:MustSupportRefIssuerSerial/>
+                </wsp:Policy>
+            </sp:Wss10>
+            <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:EncryptedParts>
+            <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+                <sp:Header Namespace="http://www.w3.org/2005/08/addressing"/>
+            </sp:SignedParts>
+            <rampc:RampartConfig xmlns:rampc="http://ws.apache.org/rampart/c/policy">
+                <rampc:User>Alice</rampc:User>
+                <rampc:TimeToLive>360</rampc:TimeToLive>
+                <rampc:EncryptionUser>a</rampc:EncryptionUser>
+                <rampc:PasswordType>Digest</rampc:PasswordType>
+                <rampc:PasswordCallbackClass>AXIS2C_HOME/bin/samples/rampart/callback/libpwcb.so</rampc:PasswordCallbackClass>
+                <rampc:ReceiverCertificate>AXIS2C_HOME/bin/samples/rampart/keys/ahome/bob_cert.cert</rampc:ReceiverCertificate>
+                <rampc:Certificate>AXIS2C_HOME/bin/samples/rampart/keys/ahome/alice_cert.cert</rampc:Certificate>
+                <rampc:PrivateKey>AXIS2C_HOME/bin/samples/rampart/keys/ahome/alice_key.pem</rampc:PrivateKey>
+            </rampc:RampartConfig>
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/rm-1.0.xml b/neethi/test/policies/rm-1.0.xml
new file mode 100644
index 0000000..353e1ba
--- /dev/null
+++ b/neethi/test/policies/rm-1.0.xml
@@ -0,0 +1,21 @@
+<wsp:Policy wsu:Id="RmPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm/policy" xmlns:sanc="http://ws.apache.org/sandesha2/c/policy" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <wsrm:RMAssertion>
+                <wsrm:InactivityTimeout Milliseconds="600000"/>
+                <wsrm:AcknowledgementInterval Milliseconds="200"/>
+                <wsrm:BaseRetransmissionInterval Milliseconds="300"/>
+                <wsrm:ExponentialBackoff/>
+                <sanc:sandesha2_db>/tmp/sandesha2_db</sanc:sandesha2_db>
+                <sanc:InactivityTimeout>64</sanc:InactivityTimeout>
+                <sanc:StorageManager>persistent</sanc:StorageManager>
+                <sanc:MessageTypesToDrop>none</sanc:MessageTypesToDrop>
+                <sanc:MaxRetransCount>10</sanc:MaxRetransCount>
+                <sanc:SenderSleepTime>1</sanc:SenderSleepTime><!--In seconds-->
+                <sanc:InvokerSleepTime>1</sanc:InvokerSleepTime>
+                <sanc:PollingWaitTime>4</sanc:PollingWaitTime>
+                <sanc:TerminateDelay>4</sanc:TerminateDelay>
+            </wsrm:RMAssertion>
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/rm-1.1.xml b/neethi/test/policies/rm-1.1.xml
new file mode 100644
index 0000000..6c60dbc
--- /dev/null
+++ b/neethi/test/policies/rm-1.1.xml
@@ -0,0 +1,27 @@
+<wsp:Policy wsu:Id="RmPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsrmp="http://docs.oasis-open.org/ws-rx/wsrmp/200702" xmlns:sanc="http://ws.apache.org/sandesha2/c/policy" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">
+    <wsp:ExactlyOne>
+        <wsp:All>
+            <wsrmp:RMAssertion>
+                <wsp:Policy>
+                    <wsrmp:DeliveryAssurance>
+                        <wsp:Policy>
+                            <wsrmp:ExactlyOnce/>
+                            <wsrmp:InOrder/>
+                        </wsp:Policy>
+                    </wsrmp:DeliveryAssurance>
+                </wsp:Policy>
+                <sanc:InactivityTimeout>600000</sanc:InactivityTimeout>
+                <sanc:AcknowledgementInterval>200</sanc:AcknowledgementInterval>
+                <sanc:BaseRetransmissionInterval>300</sanc:BaseRetransmissionInterval>
+                <sanc:sandesha2_db>/tmp/sandesha2_db</sanc:sandesha2_db>
+                <sanc:StorageManager>persistent</sanc:StorageManager>
+                <sanc:MessageTypesToDrop>none</sanc:MessageTypesToDrop>
+                <sanc:MaxRetransCount>10</sanc:MaxRetransCount>
+                <sanc:SenderSleepTime>1</sanc:SenderSleepTime><!--In seconds-->
+                <sanc:InvokerSleepTime>1</sanc:InvokerSleepTime>
+                <sanc:PollingWaitTime>4</sanc:PollingWaitTime>
+                <sanc:TerminateDelay>4</sanc:TerminateDelay>
+            </wsrmp:RMAssertion>
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/policies/symmetric_binding_policy.xml b/neethi/test/policies/symmetric_binding_policy.xml
new file mode 100644
index 0000000..3db3ed8
--- /dev/null
+++ b/neethi/test/policies/symmetric_binding_policy.xml
@@ -0,0 +1,75 @@
+<wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+    <wsp:ExactlyOne>
+        <wsp:All>
+           <sp:SymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:ProtectionToken>
+                        <wsp:Policy>
+                            <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+                                <wsp:Policy>
+                                    <sp:RequireDerivedKeys/>
+                                    <sp:RequireThumbprintReference/>
+                                    <sp:WssX509V3Token10/>
+                                </wsp:Policy>
+                            </sp:X509Token>
+                        </wsp:Policy>
+                    </sp:ProtectionToken>
+                    <sp:AlgorithmSuite>
+                        <wsp:Policy>
+                            <sp:Basic256/>
+                        </wsp:Policy>
+                    </sp:AlgorithmSuite>
+                    <sp:Layout>
+                        <wsp:Policy>
+                            <sp:Strict/>
+                        </wsp:Policy>
+                    </sp:Layout>
+                    <sp:IncludeTimestamp/>
+                    <sp:EncryptSignature/>
+                    <sp:OnlySignEntireHeadersAndBody/>
+                </wsp:Policy>
+            </sp:SymmetricBinding>
+            <sp:SignedSupportingTokens xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+                        <wsp:Policy>
+                            <sp:WssUsernameToken10/>
+                        </wsp:Policy>
+                    </sp:UsernameToken>
+                </wsp:Policy>
+            </sp:SignedSupportingTokens>
+            <sp:Wss11 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:MustSupportRefKeyIdentifier/>
+                    <sp:MustSupportRefIssuerSerial/>
+                    <sp:MustSupportRefThumbprint/>
+                    <sp:MustSupportRefEncryptedKey/>
+                </wsp:Policy>
+            </sp:Wss11>
+            <sp:Trust10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:MustSupportIssuedTokens/>
+                    <sp:RequireClientEntropy/>
+                    <sp:RequireServerEntropy/>
+                </wsp:Policy>
+            </sp:Trust10> 
+            <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:EncryptedParts>
+            <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+                <sp:Header Namespace="http://www.w3.org/2005/08/addressing"/>
+            </sp:SignedParts>
+            <rampc:RampartConfig xmlns:rampc="http://ws.apache.org/rampart/c/policy">
+                <rampc:User>Alice</rampc:User>
+                <rampc:TimeToLive>360</rampc:TimeToLive>
+                <rampc:EncryptionUser>a</rampc:EncryptionUser>
+                <rampc:PasswordType>Digest</rampc:PasswordType>
+                <rampc:PasswordCallbackClass>AXIS2C_HOME/bin/samples/rampart/callback/libpwcb.so</rampc:PasswordCallbackClass>
+                <rampc:ReceiverCertificate>AXIS2C_HOME/bin/samples/rampart/keys/ahome/bob_cert.cert</rampc:ReceiverCertificate>
+                <rampc:Certificate>AXIS2C_HOME/bin/samples/rampart/keys/ahome/alice_cert.cert</rampc:Certificate>
+                <rampc:PrivateKey>AXIS2C_HOME/bin/samples/rampart/keys/ahome/alice_key.pem</rampc:PrivateKey>
+            </rampc:RampartConfig>
+        </wsp:All>
+    </wsp:ExactlyOne>
+</wsp:Policy>
diff --git a/neethi/test/security_context_token/build.sh b/neethi/test/security_context_token/build.sh
new file mode 100644
index 0000000..6a5714d
--- /dev/null
+++ b/neethi/test/security_context_token/build.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+gcc security_context_token_test.c ../../../util/test/util/create_env.c -Werror -g -I$AXIS2C_HOME/include/axis2-1.2 -L$AXIS2C_HOME/lib -lneethi -laxutil -laxis2_axiom -laxis2_parser -o security_context_token 
diff --git a/neethi/test/security_context_token/security_context_token_test.c b/neethi/test/security_context_token/security_context_token_test.c
new file mode 100644
index 0000000..6f320f3
--- /dev/null
+++ b/neethi/test/security_context_token/security_context_token_test.c
@@ -0,0 +1,54 @@
+#include <rp_security_context_token.h>
+#include "../../../util/test/util/create_env.h"
+
+axutil_env_t *env = NULL;
+rp_security_context_token_t * security_context_token = NULL;
+axis2_char_t * inclusion = NULL ;
+axis2_status_t status = AXIS2_FAILURE ;
+axis2_bool_t derivedkeys ;
+axis2_bool_t require_external_uri_ref;
+axis2_bool_t sc10_security_context_token;
+
+/** @brief test options 
+ * build a om from a client options
+ */
+
+axis2_status_t test_security_context_token(axutil_env_t *env)
+{  
+   security_context_token = rp_security_context_token_create(env); 
+   inclusion = rp_security_context_token_get_inclusion(security_context_token,env);
+   printf("%s\n",inclusion);
+   status = rp_security_context_token_set_inclusion(security_context_token,env,inclusion);
+   if (status == AXIS2_SUCCESS)
+        printf("rp security context token set is success\n");
+   derivedkeys = rp_security_context_token_get_derivedkeys(security_context_token,env);
+   status = rp_security_context_token_set_derivedkeys(security_context_token,env,derivedkeys);
+   if (status == AXIS2_SUCCESS)
+        printf("rp security token derivedkeys set is success\n");
+   require_external_uri_ref = rp_security_context_token_get_require_external_uri_ref(security_context_token,env);
+   status = rp_security_context_token_set_require_external_uri_ref(security_context_token,env,require_external_uri_ref);
+   if (status == AXIS2_SUCCESS)
+        printf("rp security require external uri set is success\n");
+   sc10_security_context_token = rp_security_context_token_get_sc10_security_context_token(security_context_token,env);
+   status = rp_security_context_token_set_sc10_security_context_token(security_context_token,env,sc10_security_context_token);
+   if (status == AXIS2_SUCCESS)
+        printf("rp security sc10 security token  set is success\n");
+   rp_security_context_token_increment_ref(security_context_token,env);
+   rp_security_context_token_free(security_context_token,env);
+   return AXIS2_SUCCESS;
+}
+int main()
+{
+    int status = AXIS2_SUCCESS;
+    env = create_environment();
+    status = test_security_context_token(env);
+    if(status == AXIS2_FAILURE)
+    {
+        printf(" test  failed");
+    }
+    axutil_env_free(env);
+    return 0;
+}
+
+
+
diff --git a/neethi/test/test-policy.xml b/neethi/test/test-policy.xml
new file mode 100644
index 0000000..8e44f90
--- /dev/null
+++ b/neethi/test/test-policy.xml
@@ -0,0 +1,10 @@
+<wsp:Policy wsu:Id="Policy1">
+    <pa:Assertion1 marker="1"/>
+</wsp:Policy>
+    <wsp:Policy wsu:Id="Policy2">
+        <pa:Assertion2 marker="2"/>
+    </wsp:Policy>
+    <wsp:Policy wsu:Id="Policy3">
+        <pa:Assertion3 marker="3"/>
+    </wsp:Policy>
+
diff --git a/neethi/test/test-resources/different-level-policies.xml b/neethi/test/test-resources/different-level-policies.xml
new file mode 100644
index 0000000..de5a707
--- /dev/null
+++ b/neethi/test/test-resources/different-level-policies.xml
@@ -0,0 +1,109 @@
+<service name="sec_echo">
+    <parameter name="ServiceClass" locked="xsd:false">sec_echo</parameter>
+
+   <description>
+        This is a testing service , to test the system is working or not
+   </description>
+    <module ref="rampart"/>
+    <operation name="echoString">
+            <parameter name="wsamapping">http://example.com/ws/2004/09/policy/Test/EchoRequest</parameter>
+            <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+            <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:SignedParts>
+            <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:EncryptedParts>
+        </wsp:Policy>
+        <!--message label="in">
+            <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+                <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:SignedParts>
+                <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:EncryptedParts>
+            </wsp:Policy>
+        </message-->
+        <!--message label="out">
+            <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+                <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:SignedParts>
+                <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:EncryptedParts>
+            </wsp:Policy>
+        </message-->
+    </operation>
+
+    <wsp:Policy xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+        <wsp:ExactlyOne>
+            <wsp:All>
+                <sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <wsp:Policy>
+                        <sp:InitiatorToken>
+                            <wsp:Policy>
+                                <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+                                    <wsp:Policy>
+                                        <sp:WssX509V3Token10/>
+                                    </wsp:Policy>
+                                </sp:X509Token>
+                            </wsp:Policy>
+                        </sp:InitiatorToken>
+                        <sp:RecipientToken>
+                            <wsp:Policy>
+                                <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+                                    <wsp:Policy>
+                                        <sp:WssX509V3Token10/>
+                                    </wsp:Policy>
+                                </sp:X509Token>
+                            </wsp:Policy>
+                        </sp:RecipientToken>
+                        <sp:AlgorithmSuite>
+                            <wsp:Policy>
+                                <sp:Basic256Rsa15/>
+                            </wsp:Policy>
+                        </sp:AlgorithmSuite>
+                        <sp:Layout>
+                            <wsp:Policy>
+                                <sp:Strict/>
+                            </wsp:Policy>
+                        </sp:Layout>
+                        <sp:IncludeTimestamp/>
+                        <!--sp:EncryptSignature/-->
+                        <!--sp:EncryptBeforeSigning/-->
+                    </wsp:Policy>
+                </sp:AsymmetricBinding>
+                <sp:SignedSupportingTokens xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <wsp:Policy>
+                    <sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Always"/>
+                </wsp:Policy>
+                </sp:SignedSupportingTokens>
+                <sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <wsp:Policy>
+                        <sp:MustSupportRefKeyIdentifier/>
+                        <sp:MustSupportRefEmbeddedToken/>
+                        <sp:MustSupportRefIssuerSerial/>
+                    </wsp:Policy>
+                </sp:Wss10>
+                <!--sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:EncryptedParts-->
+                <!--sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:SignedParts-->
+                <rampc:RampartConfig xmlns:rampc="http://ws.apache.org/rampart/c/policy">
+                    <rampc:User>Bob</rampc:User>
+                    <rampc:TimeToLive>360</rampc:TimeToLive>
+                    <rampc:EncryptionUser>b</rampc:EncryptionUser>
+                    <rampc:PasswordType>Digest</rampc:PasswordType>
+                    <rampc:PasswordCallbackClass>/home/manjula/axis2/c/deploy/bin/samples/rampart/callback/libpwcb.so</rampc:PasswordCallbackClass>
+                    <rampc:ReceiverCertificate>/home/manjula/axis2/c/deploy/bin/samples/rampart/keys/bhome/alice_cert.cert</rampc:ReceiverCertificate>
+                    <rampc:Certificate>/home/manjula/axis2/c/deploy/bin/samples/rampart/keys/bhome/bob_cert.cert</rampc:Certificate>
+                    <rampc:PrivateKey>/home/manjula/axis2/c/deploy/bin/samples/rampart/keys/bhome/bob_key.pem</rampc:PrivateKey>
+                </rampc:RampartConfig>
+            </wsp:All>
+        </wsp:ExactlyOne>
+    </wsp:Policy>
+</service>
diff --git a/neethi/test/test-resources/echo-services.xml b/neethi/test/test-resources/echo-services.xml
new file mode 100644
index 0000000..c7fc88b
--- /dev/null
+++ b/neethi/test/test-resources/echo-services.xml
@@ -0,0 +1,115 @@
+<service name="echo">
+    <parameter name="ServiceClass" locked="xsd:false">echo</parameter>
+
+    <description>
+        This is a testing service , to test the system is working or not
+    </description>
+
+	<operation name="echoString">
+        <parameter name="wsamapping" >http://ws.apache.org/axis2/c/samples/echoString</parameter>
+        <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+            <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:SignedParts>
+            <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:EncryptedParts>
+        </wsp:Policy>
+        <message label="in">
+            <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+                <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:SignedParts>
+                <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:EncryptedParts>
+            </wsp:Policy>
+        </message>    
+        <message label="out">
+            <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+                <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:SignedParts>
+                <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:EncryptedParts>
+            </wsp:Policy>
+        </message>    
+	</operation>
+
+	<wsp:Policy wsu:Id="SigEncr" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:InitiatorToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+									<wsp:Policy>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:InitiatorToken>
+						<sp:RecipientToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+									<wsp:Policy>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:RecipientToken>
+						<sp:AlgorithmSuite>
+							<wsp:Policy>
+								<sp:Basic256/>
+							</wsp:Policy>
+						</sp:AlgorithmSuite>
+						<sp:Layout>
+							<wsp:Policy>
+								<sp:Strict/>
+							</wsp:Policy>
+						</sp:Layout>
+						<sp:IncludeTimestamp/>
+						<sp:OnlySignEntireHeadersAndBody/>
+					</wsp:Policy>
+				</sp:AsymmetricBinding>
+				<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:MustSupportRefKeyIdentifier/>
+						<sp:MustSupportRefIssuerSerial/>
+					</wsp:Policy>
+				</sp:Wss10>
+				<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:SignedParts>
+				<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:EncryptedParts>
+
+				<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+					<ramp:user>alice</ramp:user>
+					<ramp:encryptionUser>bob</ramp:encryptionUser>
+					<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+					
+					<ramp:signatureCrypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:signatureCrypto>
+					<ramp:encryptionCypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:encryptionCypto>
+				</ramp:RampartConfig>
+
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+
+</service>
diff --git a/neethi/test/test-resources/message-services-sc.xml b/neethi/test/test-resources/message-services-sc.xml
new file mode 100644
index 0000000..2f293df
--- /dev/null
+++ b/neethi/test/test-resources/message-services-sc.xml
@@ -0,0 +1,116 @@
+<service name="SecureService3">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+        <actionMapping>urn:echo</actionMapping>
+        <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+            <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:SignedParts>
+            <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                <sp:Body/>
+            </sp:EncryptedParts>
+        </wsp:Policy>
+        <message label="in">
+            <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+                <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:SignedParts>
+                <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:EncryptedParts>
+            </wsp:Policy>
+        </message>    
+        <message label="out">
+            <wsp:Policy wsu:Id="SigEncrMessage" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+                <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:SignedParts>
+                <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+                    <sp:Body/>
+                </sp:EncryptedParts>
+            </wsp:Policy>
+        </message>    
+	</operation>
+
+	<wsp:Policy wsu:Id="SigEncr" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:InitiatorToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+									<wsp:Policy>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:InitiatorToken>
+						<sp:RecipientToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+									<wsp:Policy>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:RecipientToken>
+						<sp:AlgorithmSuite>
+							<wsp:Policy>
+								<sp:Basic256/>
+							</wsp:Policy>
+						</sp:AlgorithmSuite>
+						<sp:Layout>
+							<wsp:Policy>
+								<sp:Strict/>
+							</wsp:Policy>
+						</sp:Layout>
+						<sp:IncludeTimestamp/>
+						<sp:OnlySignEntireHeadersAndBody/>
+					</wsp:Policy>
+				</sp:AsymmetricBinding>
+				<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:MustSupportRefKeyIdentifier/>
+						<sp:MustSupportRefIssuerSerial/>
+					</wsp:Policy>
+				</sp:Wss10>
+				<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:SignedParts>
+				<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:EncryptedParts>
+
+				<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+					<ramp:user>alice</ramp:user>
+					<ramp:encryptionUser>bob</ramp:encryptionUser>
+					<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+					
+					<ramp:signatureCrypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:signatureCrypto>
+					<ramp:encryptionCypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:encryptionCypto>
+				</ramp:RampartConfig>
+
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+
+</service>
diff --git a/neethi/test/test-resources/services-1.xml b/neethi/test/test-resources/services-1.xml
new file mode 100644
index 0000000..4c727d3
--- /dev/null
+++ b/neethi/test/test-resources/services-1.xml
@@ -0,0 +1,51 @@
+<service name="SecureService1">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+
+	<wsp:Policy wsu:Id="UTOverTransport" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+	  <wsp:All>
+		<sp:TransportBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+		  <wsp:Policy>
+			<sp:TransportToken>
+			  <wsp:Policy>
+				<sp:HttpsToken RequireClientCertificate="false"/>
+			  </wsp:Policy>
+			</sp:TransportToken>
+			<sp:AlgorithmSuite>
+			  <wsp:Policy>
+				<sp:Basic256/>
+			  </wsp:Policy>
+			</sp:AlgorithmSuite>
+			<sp:Layout>
+			  <wsp:Policy>
+				<sp:Lax/>
+			  </wsp:Policy>
+			</sp:Layout>
+			<sp:IncludeTimestamp/>
+		  </wsp:Policy>
+		</sp:TransportBinding>
+		<sp:SignedSupportingTokens xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+			<wsp:Policy>
+				<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient" />
+		  </wsp:Policy>
+		</sp:SignedSupportingTokens>
+		
+		<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+			<ramp:user>alice</ramp:user>
+			<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+		</ramp:RampartConfig>
+		
+	  </wsp:All>
+	</wsp:ExactlyOne>
+	</wsp:Policy>
+
+</service>
diff --git a/neethi/test/test-resources/services-2.xml b/neethi/test/test-resources/services-2.xml
new file mode 100644
index 0000000..ec80dd5
--- /dev/null
+++ b/neethi/test/test-resources/services-2.xml
@@ -0,0 +1,76 @@
+<service name="SecureService2">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+	
+	<wsp:Policy wsu:Id="SigOnly" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:InitiatorToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:InitiatorToken>
+					<sp:RecipientToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:RecipientToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:Basic256/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Strict/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:AsymmetricBinding>
+			<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+				</wsp:Policy>
+			</sp:Wss10>
+			<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:SignedParts>
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>alice</ramp:user>
+				<ramp:encryptionUser>bob</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+			</ramp:RampartConfig>
+		</wsp:All>
+	</wsp:ExactlyOne>
+</wsp:Policy>
+
+</service>
diff --git a/neethi/test/test-resources/services-3.xml b/neethi/test/test-resources/services-3.xml
new file mode 100644
index 0000000..3d1bf60
--- /dev/null
+++ b/neethi/test/test-resources/services-3.xml
@@ -0,0 +1,88 @@
+<service name="SecureService3">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+
+	<wsp:Policy wsu:Id="SigEncr" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:InitiatorToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+									<wsp:Policy>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:InitiatorToken>
+						<sp:RecipientToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+									<wsp:Policy>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:RecipientToken>
+						<sp:AlgorithmSuite>
+							<wsp:Policy>
+								<sp:Basic256/>
+							</wsp:Policy>
+						</sp:AlgorithmSuite>
+						<sp:Layout>
+							<wsp:Policy>
+								<sp:Strict/>
+							</wsp:Policy>
+						</sp:Layout>
+						<sp:IncludeTimestamp/>
+						<sp:OnlySignEntireHeadersAndBody/>
+					</wsp:Policy>
+				</sp:AsymmetricBinding>
+				<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:MustSupportRefKeyIdentifier/>
+						<sp:MustSupportRefIssuerSerial/>
+					</wsp:Policy>
+				</sp:Wss10>
+				<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:SignedParts>
+				<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:EncryptedParts>
+
+				<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+					<ramp:user>alice</ramp:user>
+					<ramp:encryptionUser>bob</ramp:encryptionUser>
+					<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+					
+					<ramp:signatureCrypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:signatureCrypto>
+					<ramp:encryptionCypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:encryptionCypto>
+				</ramp:RampartConfig>
+
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+
+</service>
diff --git a/neethi/test/test-resources/services-4.xml b/neethi/test/test-resources/services-4.xml
new file mode 100644
index 0000000..537164f
--- /dev/null
+++ b/neethi/test/test-resources/services-4.xml
@@ -0,0 +1,89 @@
+<service name="SecureService4">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+
+<wsp:Policy wsu:Id="EncrSig" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:InitiatorToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:InitiatorToken>
+					<sp:RecipientToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:RecipientToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:Basic256/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Strict/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:EncryptBeforeSigning />
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:AsymmetricBinding>
+			<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+				</wsp:Policy>
+			</sp:Wss10>
+			<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:SignedParts>
+			<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:EncryptedParts>
+
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>alice</ramp:user>
+				<ramp:encryptionUser>bob</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+				<ramp:encryptionCypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:encryptionCypto>
+			</ramp:RampartConfig>
+
+		</wsp:All>
+	</wsp:ExactlyOne>
+</wsp:Policy>
+
+</service>
diff --git a/neethi/test/test-resources/services-5.xml b/neethi/test/test-resources/services-5.xml
new file mode 100644
index 0000000..64fcecb
--- /dev/null
+++ b/neethi/test/test-resources/services-5.xml
@@ -0,0 +1,89 @@
+<service name="SecureService5">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+	
+	<wsp:Policy wsu:Id="SigEncrDK" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:InitiatorToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+									<wsp:Policy>
+										<sp:RequireDerivedKeys/>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:InitiatorToken>
+						<sp:RecipientToken>
+							<wsp:Policy>
+								<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+									<wsp:Policy>
+										<sp:RequireDerivedKeys/>
+										<sp:WssX509V3Token10/>
+									</wsp:Policy>
+								</sp:X509Token>
+							</wsp:Policy>
+						</sp:RecipientToken>
+						<sp:AlgorithmSuite>
+							<wsp:Policy>
+								<sp:Basic256/>
+							</wsp:Policy>
+						</sp:AlgorithmSuite>
+						<sp:Layout>
+							<wsp:Policy>
+								<sp:Strict/>
+							</wsp:Policy>
+						</sp:Layout>
+						<sp:IncludeTimestamp/>
+						<sp:OnlySignEntireHeadersAndBody/>
+					</wsp:Policy>
+				</sp:AsymmetricBinding>
+				<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<wsp:Policy>
+						<sp:MustSupportRefKeyIdentifier/>
+						<sp:MustSupportRefIssuerSerial/>
+					</wsp:Policy>
+				</sp:Wss10>
+				<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:SignedParts>
+				<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+					<sp:Body/>
+				</sp:EncryptedParts>
+
+				<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+					<ramp:user>alice</ramp:user>
+					<ramp:encryptionUser>bob</ramp:encryptionUser>
+					<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+					
+					<ramp:signatureCrypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:signatureCrypto>
+					<ramp:encryptionCypto>
+						<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+							<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+						</ramp:crypto>
+					</ramp:encryptionCypto>
+				</ramp:RampartConfig>
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+
+</service>
diff --git a/neethi/test/test-resources/services-6.xml b/neethi/test/test-resources/services-6.xml
new file mode 100644
index 0000000..ff37936
--- /dev/null
+++ b/neethi/test/test-resources/services-6.xml
@@ -0,0 +1,86 @@
+<service name="SecureService6">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+	
+	<wsp:Policy wsu:Id="SigEncrTripleDesRSA15" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:InitiatorToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:InitiatorToken>
+					<sp:RecipientToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:RecipientToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:TripleDesRsa15/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Strict/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:AsymmetricBinding>
+			<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+				</wsp:Policy>
+			</sp:Wss10>
+			<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:SignedParts>
+			<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:EncryptedParts>
+
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>alice</ramp:user>
+				<ramp:encryptionUser>bob</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+				<ramp:encryptionCypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:encryptionCypto>
+			</ramp:RampartConfig>
+		</wsp:All>
+	</wsp:ExactlyOne>
+	</wsp:Policy>
+</service>
diff --git a/neethi/test/test-resources/services-7.xml b/neethi/test/test-resources/services-7.xml
new file mode 100644
index 0000000..b476623
--- /dev/null
+++ b/neethi/test/test-resources/services-7.xml
@@ -0,0 +1,89 @@
+<service name="SecureService7">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+	
+	<wsp:Policy wsu:Id="SigEncrTripleDesRSA15DK" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:InitiatorToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:RequireDerivedKeys/>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:InitiatorToken>
+					<sp:RecipientToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+								<wsp:Policy>
+									<sp:RequireDerivedKeys/>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:RecipientToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:TripleDesRsa15/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Strict/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:AsymmetricBinding>
+			<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+				</wsp:Policy>
+			</sp:Wss10>
+			<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:SignedParts>
+			<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:EncryptedParts>
+
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>alice</ramp:user>
+				<ramp:encryptionUser>bob</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+				<ramp:encryptionCypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:encryptionCypto>
+			</ramp:RampartConfig>
+
+		</wsp:All>
+	</wsp:ExactlyOne>
+	</wsp:Policy>
+</service>
diff --git a/neethi/test/test-resources/services-8.xml b/neethi/test/test-resources/services-8.xml
new file mode 100644
index 0000000..5e67653
--- /dev/null
+++ b/neethi/test/test-resources/services-8.xml
@@ -0,0 +1,89 @@
+<service name="SecureService8">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+	
+	<wsp:Policy wsu:Id="SigEncrTripleDesRSA15DK" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:InitiatorToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:RequireDerivedKeys/>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:InitiatorToken>
+					<sp:RecipientToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+								<wsp:Policy>
+									<sp:RequireDerivedKeys/>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:RecipientToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:TripleDesRsa15/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Strict/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:AsymmetricBinding>
+			<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+				</wsp:Policy>
+			</sp:Wss10>
+			<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:SignedParts>
+			<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:EncryptedParts>
+
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>alice</ramp:user>
+				<ramp:encryptionUser>useReqSigCert</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+				<ramp:encryptionCypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:encryptionCypto>
+			</ramp:RampartConfig>
+
+		</wsp:All>
+	</wsp:ExactlyOne>
+	</wsp:Policy>
+</service>
diff --git a/neethi/test/test-resources/services-9.xml b/neethi/test/test-resources/services-9.xml
new file mode 100644
index 0000000..fbf1eda
--- /dev/null
+++ b/neethi/test/test-resources/services-9.xml
@@ -0,0 +1,87 @@
+<service name="SecureService9">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+	
+	<wsp:Policy wsu:Id="SigEncrTripleDesRSA15" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:InitiatorToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:InitiatorToken>
+					<sp:RecipientToken>
+						<wsp:Policy>
+							<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+								<wsp:Policy>
+									<sp:WssX509V3Token10/>
+								</wsp:Policy>
+							</sp:X509Token>
+						</wsp:Policy>
+					</sp:RecipientToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:TripleDesRsa15/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Strict/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:EncryptSignature />
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:AsymmetricBinding>
+			<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+				</wsp:Policy>
+			</sp:Wss10>
+			<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:SignedParts>
+			<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:EncryptedParts>
+
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>alice</ramp:user>
+				<ramp:encryptionUser>bob</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+				<ramp:encryptionCypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:encryptionCypto>
+			</ramp:RampartConfig>
+		</wsp:All>
+	</wsp:ExactlyOne>
+	</wsp:Policy>
+</service>
diff --git a/neethi/test/test-resources/services-sc-1.xml b/neethi/test/test-resources/services-sc-1.xml
new file mode 100644
index 0000000..1bd254f
--- /dev/null
+++ b/neethi/test/test-resources/services-sc-1.xml
@@ -0,0 +1,176 @@
+<service name="SecureServiceSC1">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+	<module ref="rahas"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+
+	<wsp:Policy wsu:Id="SecConvPolicy1" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:SymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:ProtectionToken>
+						<wsp:Policy>
+							<sp:SecureConversationToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:RequireDerivedKeys/>
+									<sp:BootstrapPolicy>
+										<wsp:Policy wsu:Id="SigEncrTripleDesRSA15" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+										<wsp:ExactlyOne>
+											<wsp:All>
+												<sp:AsymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+													<wsp:Policy>
+														<sp:InitiatorToken>
+															<wsp:Policy>
+																<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+																	<wsp:Policy>
+																		<sp:WssX509V3Token10/>
+																	</wsp:Policy>
+																</sp:X509Token>
+															</wsp:Policy>
+														</sp:InitiatorToken>
+														<sp:RecipientToken>
+															<wsp:Policy>
+																<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+																	<wsp:Policy>
+																		<sp:WssX509V3Token10/>
+																	</wsp:Policy>
+																</sp:X509Token>
+															</wsp:Policy>
+														</sp:RecipientToken>
+														<sp:AlgorithmSuite>
+															<wsp:Policy>
+																<sp:TripleDesRsa15/>
+															</wsp:Policy>
+														</sp:AlgorithmSuite>
+														<sp:Layout>
+															<wsp:Policy>
+																<sp:Strict/>
+															</wsp:Policy>
+														</sp:Layout>
+														<sp:IncludeTimestamp/>
+														<sp:OnlySignEntireHeadersAndBody/>
+													</wsp:Policy>
+												</sp:AsymmetricBinding>
+												<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+													<wsp:Policy>
+														<sp:MustSupportRefKeyIdentifier/>
+														<sp:MustSupportRefIssuerSerial/>
+													</wsp:Policy>
+												</sp:Wss10>
+												<sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+													<sp:Body/>
+												</sp:SignedParts>
+												<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+													<sp:Body/>
+												</sp:EncryptedParts>
+											</wsp:All>
+										</wsp:ExactlyOne>
+										</wsp:Policy>
+									</sp:BootstrapPolicy>
+								</wsp:Policy>
+							</sp:SecureConversationToken>
+						</wsp:Policy>
+					</sp:ProtectionToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:Basic256/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Lax/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:EncryptSignature/>
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:SymmetricBinding>
+			<sp:Wss10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+				</wsp:Policy>
+			</sp:Wss10>
+			<sp:Trust10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportIssuedTokens/>
+					<sp:RequireClientEntropy/>
+					<sp:RequireServerEntropy/>
+				</wsp:Policy>
+			</sp:Trust10>
+			<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:EncryptedParts>
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>alice</ramp:user>
+				<ramp:encryptionUser>bob</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+				<ramp:encryptionCypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:encryptionCypto>
+			</ramp:RampartConfig>
+		</wsp:All>
+	</wsp:ExactlyOne>
+	</wsp:Policy>
+	
+    <parameter name="sct-issuer-config">
+		<sct-issuer-config>
+			<cryptoProperties>
+               <crypto provider="org.apache.ws.security.components.crypto.Merlin">
+                    <property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</property>
+                    <property name="org.apache.ws.security.crypto.merlin.file">sts.jks</property>
+                    <property name="org.apache.ws.security.crypto.merlin.keystore.password">password</property>
+                </crypto>
+			</cryptoProperties>
+			<addRequestedAttachedRef />
+			<addRequestedUnattachedRef />
+
+            <!--
+               Key computation mechanism
+               1 - Use Request Entropy
+               2 - Provide Entropy
+               3 - Use Own Key
+            -->
+            <keyComputation>3</keyComputation>
+
+            <!--
+               proofKeyType element is valid only if the keyComputation is set to 3
+               i.e. Use Own Key
+
+               Valid values are: EncryptedKey & BinarySecret
+            -->
+            <proofKeyType>BinarySecret</proofKeyType>
+        </sct-issuer-config>
+    </parameter>
+	
+	<parameter name="token-canceler-config">
+		<token-canceler-config>
+			<!--<proofToken>EncryptedKey</proofToken>-->
+			<!--<cryptoProperties>sctIssuer.properties</cryptoProperties>-->
+			<!--<addRequestedAttachedRef />-->
+		</token-canceler-config>
+    </parameter>
+	
+	
+</service>
diff --git a/neethi/test/test-resources/services-sc-2.xml b/neethi/test/test-resources/services-sc-2.xml
new file mode 100644
index 0000000..2d0febe
--- /dev/null
+++ b/neethi/test/test-resources/services-sc-2.xml
@@ -0,0 +1,186 @@
+<service name="SecureServiceSC2">
+
+	<module ref="addressing"/>
+	<module ref="rampart"/>
+	<module ref="rahas"/>
+
+	<parameter locked="false" name="ServiceClass">org.apache.rampart.Service</parameter>
+
+	<operation name="echo">
+		<messageReceiver class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/>
+		<actionMapping>urn:echo</actionMapping>
+	</operation>
+
+	<wsp:Policy wsu:Id="SecConvPolicy2" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
+	<wsp:ExactlyOne>
+		<wsp:All>
+			<sp:SymmetricBinding xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:ProtectionToken>
+						<wsp:Policy>
+							<sp:SecureConversationToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+								<wsp:Policy>
+									<sp:RequireDerivedKeys/>
+									<sp:BootstrapPolicy>
+										<wsp:Policy>
+											<sp:EncryptedParts>
+												<sp:Body/>
+											</sp:EncryptedParts>
+											<sp:SymmetricBinding>
+												<wsp:Policy>
+													<sp:ProtectionToken>
+														<wsp:Policy>
+															<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
+																<wsp:Policy>
+																	<sp:RequireDerivedKeys/>
+																	<sp:RequireThumbprintReference/>
+																	<sp:WssX509V3Token10/>
+																</wsp:Policy>
+															</sp:X509Token>
+														</wsp:Policy>
+													</sp:ProtectionToken>
+													<sp:AlgorithmSuite>
+														<wsp:Policy>
+															<sp:Basic128Rsa15/>
+														</wsp:Policy>
+													</sp:AlgorithmSuite>
+													<sp:Layout>
+														<wsp:Policy>
+															<sp:Strict/>
+														</wsp:Policy>
+													</sp:Layout>
+													<sp:IncludeTimestamp/>
+													<sp:EncryptSignature/>
+													<sp:OnlySignEntireHeadersAndBody/>
+												</wsp:Policy>
+											</sp:SymmetricBinding>
+											<sp:EndorsingSupportingTokens>
+												<wsp:Policy>
+													<sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+														<wsp:Policy>
+															<sp:RequireThumbprintReference/>
+															<sp:WssX509V3Token10/>
+														</wsp:Policy>
+													</sp:X509Token>
+												</wsp:Policy>
+											</sp:EndorsingSupportingTokens>
+											<sp:Wss11>
+												<wsp:Policy>
+													<sp:MustSupportRefKeyIdentifier/>
+													<sp:MustSupportRefIssuerSerial/>
+													<sp:MustSupportRefThumbprint/>
+													<sp:MustSupportRefEncryptedKey/>
+													<sp:RequireSignatureConfirmation/>
+												</wsp:Policy>
+											</sp:Wss11>
+											<sp:Trust10>
+												<wsp:Policy>
+													<sp:MustSupportIssuedTokens/>
+													<sp:RequireClientEntropy/>
+													<sp:RequireServerEntropy/>
+												</wsp:Policy>
+											</sp:Trust10>
+										</wsp:Policy>
+									</sp:BootstrapPolicy>
+								</wsp:Policy>
+							</sp:SecureConversationToken>
+						</wsp:Policy>
+					</sp:ProtectionToken>
+					<sp:AlgorithmSuite>
+						<wsp:Policy>
+							<sp:Basic128Rsa15/>
+						</wsp:Policy>
+					</sp:AlgorithmSuite>
+					<sp:Layout>
+						<wsp:Policy>
+							<sp:Strict/>
+						</wsp:Policy>
+					</sp:Layout>
+					<sp:IncludeTimestamp/>
+					<sp:EncryptSignature/>
+					<sp:OnlySignEntireHeadersAndBody/>
+				</wsp:Policy>
+			</sp:SymmetricBinding>
+			<sp:Wss11 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportRefKeyIdentifier/>
+					<sp:MustSupportRefIssuerSerial/>
+					<sp:MustSupportRefThumbprint/>
+					<sp:MustSupportRefEncryptedKey/>
+				</wsp:Policy>
+			</sp:Wss11>
+			<sp:Trust10 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<wsp:Policy>
+					<sp:MustSupportIssuedTokens/>
+					<sp:RequireClientEntropy/>
+					<sp:RequireServerEntropy/>
+				</wsp:Policy>
+			</sp:Trust10>
+			<sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+				<sp:Body/>
+			</sp:EncryptedParts>
+			<ramp:RampartConfig xmlns:ramp="http://ws.apache.org/rampart/policy"> 
+				<ramp:user>bob</ramp:user>
+				<ramp:encryptionUser>alice</ramp:encryptionUser>
+				<ramp:passwordCallbackClass>org.apache.rampart.PWCallback</ramp:passwordCallbackClass>
+				
+				<ramp:signatureCrypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:signatureCrypto>
+				<ramp:encryptionCypto>
+					<ramp:crypto provider="org.apache.ws.security.components.crypto.Merlin">
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.file">store.jks</ramp:property>
+						<ramp:property name="org.apache.ws.security.crypto.merlin.keystore.password">password</ramp:property>
+					</ramp:crypto>
+				</ramp:encryptionCypto>
+				
+			</ramp:RampartConfig>
+		</wsp:All>
+	</wsp:ExactlyOne>
+	</wsp:Policy>
+	
+    <parameter name="sct-issuer-config">
+		<sct-issuer-config>
+			<cryptoProperties>
+               <crypto provider="org.apache.ws.security.components.crypto.Merlin">
+                    <property name="org.apache.ws.security.crypto.merlin.keystore.type">JKS</property>
+                    <property name="org.apache.ws.security.crypto.merlin.file">sts.jks</property>
+                    <property name="org.apache.ws.security.crypto.merlin.keystore.password">password</property>
+                </crypto>
+			</cryptoProperties>
+			<addRequestedAttachedRef />
+			<addRequestedUnattachedRef />
+
+            <!--
+               Key computation mechanism
+               1 - Use Request Entropy
+               2 - Provide Entropy
+               3 - Use Own Key
+            -->
+            <keyComputation>3</keyComputation>
+
+            <!--
+               proofKeyType element is valid only if the keyComputation is set to 3
+               i.e. Use Own Key
+
+               Valid values are: EncryptedKey & BinarySecret
+            -->
+            <proofKeyType>BinarySecret</proofKeyType>
+        </sct-issuer-config>
+    </parameter>
+	
+	<parameter name="token-canceler-config">
+		<token-canceler-config>
+			<!--<proofToken>EncryptedKey</proofToken>-->
+			<!--<cryptoProperties>sctIssuer.properties</cryptoProperties>-->
+			<!--<addRequestedAttachedRef />-->
+		</token-canceler-config>
+    </parameter>
+	
+	
+</service>
diff --git a/neethi/test/test.c b/neethi/test/test.c
new file mode 100644
index 0000000..9585599
--- /dev/null
+++ b/neethi/test/test.c
@@ -0,0 +1,239 @@
+#include <axiom.h>
+#include <axutil_utils.h>
+#include <axutil_env.h>
+#include <axutil_log_default.h>
+#include <axutil_error_default.h>
+#include <stdio.h>
+#include <axiom_xml_reader.h>
+#include <neethi_engine.h>
+#include <axutil_array_list.h>
+
+axis2_status_t AXIS2_CALL om_node_serialize(
+    axiom_node_t * node,
+    const axutil_env_t * env);
+
+int
+main(
+    int argc,
+    char **argv)
+{
+    /*axutil_allocator_t *allocator = axutil_allocator_init(NULL);
+    axutil_error_t *error = axutil_error_create(allocator);
+    const axutil_env_t *env = axutil_env_create_with_error(allocator, error);*/
+    const axutil_env_t *env = NULL;
+    axiom_xml_reader_t *reader = NULL;
+    axiom_stax_builder_t *builder = NULL;
+    axiom_document_t *document = NULL;
+    axiom_node_t *root = NULL;
+    axiom_element_t *root_ele = NULL;
+
+    env = axutil_env_create_all("test.log", AXIS2_LOG_LEVEL_TRACE);
+
+    reader = axiom_xml_reader_create_for_file(env, argv[1], NULL);
+
+    if (!reader)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
+                        AXIS2_FAILURE);
+        printf("xml reader creation failed\n");
+        return 0;
+    }
+
+    builder = axiom_stax_builder_create(env, reader);
+    if (!builder)
+    {
+        axiom_xml_reader_free(reader, env);
+        printf("Builder creation failed\n");
+        return 0;
+    }
+    document = axiom_stax_builder_get_document(builder, env);
+    if (!document)
+    {
+        axiom_stax_builder_free(builder, env);
+        printf("Document creation failed\n");
+        return 0;
+    }
+
+    /*root = axiom_document_get_root_element(document, env); */
+    root = axiom_document_build_all(document, env);
+    if (!root)
+    {
+        axiom_stax_builder_free(builder, env);
+        return 0;
+    }
+
+    if (root)
+    {
+        if (axiom_node_get_node_type(root, env) == AXIOM_ELEMENT)
+        {
+            root_ele =
+                (axiom_element_t *) axiom_node_get_data_element(root, env);
+            if (root_ele)
+            {
+                neethi_policy_t *neethi_policy = NULL;
+                neethi_policy = neethi_engine_get_policy(env, root, root_ele);
+                if (!neethi_policy)
+                {
+                    printf("Policy Creation fails\n");
+                    return 0;
+                }
+
+                if(neethi_policy)
+                {
+                    axis2_char_t *id = NULL;
+                    axis2_char_t *name = NULL;
+
+                    id = neethi_policy_get_id(neethi_policy, env); 
+                    if(id)
+                    {
+                        printf("Id is : %s\n", id);
+                    }   
+                    name = neethi_policy_get_name(neethi_policy, env);
+                    if(name)
+                    {
+                        printf("Name is : %s\n", name);
+                    }
+                    neethi_policy_free(neethi_policy, env);
+                    neethi_policy = NULL;
+
+                    printf("Successful \n");
+                }
+
+                /*else
+                {
+                    axiom_node_t *s_node = NULL;
+                    s_node = neethi_engine_serialize(neethi_policy, env);
+                    if (!s_node)
+                    {
+                        printf("Serializing failed\n");
+                        return 0;
+                    }
+                    if (om_node_serialize(s_node, env) != AXIS2_SUCCESS)
+                        return 0;
+                }*/
+            }
+        }
+    }
+
+    if(builder)
+    {
+        axiom_stax_builder_free(builder, env);
+        builder = NULL;
+    }
+
+    axutil_env_free((axutil_env_t *)env);
+    env = NULL;    
+
+    printf("Successful\n");
+    return 0;
+
+}
+
+axis2_status_t AXIS2_CALL
+om_node_serialize(
+    axiom_node_t * node,
+    const axutil_env_t * env)
+{
+
+    axiom_output_t *om_output = NULL;
+    axiom_xml_writer_t *writer = NULL;
+    axis2_char_t *output_buffer = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+
+    writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
+                                                AXIS2_XML_PARSER_TYPE_BUFFER);
+    om_output = axiom_output_create(env, writer);
+
+    status = axiom_node_serialize(node, env, om_output);
+    if (status != AXIS2_SUCCESS)
+    {
+        printf("\naxiom_node_serialize failed\n");
+        return 0;
+    }
+    else
+        printf("\naxiom_node_serialize success\n");
+    /* end serializing stuff */
+
+    /*axiom_node_free_tree(node1, environment); */
+    output_buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, env);
+
+    printf("\nend test_om_serialize\n");
+
+    return AXIS2_SUCCESS;
+
+}
+
+axutil_array_list_t *AXIS2_CALL
+load_policy_array(
+    int argc,
+    char **argv,
+    const axutil_env_t * env)
+{
+
+    axiom_xml_reader_t *reader = NULL;
+    axiom_stax_builder_t *builder = NULL;
+    axiom_document_t *document = NULL;
+    axiom_node_t *root = NULL;
+    axiom_element_t *root_ele = NULL;
+    int i = 0;
+    axutil_array_list_t *arraylist = NULL;
+
+    arraylist = axutil_array_list_create(env, 0);
+
+    for (i = 1; i < argc; i++)
+    {
+        reader = axiom_xml_reader_create_for_file(env, argv[i], NULL);
+
+        if (!reader)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER,
+                            AXIS2_FAILURE);
+            printf("xml reader creation failed\n");
+            return NULL;
+        }
+
+        builder = axiom_stax_builder_create(env, reader);
+        if (!builder)
+        {
+            axiom_xml_reader_free(reader, env);
+            printf("Builder creation failed\n");
+            return NULL;
+        }
+        document = axiom_stax_builder_get_document(builder, env);
+        if (!document)
+        {
+            axiom_stax_builder_free(builder, env);
+            printf("Document creation failed\n");
+            return NULL;
+        }
+
+        /*root = axiom_document_get_root_element(document, env); */
+        root = axiom_document_build_all(document, env);
+        if (!root)
+        {
+            axiom_stax_builder_free(builder, env);
+            return NULL;
+        }
+        if (root)
+        {
+            if (axiom_node_get_node_type(root, env) == AXIOM_ELEMENT)
+            {
+                root_ele =
+                    (axiom_element_t *) axiom_node_get_data_element(root, env);
+                if (root_ele)
+                {
+                    neethi_policy_t *neethi_policy = NULL;
+                    neethi_policy =
+                        neethi_engine_get_policy(env, root, root_ele);
+                    if (!neethi_policy)
+                    {
+                        printf("Policy Creation fails\n");
+                        return NULL;
+                    }
+                    axutil_array_list_add(arraylist, env, neethi_policy);
+                }
+            }
+        }
+    }
+    return arraylist;
+}